diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 0000000..165dae7 --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,6 @@ +ARG VARIANT="3.11-bookworm" +# INFO, full list of python devcontainers available: + # https://mcr.microsoft.com/v2/vscode/devcontainers/python/tags/list +FROM mcr.microsoft.com/vscode/devcontainers/python:${VARIANT} + +ENV PATH="/home/vscode/.local/bin:${PATH}" diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 0000000..31b0c3e --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,54 @@ +{ +"name": "Python 3", +"build": { +"dockerfile": "Dockerfile", +"context": "..", +"args": { +"VARIANT": "3.11-bookworm" +} +}, +"customizations": { +"vscode": { +"settings": { +"python.defaultInterpreterPath": "/workspaces/tutorial-group-1/.venv/bin/python", +"python.terminal.activateEnvironment": true, +"python.testing.pytestArgs": [ +"tests" +], +"python.testing.pytestEnabled": true, +"python.testing.unittestEnabled": false, +"python.testing.pytestPath": "/workspaces/tutorial-group-1/.venv/bin/pytest" +}, +"extensions": [ +"bierner.markdown-mermaid", +"charliermarsh.ruff", +"EditorConfig.EditorConfig", +"github.vscode-github-actions", +"ms-toolsai.jupyter", +"ms-toolsai.jupyter-keymap", +"ms-toolsai.jupyter-renderers", +"ms-python.python", +"ms-python.vscode-pylance", +"ms-toolsai.vscode-jupyter-cell-tags", +"ms-toolsai.vscode-jupyter-slideshow", +"ms-vsliveshare.vsliveshare", +"ryanluker.vscode-coverage-gutters" +] +} +}, +"forwardPorts": [ +8888 +], +"portsAttributes": { +"8888": { +"label": "Jupyter Notebook" +} +}, +"updateContentCommand": "git config --global --add safe.directory /workspaces/tutorial-group-1; make create_venv; echo 'NOTE: PyTorch is NOT installed by default. To install PyTorch (CPU-only), run: source .venv/bin/activate && make install-torch'", +"postCreateCommand": "echo 'source /workspaces/tutorial-group-1/.venv/bin/activate' >> ~/.bashrc; echo 'echo -e \"\\n⚠️ IMPORTANT: PyTorch is not installed by default due to size constraints.\"' >> ~/.bashrc; echo 'echo \"To install PyTorch (CPU-only ~730MB), run:\"' >> ~/.bashrc; echo 'echo \" source .venv/bin/activate && make install-torch\"' >> ~/.bashrc", +"remoteUser": "root", +"features": { +"git": "latest", +"github-cli": "latest" +} +} diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..dfe0770 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +# Auto detect text files and perform LF normalization +* text=auto diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml new file mode 100644 index 0000000..4611cd4 --- /dev/null +++ b/.github/workflows/main.yml @@ -0,0 +1,35 @@ +name: Linting +on: + push: + branches: + - main + pull_request: + branches: + - main + +permissions: + contents: read + +jobs: + lint: + name: Linting (Python ${{ matrix.python-version }}) + runs-on: ubuntu-latest + strategy: + fail-fast: true + matrix: + python-version: ['3.11'] + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python3 -m pip install --upgrade pip + pip install -e .[dev] + # Install PyTorch CPU-only version for CI + pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu + - name: Linting with pre-commit + run: pre-commit run --all-files diff --git a/.github/workflows/render-notebook.yml b/.github/workflows/render-notebook.yml new file mode 100644 index 0000000..fcc41ce --- /dev/null +++ b/.github/workflows/render-notebook.yml @@ -0,0 +1,57 @@ +name: Render Notebook to HTML + +on: + push: + branches: + - main + paths: + - 'notebooks/tutorial_few_shot_learning.ipynb' + pull_request: + branches: + - main + paths: + - 'notebooks/tutorial_few_shot_learning.ipynb' + workflow_dispatch: + +permissions: + contents: write + +jobs: + render: + runs-on: ubuntu-latest + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' + + - name: Install dependencies + run: | + python3 -m pip install --upgrade pip + pip install nbconvert jupyter + + - name: Convert notebook to HTML + run: | + jupyter nbconvert \ + --to html \ + notebooks/tutorial_few_shot_learning.ipynb \ + --output tutorial_few_shot_learning.html \ + --output-dir docs/ + + # Only commit on push to main, NOT on PRs + - name: Commit rendered HTML + if: github.event_name == 'push' && github.ref == 'refs/heads/main' + run: | + git config --local user.email "github-actions[bot]@users.noreply.github.com" + git config --local user.name "github-actions[bot]" + git add docs/tutorial_few_shot_learning.html + if ! git diff --staged --quiet; then + git commit -m "Auto-render notebook to HTML [skip ci]" + git push + else + echo "No changes to commit" + fi diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8ccee1b --- /dev/null +++ b/.gitignore @@ -0,0 +1,156 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ +data/ + +.DS_Store \ No newline at end of file diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..4e1863c --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,65 @@ +# pre-commit: A framework for managing and maintaining multi-language pre-commit hooks +# after configuration is complete, do these steps: + # pre-commit install + # pre-commit run --all-files +# to skip pre-commmit-config when git-committing in terminal, add this: "--no-verify" option. + +ci: + autoupdate_commit_msg: "chore: update pre-commit hooks" + autofix_commit_msg: "style: pre-commit fixes" + +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.5.0 + hooks: + - id: check-added-large-files + stages: [manual] + - id: check-case-conflict + stages: [manual] + - id: check-merge-conflict + stages: [manual] + - id: check-symlinks + stages: [manual] + - id: mixed-line-ending + stages: [manual] + - id: name-tests-test + stages: [manual] + args: [--pytest-test-first] + # pygrep-hooks: a collection of fast, cheap, regex based pre-commit hooks + - repo: https://github.com/pre-commit/pygrep-hooks + rev: v1.10.0 + hooks: + - id: python-no-log-warn + stages: [manual] + - id: python-no-eval + stages: [manual] + exclude: ^src/few_shot_utils/(train|evaluate)\.py$ + - id: rst-directive-colons + stages: [manual] + - id: rst-inline-touching-normal + stages: [manual] + # check-manifest: This makes sense only if you have MANIFEST.in (TODO:review) + - repo: https://github.com/mgedmin/check-manifest + rev: "0.47" + hooks: + - id: check-manifest + stages: [manual] + # pip audit to check for known pip vulnerabilities, supports pyproject.toml + - repo: https://github.com/pypa/pip-audit + rev: v2.7.1 + hooks: + - id: pip-audit + stages: [manual] + #Ruff linter and formatter + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.8.2 + hooks: + # Recommended to run linter first of automatic fixes are enabled (as some linting fixes might require reformatting) + - id: ruff + #Automatic linting fixes + types_or: [ python, pyi, jupyter ] + args: [ --fix ] + stages: [manual] + - id: ruff-format + types_or: [ python, pyi, jupyter ] + stages: [manual] diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..f0738b5 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,12 @@ +{ + "files.trimTrailingWhitespace": true, + "git.autofetch": true, + "[jsonc]": {"editor.defaultFormatter": "vscode.json-language-features"}, + "[python]": { + "editor.defaultFormatter": "charliermarsh.ruff", + "editor.formatOnSave": false + }, + "[jupyter]": { + "editor.defaultFormatter": "charliermarsh.ruff" + } +} diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..72c37e1 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,30 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "create_venv", + "type": "shell", + "command": "make", + "args": ["create_venv"], + "group": { + "kind": "build", + "isDefault": true + }, + "presentation": { + "reveal": "always", + "panel": "new" + } + }, + { + "label": "run_tests", + "type": "shell", + "command": "make", + "args": ["run_pytest_with_cov"], + "group": "test", + "presentation": { + "reveal": "always", + "panel": "new" + } + } + ] +} diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..727a39b --- /dev/null +++ b/Makefile @@ -0,0 +1,36 @@ +SHELL := /bin/bash + +.PHONY: create_venv install install-torch lint help + +help: + @echo "Available targets:" + @echo " create_venv - Create virtual environment and install dependencies (without torch)" + @echo " install - Install package with dev dependencies (without torch)" + @echo " install-torch - Install PyTorch CPU-only version" + @echo " lint - Run pre-commit hooks on all files" + +create_venv: + @echo "Creating virtual environment..." + python3 -m venv .venv + @echo "Installing dependencies (without torch)..." + .venv/bin/python3 -m pip install --upgrade pip + .venv/bin/pip install -e .[dev] + @echo "" + @echo "Virtual environment created successfully!" + @echo "To install PyTorch (CPU-only), run: make install-torch" + @echo "Or manually install with:" + @echo " pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu" + +install: + python3 -m pip install --upgrade pip + pip install -e .[dev] + @echo "Dependencies installed (without torch)." + @echo "To install PyTorch (CPU-only), run: make install-torch" + +install-torch: + @echo "Installing PyTorch CPU-only version..." + pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu + @echo "PyTorch installed successfully!" + +lint: + pre-commit run --all-files diff --git a/README.md b/README.md index 964def5..b4bc4f8 100644 --- a/README.md +++ b/README.md @@ -1,36 +1,126 @@ -# Deep Learning E1394 - Tutorial - -## Submitting your work - -Once the deadline has passed, you are not able to push to your repository anymore or update it in any other way and all changes on the main branch will be considered for grading. In other words, there is no "submit" button which you need to press. You just need to ensure that all your work has been pushed / uploaded to GitHub before the deadline. - -Uploading a new or edited file to GitHub involves three steps: -1. Add the file to the staging area: - ``` - git add - ``` -2. Create a commit: - ``` - git commit -m - ``` -3. Push the local commit to GitHub: - ``` - git push - ``` - -To avoid conflicts when multiple people are working on the same file, we recommend to push your changes as frequently as possible and always pull the latest changes from GitHub before you start working. Also, as a nice teammate, test your changes before you push them and use meaninful commit messages to make it easy to understand your changes. - -## Asking for help - -If you have important questions or believe to have spotted an error, please open an issue on your repository and mention the teaching assistant with @chiara-fb and @henrycgbaker. - -## Useful Links -* Git best practices: https://gist.github.com/luismts/495d982e8c5b1a0ced4a57cf3d93cf60 -* How to write a good git commit message: https://cbea.ms/git-commit/ -* Book "Dive into Deep Learning": https://d2l.ai/ -* Tutorial on pushing and submitting work with GitHub classroom: https://www.youtube.com/watch?v=jXpT8eOzzCM -* Neural network from scratch: - * https://towardsdatascience.com/math-neural-network-from-scratch-in-python-d6da9f29ce65 - * https://pythonalgos.com/create-a-neural-network-from-scratch-in-python-3/ - * https://github.com/casperbh96/Neural-Network-From-Scratch/blob/master/NN_From_Scratch.ipynb - * https://www.codingame.com/playgrounds/59631/neural-network-xor-example-from-scratch-no-libs +# Few-Shot Learning for Rooftop Detection in Satellite Imagery +### GRAD-E1394 Deep Learning + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/hertie-data-science-lab/tutorial-new-tutorial-group-1/blob/elena-setup/notebooks/tutorial_few_shot_learning.ipynb) + + +**Author(s):** Elena Dreyer, Giorgio Coppola, Nadine Daum, Nicolas Reichardt + +## Tutorial Overview + +This tutorial demonstrates few-shot learning techniques for semantic segmentation of satellite imagery. The dataset contains high-resolution satellite images of Geneva, Switzerland, with corresponding segmentation labels for rooftop detection. + +πŸ““ **[View Tutorial Notebook (HTML)](docs/tutorial_few_shot_learning.html)** + +### Learning Outcomes +- Understanding few-shot learning concepts for image segmentation +- Working with satellite imagery and segmentation masks +- Implementing and evaluating few-shot learning models for rooftop detection + +## Video Tutorial + + +[![Tutorial Video](https://img.youtube.com/vi/VIDEO_ID/0.jpg)](https://www.youtube.com/watch?v=VIDEO_ID) + +*Click the image above to watch the tutorial video* + +## Quick Start + +### Installation + +```bash +# Clone the repository +git clone https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1.git +cd tutorial-group-1 + +# Create virtual environment +python3 -m venv .venv +source .venv/bin/activate + +# Install the package (without PyTorch) +pip install -e . + +# Install PyTorch (CPU-only version recommended to save disk space) +# CPU-only: ~730MB vs CUDA version: ~7GB +pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu + +# Or use the Makefile +make install +make install-torch +``` + +**Note:** PyTorch is not installed by default due to its large size. The CPU-only version is recommended for most use cases and saves significant disk space. + +### Running the Tutorial + +Open the main tutorial notebook: +```bash +jupyter notebook notebooks/tutorial_few_shot_learning.ipynb +``` + +## Project Structure + +``` +β”œβ”€β”€ notebooks/ +β”‚ └── tutorial_few_shot_learning.ipynb # Main tutorial notebook +β”œβ”€β”€ src/few_shot_utils/ +β”‚ β”œβ”€β”€ __init__.py # Package initialization +β”‚ β”œβ”€β”€ data.py # Data loading utilities +β”‚ β”œβ”€β”€ models.py # Model architectures +β”‚ β”œβ”€β”€ train.py # Training functions +β”‚ └── evaluate.py # Evaluation metrics +└── docs/ # Documentation +``` + +## Dataset Description + +The dataset consists of: +- **Satellite Images**: High-resolution RGB satellite images of Geneva, Switzerland +- **Segmentation Labels**: Binary masks indicating rooftop locations +- **Resolution**: Images at various resolutions suitable for few-shot learning + +## Development + +### Linting and Formatting + +This project uses [Ruff](https://docs.astral.sh/ruff/) for linting and formatting, including Jupyter notebooks. + +```bash +# Run linting with automatic fixes +ruff check . --fix +ruff format . + +# Run pre-commit hooks +pre-commit run --all-files +``` + +## References + +- Alsentzer, E., Li, M. M., Kobren, S. N., Noori, A., Undiagnosed Diseases Network, Kohane, I. S., & Zitnik, M. (2025). *Few shot learning for phenotype-driven diagnosis of patients with rare genetic diseases*. npj Digital Medicine, 8(1), 380. https://doi.org/10.1038/s41746-025-01749-1 + +- Castello, R., Walch, A., Attias, R., Cadei, R., Jiang, S., & Scartezzini, J.-L. (2021). *Quantification of the suitable rooftop area for solar panel installation from overhead imagery using convolutional neural networks*. Journal of Physics: Conference Series, 2042(1), 012002. https://doi.org/10.1088/1742-6596/2042/1/012002 + +- Chen, Y., Wei, C., Wang, D., Ji, C., & Li, B. (2022). *Semi-supervised contrastive learning for few-shot segmentation of remote sensing images*. Remote Sensing, 14(17), 4254. https://doi.org/10.3390/rs14174254 + +- Finn, C., Abbeel, P., & Levine, S. (2017). *Model-agnostic meta-learning for fast adaptation of deep networks*. In International Conference on Machine Learning (pp. 1126–1135). PMLR. https://doi.org/10.48550/arXiv.1703.03400 + +- Ge, Z., Fan, X., Zhang, J., & Jin, S. (2025). *SegPPD-FS: Segmenting plant pests and diseases in the wild using few-shot learning*. Plant Phenomics, 100121. https://doi.org/10.1016/j.plaphe.2025.100121 + +- Hu, Y., Liu, C., Li, Z., Xu, J., Han, Z., & Guo, J. (2022). *Few-shot building footprint shape classification with relation network*. ISPRS International Journal of Geo-Information, 11(5), 311. https://doi.org/10.3390/ijgi11050311 + +- Jadon, S. (2021, February). *COVID-19 detection from scarce chest x-ray image data using few-shot deep learning approach*. In Medical Imaging 2021: Imaging Informatics for Healthcare, Research, and Applications (Vol. 11601, pp. 161–170). SPIE. https://doi.org/10.1117/12.2581496 + +- Lee, G. Y., Dam, T., Ferdaus, M. M., Poenar, D. P., & Duong, V. (2025). *Enhancing Few-Shot Classification of Benchmark and Disaster Imagery with ATTBHFA-Net*. arXiv preprint arXiv:2510.18326. https://doi.org/10.48550/arXiv.2510.18326 + +- Li, X., He, Z., Zhang, L., Guo, S., Hu, B., & Guo, K. (2025). *CDCNet: Cross-domain few-shot learning with adaptive representation enhancement*. Pattern Recognition, 162, 111382. https://doi.org/10.1016/j.patcog.2025.111382 + +- Puthumanaillam, G., & Verma, U. (2023). *Texture based prototypical network for few-shot semantic segmentation of forest cover: Generalizing for different geographical regions*. Neurocomputing, 538, 126201. https://doi.org/10.1016/j.neucom.2023.03.062 + +- Snell, J., Swersky, K., & Zemel, R. (2017). *Prototypical networks for few-shot learning*. Advances in Neural Information Processing Systems, 30. https://doi.org/10.48550/arXiv.1703.05175 + +- Sung, F., Yang, Y., Zhang, L., Xiang, T., Torr, P. H., & Hospedales, T. M. (2018). *Learning to compare: Relation network for few-shot learning*. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 1199–1208). https://doi.org/10.1109/CVPR.2018.00131 + + +## License + +This project is licensed under the MIT License - see the LICENSE file for details. diff --git a/dataset_strategy_comparison.md b/dataset_strategy_comparison.md new file mode 100644 index 0000000..4ce596c --- /dev/null +++ b/dataset_strategy_comparison.md @@ -0,0 +1,525 @@ +# Dataset Strategy Comparison for Few-Shot Rooftop Segmentation Tutorial + +**Goal**: Compare three different dataset strategies for teaching few-shot learning for rooftop/building segmentation. + +#### ATTENTION: This document is AI generated, and should be used as a checklist / orientative document. Information have been checked, and should be acceptably accurate. + +--- + +## Executive Summary + +| Strategy | Complexity | Realism | Tutorial Clarity | Implementation Effort | Recommendation | +|----------|------------|---------|------------------|----------------------|----------------| +| **Geneva + Inria** | Medium | High | ⭐⭐⭐⭐⭐ | Medium | **Best for education** | +| **Only Inria** | Low-Medium | Medium-High | ⭐⭐⭐⭐ | Low | **Best for simplicity** | +| **Only RID** | High | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | High | **Best for realism** | + +**Quick Recommendation**: +- **For teaching fundamentals**: Use Geneva + Inria (Strategy 1) +- **For quick implementation**: Use Only Inria (Strategy 2) +- **For real-world impact**: Use Only RID (Strategy 3) + +--- + +## Dataset Deep Dive + +### Geneva Satellite Dataset +**Source**: HuggingFace (`raphaelattias/overfitteam-geneva-satellite-images`) + +**Key Facts**: +- **Size**: 1,050 labeled image-mask pairs +- **Task**: Binary segmentation (rooftop vs background) +- **Geographic splits**: 3 grids (1301_11, 1301_13, 1301_31) +- **Image size**: 250x250 pixels +- **Categories**: All, Industrial, Residential +- **Characteristics**: Single city, well-defined geographic regions + +**Strengths**: +- βœ… Clean binary task +- βœ… Built-in geographic splits +- βœ… Easy to use (already on HuggingFace) +- βœ… Good size for tutorial (not too large) +- βœ… Clear within-city domain shift + +**Limitations**: +- ❌ Only one city +- ❌ Relatively small compared to others +- ❌ Simple task (binary only) + +--- + +### Inria Aerial Image Dataset +**Source**: https://project.inria.fr/aerialimagelabeling/ +**HuggingFace**: `Jonathan/INRIA-Aerial-Dataset` + +**Key Facts**: +- **Size**: 360 images (180 train + 180 test) +- **Coverage**: 180 kmΒ² across 5 cities +- **Cities**: + - **Austin, Texas** (US) - Suburban sprawl + - **Chicago, Illinois** (US) - Dense urban + - **Kitsap County, Washington** (US) - Rural/suburban + - **Vienna, Austria** (EU) - European urban + - **Tyrol-Innsbruck, Austria** (EU) - Mountain town +- **Task**: Binary segmentation (building vs background) +- **Image size**: 5000x5000 pixels (need tiling) +- **Resolution**: 0.3m per pixel + +**Strengths**: +- βœ… Multiple cities (5 different domains) +- βœ… Geographic diversity (US + Europe) +- βœ… Urban diversity (dense city, suburban, rural) +- βœ… Large coverage area +- βœ… Same task as Geneva (binary) +- βœ… Well-documented benchmark dataset +- βœ… Freely available + +**Limitations**: +- ❌ Large file sizes +- ❌ Only building footprints (not roof-specific) +- ❌ Fixed train/test split per city + +**City Characteristics**: +``` +Austin: Large, low-density sprawl, similar-looking houses +Chicago: Dense urban, varied building types, tall buildings +Kitsap: Rural/suburban, scattered buildings, trees +Vienna: European architecture, moderate density, distinct style +Tyrol: Mountain town, alpine architecture, complex terrain +``` + +--- + +### RID - Roof Information Dataset +**Source**: mediaTUM (TUM) + GitHub (https://github.com/TUMFTM/RID) + +**Key Facts**: +- **Size**: 1,880 images (+ 26 for annotation experiment) +- **Task 1**: Roof segments - 18 classes + - Background + 16 azimuth directions (N, NNE, NE, ENE, E, ...) + Flat +- **Task 2**: Roof superstructures - Multiple classes + - PV modules, windows, chimneys, dormer windows, etc. +- **Image source**: Google Maps Static API (georeferenced) +- **Cities**: Multiple (not explicitly listed, but multi-city dataset) +- **Split**: 1880 images with train/val/test splits provided + +**Strengths**: +- βœ… **Directly relevant**: Designed for solar panel assessment +- βœ… **Multi-class**: More realistic task complexity +- βœ… **Rich annotations**: Both segments and superstructures +- βœ… **Large size**: 1,880 images +- βœ… **Quality control**: Reviewed annotations, multiple labelers +- βœ… **Practical application**: Real-world solar potential assessment +- βœ… **Code available**: GitHub repo with data preparation + +**Limitations**: +- ❌ **Complex**: Multi-class segmentation harder to learn +- ❌ **Google Maps imagery**: Different from satellite (closer, angled) + +**Task Complexity Comparison**: +``` +Geneva: 2 classes (rooftop, background) +Inria: 2 classes (building, background) +RID-S: 18 classes (16 directions + flat + background) +RID-SS: ~10 classes (PV, window, chimney, dormer, ...) +``` +--- + +## Strategy 1: Geneva + Inria + +### Overview +Use Geneva as base dataset, Inria cities as cross-city transfer targets. + +### Task Structure +``` +Phase 1: Within-City Transfer (Geneva) +β”œβ”€ Train: Grid 1301_11 (295 images) +β”œβ”€ Test: Grid 1301_13 (76 images) - Different neighborhood +└─ Test: Grid 1301_31 (49 images) - Different neighborhood + +Phase 2: Cross-City Transfer (Geneva β†’ Inria) +β”œβ”€ Train: Grid 1301_11 (Geneva) +β”œβ”€ Test: Vienna (European, similar to Geneva) +β”œβ”€ Test: Austin (US suburban, different architecture) +└─ Optional: Chicago, Kitsap, Tyrol (varying difficulty) +``` + +### Few-Shot Setup +**Training** (on Geneva Grid 1301_11): +- Fine-tuning baseline: Standard supervised learning +- Prototypical Networks: Episodic training (K=3-5 per episode) +- PANet: Episodic training with MAP + +**Evaluation** (on target domains): +```python +For each target (1301_13, 1301_31, Vienna, Austin): + For K in [1, 3, 5, 10, 20]: + # Select K support examples from target + support_set = random_sample(target_data, K) + query_set = remaining_data + + # Apply method + predictions = method.predict(support_set, query_set) + + # Evaluate + iou = compute_iou(predictions, query_masks) +``` + +### Expected Domain Shift +``` +Geneva 1301_11 β†’ Geneva 1301_13: SMALL (same city, diff neighborhood) +Geneva 1301_11 β†’ Geneva 1301_31: SMALL-MEDIUM (different area) +Geneva 1301_11 β†’ Vienna: MEDIUM (Euroβ†’Euro, diff city) +Geneva 1301_11 β†’ Austin: LARGE (Euroβ†’US, diff architecture) +``` + +### Advantages +βœ… **Progressive difficulty**: Small β†’ Large domain shift +βœ… **Same task throughout**: Binary segmentation +βœ… **Clear learning progression**: Students see increasing challenge +βœ… **Multiple test cases**: 5 target domains (2 Geneva + 3 Inria) +βœ… **Well-documented**: Both datasets established +βœ… **Best for teaching**: Clear concept progression + +### Disadvantages +❌ **Two datasets**: More setup complexity +❌ **Preprocessing needed**: Tile Inria 5000x5000 β†’ 250x250 +❌ **Different sources**: Satellite vs aerial imagery mix + +### Implementation Complexity: **Medium** (6/10) + +### Tutorial Timeline +``` +Week 1: Geneva setup + baseline (Grid 1301_11 β†’ 1301_13/31) +Week 2: Prototypical Networks on Geneva +Week 3: PANet on Geneva + comparison +Week 4: Cross-city transfer (Vienna, Austin) +``` + +### Key Learning Outcomes +1. Understand few-shot learning fundamentals +2. See domain adaptation on same task +3. Compare methods across varying domain shifts +4. Learn practical deployment scenario (city β†’ city) + +--- + +## Strategy 2: Only Inria (Multi-City) + +### Overview +Use only Inria dataset, train on one city, test on others. + +### Task Structure +``` +Single-Dataset Multi-City Transfer + +Train: Vienna (36 train images Γ— tiled = ~576 patches) + +Test Domains: +β”œβ”€ Austin (US suburban - LARGE shift from Vienna) +β”œβ”€ Chicago (US urban - LARGE shift, but urban like Vienna) +β”œβ”€ Kitsap (US rural - VERY LARGE shift) +└─ Tyrol (Austrian mountain - MEDIUM shift, both European) +``` + +### Alternative Training Cities +``` +Option A: Train on Vienna (European urban) + β†’ Test on Austin, Chicago, Kitsap, Tyrol + β†’ Bias: European β†’ American + +Option B: Train on Austin (US suburban) + β†’ Test on Vienna, Chicago, Kitsap, Tyrol + β†’ Bias: Suburban β†’ diverse targets + +Option C: Train on Chicago (Dense urban) + β†’ Test on Vienna, Austin, Kitsap, Tyrol + β†’ Bias: Dense urban β†’ varying densities +``` + +### Few-Shot Setup +**Training** (e.g., on Vienna): +```python +# Tile Vienna images into 250x250 patches +vienna_patches = tile_images(vienna_train, patch_size=250) +# Result: ~576 training patches + +# Episodic training +for episode in range(num_episodes): + support, query = sample_episode(vienna_patches, K=5, Q=5) + # Train meta-learning model +``` + +**Evaluation** (on other cities): +```python +For each target_city in [Austin, Chicago, Kitsap, Tyrol]: + # Tile target city images + city_patches = tile_images(target_city, patch_size=250) + + For K in [1, 3, 5, 10, 20]: + support = random_sample(city_patches, K) + query = remaining_patches + + predictions = method.predict(support, query) + iou = compute_iou(predictions, query_masks) +``` + +### Expected Domain Shift +``` +Vienna β†’ Tyrol: MEDIUM (both Austrian, diff terrain) +Vienna β†’ Chicago: LARGE (Euroβ†’US, but both urban) +Vienna β†’ Austin: VERY LARGE (Euroβ†’US, urbanβ†’suburban) +Vienna β†’ Kitsap: VERY LARGE (Euroβ†’US, urbanβ†’rural) +``` + +### Advantages +βœ… **Single dataset**: Simpler setup, one data source +βœ… **Multiple targets**: 4 different cities to test on +βœ… **Established benchmark**: Well-known dataset +βœ… **Same task**: Binary segmentation throughout +βœ… **Good size**: After tiling, ~500-600 patches per city +βœ… **Geographic diversity**: US + Europe, urban + suburban + rural +βœ… **Easy to extend**: Can add all 5 cities as targets + +### Disadvantages +❌ **No within-city baseline**: Can't show small domain shift first +❌ **All shifts are large**: Harder to see method differences +❌ **Requires tiling**: Must preprocess 5000x5000 images +❌ **Building vs rooftop**: Not exactly rooftops (full building footprints) +❌ **Less progression**: Jumps straight to hard cross-city transfer + +### Implementation Complexity: **Low-Medium** (4/10) + +### Tutorial Timeline +``` +Week 1: Inria setup + tiling + Vienna baseline +Week 2: Prototypical Networks on Vienna +Week 3: PANet on Vienna + comparison +Week 4: Multi-city evaluation (4 cities) +``` + +### Key Learning Outcomes +1. Understand few-shot learning on real cross-city task +2. See performance across very different domains +3. Compare method robustness to large domain shifts +4. Learn practical multi-city deployment + +### Recommendation for This Strategy +**Best training city**: Vienna +- **Why**: European city, moderate density, good variety +- **Test on**: Austin (easiest), Chicago (medium), Kitsap (hardest) +- **Skip**: Tyrol initially (too similar to Vienna) + +--- + +## Strategy 3: Only RID (Multi-Class, Multi-City) + +### Overview +Use only RID dataset for realistic solar panel assessment task. + +### Task Structure + +**Option A: Roof Segments (18-class)** +``` +Task: Predict roof orientation (azimuth + flat) +Classes: Background, N, NNE, NE, ENE, E, ESE, SE, SSE, + S, SSW, SW, WSW, W, WNW, NW, NNW, Flat + +Train: Subset of cities (e.g., 60% of 1880 = ~1128 images) +Val: 20% (~376 images) +Test: 20% (~376 images) + +Few-shot: Use K examples from test set cities +``` + +**Option B: Roof Superstructures (Multi-class)** +``` +Task: Detect roof features for solar assessment +Classes: Background, PV module, Window, Chimney, + Dormer, Satellite dish, etc. + +Same split as Option A +``` + +**Option C: Hierarchical (Recommended)** +``` +Phase 1: Coarse segmentation (Roof vs Background) + - Simplify RID masks to binary + - Train baseline model + +Phase 2: Fine-grained segmentation (Superstructures) + - Given roof regions, detect PV modules, windows, etc. + - Use K examples for few-shot superstructure detection + +This shows: Can we adapt from "find roofs" to "analyze roofs"? +``` + +### Few-Shot Setup (Option B - Superstructures) + +**Data Preparation**: +```python +# RID provides georeferenced images + annotations +# Use their GitHub code to generate masks + +from rid_tools import generate_masks + +# Generate superstructure masks +masks = generate_masks( + annotations_path='RID/annotations/', + task='superstructures', + classes=['background', 'pvmodule', 'window', 'chimney', 'dormer'] +) +``` + +**Training**: +```python +# Option 1: Standard split (not city-based) +train_images = rid_data[:1128] # 60% +val_images = rid_data[1128:1504] # 20% +test_images = rid_data[1504:] # 20% + +# Option 2: City-based split (if city info available) +train_cities = ['CityA', 'CityB', 'CityC'] +test_cities = ['CityD', 'CityE'] + +# Episodic training on train set +for episode in range(num_episodes): + # N-way K-shot episodes + classes = sample_classes(N=3) # e.g., pvmodule, window, chimney + support, query = sample_episode(classes, K=5, Q=5) +``` + +**Evaluation**: +```python +# Few-shot evaluation on test set +For K in [1, 3, 5, 10, 20]: + # Sample K examples of each class + support_set = sample_per_class(test_images, K_per_class=K) + query_set = remaining_test_images + + # Predict + predictions = method.predict(support_set, query_set) + + # Compute metrics + iou_per_class = compute_iou(predictions, query_masks, classes) + mean_iou = iou_per_class.mean() +``` + +### Expected Challenges +``` +Binary (Geneva/Inria): Easy - 2 classes, clear boundaries +RID Segments: Hard - 18 classes, subtle differences (NNE vs NE) +RID Superstructures: Medium-Hard - Fewer classes but small objects +``` + +### Advantages +βœ… **Most realistic**: Actual solar panel assessment task +βœ… **Rich annotations**: Multiple semantic levels +βœ… **Direct application**: PV module detection is the end goal +βœ… **Multi-class few-shot**: Shows method capability on hard task +βœ… **Single dataset**: No need to integrate multiple sources +βœ… **Large size**: 1,880 images is substantial +βœ… **Quality data**: Reviewed annotations, multiple labelers +βœ… **Code available**: GitHub repo with utilities + +### Disadvantages +❌ **High complexity**: Multi-class harder to learn/teach +❌ **Requires preprocessing**: Must generate masks from annotations +❌ **Different task**: Not comparable to Geneva/Inria +❌ **Harder baselines**: Multi-class needs more careful implementation +❌ **Less established**: Newer dataset, fewer examples to follow +❌ **License restrictions**: CC-BY-NC (non-commercial) +❌ **Google Maps imagery**: Different from satellite +❌ **Small objects**: PV modules, windows are small, harder to segment + +### Implementation Complexity: **High** (8/10) + +### Tutorial Timeline +``` +Week 1: RID setup + mask generation + data exploration +Week 2: Binary baseline + multi-class baseline +Week 3-4: Prototypical Networks (need more time for multi-class) +Week 5: PANet + comparison +Week 6: Analysis and visualization +``` + +### Key Learning Outcomes +1. Understand few-shot learning on complex multi-class task +2. Learn N-way K-shot episodic training +3. See real-world application (solar assessment) +4. Handle class imbalance (some classes rare) +5. Deal with small objects (PV modules) + +### Recommendation for This Strategy +**If using RID, focus on**: +- **Task**: Roof superstructures (more interpretable than 18 directions) +- **Classes**: PV module, Window, Chimney, Background (4-way task) +- **Approach**: Start with binary (roof vs background), then few-shot superstructures +- **K values**: Use higher K (5-20) due to multi-class complexity + +--- + +## Head-to-Head Comparison + +### 1. Tutorial Clarity + +**Winner: Geneva + Inria** ⭐⭐⭐⭐⭐ + +**Reasoning**: +- Clear progression: small shift (Geneva grids) β†’ large shift (Inria cities) +- Same task (binary) throughout makes concept learning easier +- Students can focus on few-shot methods, not task complexity + +**Rankings**: +1. Geneva + Inria (5/5) - Clearest learning path +2. Only Inria (4/5) - Still clear, but no easy baseline +3. Only RID (3/5) - Multi-class adds complexity + +--- + +### 2. Real-World Relevance + +**Winner: Only RID** ⭐⭐⭐⭐⭐ + +**Reasoning**: +- Direct solar panel application (PV module detection) +- Multi-class is more realistic than binary +- Actually detects roof features, not just roofs + +**Rankings**: +1. Only RID (5/5) - Most realistic solar assessment +2. Geneva + Inria (4/5) - City deployment scenario realistic +3. Only Inria (3.5/5) - Building footprints less specific than roofs + +--- + +### 3. Implementation Effort + +**Winner: Only Inria** ⭐⭐⭐⭐⭐ + +**Reasoning**: +- Single dataset to manage +- Simple binary task +- Well-documented, many examples + +**Rankings**: +1. Only Inria (5/5) - Simplest +2. Geneva + Inria (3/5) - Two datasets, tiling needed +3. Only RID (2/5) - Multi-class, preprocessing, less docs + +--- + +### 4. Dataset Size & Diversity + +**Winner: Only RID** (size) / **Only Inria** (diversity) + +**For Size**: +1. Only RID: 1,880 images +2. Geneva + Inria: ~1,050 + ~360 (after tiling ~1,050 + 1,800) = ~2,850 +3. Only Inria: ~360 (after tiling ~1,800) + +**For Geographic Diversity**: +1. Only Inria: 5 cities, 3 countries, varied terrain +2. Geneva + Inria: 6 cities total +3. Only RID: Multiple cities (but not specified) + diff --git a/docs/_config.yml b/docs/_config.yml new file mode 100644 index 0000000..f4755dc --- /dev/null +++ b/docs/_config.yml @@ -0,0 +1,9 @@ +title: Few-Shot Learning Tutorial +description: Few-shot learning for rooftop detection in satellite imagery +theme: jekyll-theme-primer +baseurl: "/tutorial-group-1" +url: "https://elenaivadreyer.github.io" + +# remote_theme: pages-themes/primer@v0.6.0 +# plugins: +# - jekyll-remote-theme # add this line to the plugins list if you already have one \ No newline at end of file diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..2175fad --- /dev/null +++ b/docs/index.md @@ -0,0 +1,54 @@ +--- +layout: default +title: Few-Shot Learning for Rooftop Detection +--- + +# Few-Shot Learning for Rooftop Detection in Satellite Imagery + +Welcome to the tutorial on few-shot learning for semantic segmentation of satellite imagery, focusing on rooftop detection in Geneva, Switzerland. + +## Tutorial Overview + +This tutorial demonstrates: +- Few-shot learning concepts for image segmentation +- Working with satellite imagery and segmentation masks +- Implementing and evaluating few-shot learning models for rooftop detection + +## Getting Started + +### Prerequisites +- Python 3.11+ +- PyTorch 2.0+ + +### Installation + +```bash +git clone https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1.git +cd tutorial-group-1 +pip install -e . +``` + +### Running the Tutorial + +Open the main tutorial notebook: +```bash +jupyter notebook notebooks/tutorial_few_shot_learning.ipynb +``` + +## Video Tutorial + + +*Video coming soon...* + +## Dataset + +The dataset contains high-resolution satellite imagery of Geneva, Switzerland, with corresponding segmentation labels for rooftop detection. + +## Resources + +- [GitHub Repository](https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1) +- [Tutorial Notebook](https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1/blob/main/notebooks/tutorial_few_shot_learning.ipynb) + +## License + +This project is licensed under the MIT License. diff --git a/docs/installation.md b/docs/installation.md new file mode 100644 index 0000000..129e277 --- /dev/null +++ b/docs/installation.md @@ -0,0 +1,111 @@ +# Installation Guide + +This guide explains how to set up the tutorial environment. + +## Quick Start + +### Using Makefile (Recommended) + +```bash +# Create virtual environment and install dependencies +make create_venv + +# Activate virtual environment +source .venv/bin/activate + +# Install PyTorch (CPU-only) +make install-torch +``` + +### Manual Installation + +```bash +# Create and activate virtual environment +python3 -m venv .venv +source .venv/bin/activate + +# Install package dependencies (without PyTorch) +pip install -e . + +# Install PyTorch CPU-only version +pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu +``` + +## Why PyTorch is Optional + +PyTorch is not included as a direct dependency because: + +1. **Size**: The CUDA version is ~7GB, which can cause disk space issues +2. **CPU-only alternative**: The CPU-only version is ~730MB and sufficient for this tutorial +3. **Flexibility**: Users can choose between CPU and GPU versions based on their needs + +## PyTorch Installation Options + +### CPU-only (Recommended for most users) +```bash +pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu +``` + +### CUDA (If you have an NVIDIA GPU) +```bash +# For CUDA 11.8 +pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118 + +# For CUDA 12.1 +pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121 +``` + +For more installation options, see the [official PyTorch installation guide](https://pytorch.org/get-started/locally/). + +## Development Setup + +### Pre-commit Hooks + +This project uses pre-commit hooks for code quality. To set them up: + +```bash +# Install development dependencies +pip install -e .[dev] + +# Install pre-commit hooks +pre-commit install + +# Run hooks manually on all files +pre-commit run --all-files +``` + +### Makefile Targets + +- `make help` - Show available targets +- `make create_venv` - Create virtual environment and install dependencies +- `make install` - Install package with dev dependencies +- `make install-torch` - Install PyTorch CPU-only version +- `make lint` - Run pre-commit hooks on all files + +## Devcontainer Setup + +If you're using VS Code with devcontainers: + +1. Open the repository in VS Code +2. Click "Reopen in Container" when prompted +3. The container will build and install dependencies automatically +4. **Important**: PyTorch is not installed by default. To install it, run: + ```bash + source .venv/bin/activate && make install-torch + ``` + +## Troubleshooting + +### Disk Space Issues + +If you encounter disk space issues during installation: +- Make sure you're using the CPU-only version of PyTorch +- Clear pip cache: `pip cache purge` +- Consider using a cloud development environment with more storage + +### Import Errors + +If you get import errors for torch: +- Make sure PyTorch is installed: `pip list | grep torch` +- Verify you're using the correct virtual environment: `which python` +- Reinstall if necessary: `make install-torch` diff --git a/docs/memo.md b/docs/memo.md new file mode 100644 index 0000000..ecb89f8 --- /dev/null +++ b/docs/memo.md @@ -0,0 +1,7 @@ +Few-shot learning for satellite image segmentation is crucial for urban planning and disaster response. Traditional deep learning requires thousands of labeled samples, but few-shot learning enables rapid adaptation to new geographic regions with minimal labeled data. + +**Policy Applications:** +- Urban development monitoring +- Disaster damage assessment +- Property tax assessment +- Solar panel installation planning \ No newline at end of file diff --git a/docs/tutorial_few_shot_learning.html b/docs/tutorial_few_shot_learning.html new file mode 100644 index 0000000..716bcb5 --- /dev/null +++ b/docs/tutorial_few_shot_learning.html @@ -0,0 +1,8049 @@ + + + + + +tutorial_few_shot_learning + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ + diff --git a/notebooks/class_template.ipynb b/notebooks/class_template.ipynb new file mode 100644 index 0000000..67fda1b --- /dev/null +++ b/notebooks/class_template.ipynb @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "13i7KQ9t-CV8" + }, + "source": [ + "# Tutorial Notebook Template\n", + "## GRAD-E1394 Deep Learning -- Assignment 3\n", + "Author(s):\n", + "* Author, Email\n", + "\n", + "This serves as a template for Assignment 3.\n", + "\n", + "To get started, replace the tutorial notebook title and author information accordingly (one bullet point per group member). Replace the information in this cell with a brief summary of the tutorial as well as users' expected learning outcomes.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yNv0ANr5WcD_" + }, + "source": [ + "# Table of Contents\n", + "\n", + "\n", + "* [Memo](#memo)\n", + "* [Overview](#overview)\n", + "* [Background & Prerequisites](#background-and-prereqs)\n", + "* [Software Requirements](#software-requirements)\n", + "* [Data Description](#data-description)\n", + "* [Methodology](#methodology)\n", + "* [Results & Discussion](#results-and-discussion)\n", + "* [References](#references)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rqD_ftUYJE1n" + }, + "source": [ + "# General Guidelines\n", + "*(Please remove this and other guideline sections from your final tutorial submission.)*\n", + "\n", + "This template should help you create your tutorial. You may introduce modifications and extensions but adhere to the general principles for writing the tutorial:\n", + "\n", + "* Be brief.\n", + " * Keep it short and simple. Avoid unnecessary complexity.\n", + "* Clearly illustrate how the content relates to public policy.\n", + " * Identify the ways in which this tutorial would help the users (your collegues) in their work.\n", + "* Provide enough context.\n", + " * Explain important concepts directly in the tutorial notebook, but feel free to direct users to external resources when necessary. \n", + "* Avoid or minimize the use of jargon.\n", + " * Ideally, the content can be understood by both an ML audience and by people who are relatively new to ML and deep learning.\n", + "* Focus on readability and usability.\n", + " * Interleave code cells with explanatory text, keeping your audience in mind.\n", + "* Follow guidelines to avoid plagiarism.\n", + " * Any verbatim text needs to be put in quotation marks.\n", + " * Do not copy code.\n", + " * Clearly reference ideas and work of others.\n", + " * [Hertie School Code of Conduct](https://hertieschool-f4e6.kxcdn.com/fileadmin/5_WhoWeAre/Code_of_Conduct.pdf)\n", + "* Ensure reproducibility.\n", + " * Ensure that your notebook can be rerun by somebody else on a different machine in a reasonable amount of time. If the task is computationally expensive, provide an additional, smaller data sample for fast reproduction, and use that in your tutorial.\n", + "\n", + "## Additional Instructions\n", + "We highly recommend that you follow the [Ten simple rules for writing and sharing computational analyses using Jupyter Notebooks](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007007). We summarize the ten rules as follows:\n", + "\n", + "
\n", + "\n", + "Rule, Adam, et al. \"Ten simple rules for writing and sharing computational analyses in Jupyter Notebooks.\" PLoS computational biology 15.7 (2019).
\n", + "\n", + "### Rule 1: Tell a story for an audience\n", + "* Interleave explanatory text and code to tell a compelling story.\n", + "* Describe not just what you did but why you did it.\n", + "* How you tell your story depends on your goal and your audience.\n", + "\n", + "### Rule 2: Document the process, not just the results\n", + "* Document relevant interactive explorations.\n", + "* Don't wait until the end to add explanatory text.\n", + "* Generate publication-ready version of figures from the get-go.\n", + "\n", + "### Rule 3: Use cell divisions to make steps clear\n", + "* Each cell should perform one meaningful step in the analysis.\n", + "* Think one cell = one paragraph, function, or task (e.g. creating a plot).\n", + "* Avoid long cells (50+ lines)\n", + "* Organize your notebook into sections/subsections. \n", + "\n", + "### Rule 4: Modularize code\n", + "* Avoid duplicate code (no copy-pasting!)\n", + "* Wrap the code that you want to reuse in a function.\n", + "* Use descriptive and meaningful variable and function names.\n", + "\n", + "### Rule 5: Record dependencies\n", + "* Manage your dependencies using a package or environment manager (e.g. pip,conda)\n", + "* Feel free to use tools like Binder or Docker to generate a \"container\" for better reproducibility.\n", + "\n", + "### Rule 6: Use version control\n", + "- Google colab allows you to view revision history.\n", + "- You can also opt to use Git and Github for version control.\n", + "- As Jupyter uses JSON for serialization, tracking raw changes on GitHub is difficult. [ReviewNB](https://www.reviewnb.com/) and [nbdime](https://github.com/jupyter/nbdime) can help to generate human-readable diffs.\n", + "\n", + "### Rule 7: Build a pipeline\n", + "* A well-designed notebook can be generalized into a pipeline.\n", + "* Place key variable declarations at the top/beginning of the notebook.\n", + "* Make a habit of regularly restarting your kernel and rerunning all cells.\n", + "* Before submitting, reinstall all dependencies and rerun all cells in a new enviroment to ensure reproducibility.\n", + "\n", + "### Rule 8: Share and explain your data\n", + "* Properly reference the data you use.\n", + "* If using your own data, make your data or a sample of your data publicly available along with the notebook.\n", + "* You can opt to host public copies of your data.\n", + "\n", + "### Rule 9: Design your notebooks to be read, run, and explored\n", + "* Read: For code hosted in a public repository, add README and LICENSE files.\n", + "* Run: Consider using Google Colab, Binder, or Docker for seamless replication.\n", + "* Explore: Consider how you can design your notebook so future users can built on top of your work.\n", + "\n", + "### Rule 10: Advocate for open research" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QH81wjfsJsv1" + }, + "source": [ + "\n", + "# Memo\n", + "\n", + "Write a memo for the leadership explaining in layman's terms why this topic is relevant for public policy. Discuss relevant research works, real-world examples of successful applications, and/or organizations and governments that apply such approaches for policy making.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e2u40fYe3EOL" + }, + "source": [ + "\n", + "# Overview\n", + "\n", + "In this section, provide a summary of the main contributions of the tutorial notebook. Note that the tutorial should introduce or demonstrate the use of a method, dataset, tool, or technology to address a problem related to public policy. Be clear on the goal of the tutorial and the expected learning outcomes for the users.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gQgijl46pYzn" + }, + "source": [ + "\n", + "# Background & Prerequisites\n", + "\n", + "You will need to specify the prerequisites and basic knowledge required for the tutorial. Afterwards, please provide a brief explanation of the most important concepts necessary for the users to follow the tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ag9dvWcxqmEq" + }, + "source": [ + "## Videos\n", + "You may also opt to include short videos explaining relevant concepts.\n", + "\n", + "Example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "E4aK3MI9qhfJ", + "outputId": "044bd042-37c7-43d2-8a19-78dbc2dd6e46" + }, + "outputs": [ + { + "data": { + "image/jpeg": "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\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "\n", + "YouTubeVideo(\"aircAruvnKk\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7BpQklEEIFDD" + }, + "source": [ + "## Reading materials\n", + "Please include additional resources (e.g. research papers, blog posts, textbooks) for the readers to further study the topic of your tutorial.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rSRCNgYzUwaf" + }, + "source": [ + "\n", + "# Software Requirements\n", + "Include in this section the software requirements, setup instructions, and library imports.\n", + "\n", + "Example:\n", + "\n", + "This notebook requires Python >= 3.7. The following libraries are required:\n", + "* pandas\n", + "* numpy\n", + "* matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jObV5LtDk0Vm" + }, + "outputs": [], + "source": [ + "!pip install pandas numpy matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xVzk4V7qUu2R" + }, + "outputs": [], + "source": [ + "# Data visualization\n", + "\n", + "# Data manipulation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jXoiLncsU3pe" + }, + "source": [ + "\n", + "# Data Description\n", + "\n", + "In this section, kindly provide a brief description of the dataset that you will use in this tutorial. Specify information such as the data type or file format (e.g. text, image, video, tabular), size, spatial resolution, temporal resolution, labels or categories, etc. Explicitly name the source of your dataset. If you are introducing a new dataset, feel free to include additional information (e.g. field survey sampling methods, dataset annotation efforts, etc.) or provide external links and resources that discuss the specific details of the dataset.\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PoF-BxSM5Jkc" + }, + "source": [ + "## Data Download\n", + "Provide instructions on how to retrieve the necessary data.\n", + "\n", + "This may include bash scripts, Python scripts, or other means of downloading the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Qh5FKi6Nopbr" + }, + "outputs": [], + "source": [ + "# Insert data download code here, e.g.\n", + "# !wget .zip -O data.zip" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bSt6h_Q-oqjK" + }, + "source": [ + "## Data Preprocessing\n", + "Additionally, you can include any data preprocessing steps and exploratory data analyses (e.g. visualize data distributions, impute missing values, etc.) in this section to allow the users to better understand the dataset.\n", + "\n", + "In this section, you might also want to describe the different input and output variables, the train/val/test splits, and any data transformations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0aBJ5aLZosk-" + }, + "outputs": [], + "source": [ + "# Insert data pre-processing and exploratory data analysis\n", + "# code here. Feel free to break this up into several code\n", + "# cells, interleaved with explanatory text." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qa9Iuu2GU52Z" + }, + "source": [ + "\n", + "# Methodology\n", + "\n", + "In this section, describe a step-by-step walkthrough of the methodology, in the form of code cells. Feel free to make use of markdown headings to break this section up into smaller subsections, preferrably one section per task.\n", + "\n", + "Reminders:\n", + "* Split the code into small, digestible chunks.\n", + "* Use text cells to describe each code block.\n", + "* Avoid duplicate code through modularization.\n", + "* Focus on learning outcomes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yWXsiZ5freTG" + }, + "source": [ + "## Subtask Heading 1\n", + "Replace the heading with the appropriate title for each subtask." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "6CeKQHfyrU7k" + }, + "outputs": [], + "source": [ + "# Insert code here. Feel free to break this up into several code\n", + "# cells, interleaved with explanatory text." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o8L28axZ4NVj" + }, + "source": [ + "## Subtask Heading 2\n", + "Replace the heading with the appropriate title for each subtask." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_6HotiSW4Pe8" + }, + "outputs": [], + "source": [ + "# Insert code here. Feel free to break this up into several code\n", + "# cells, interleaved with explanatory text." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZhkmytKNU_Z2" + }, + "source": [ + "\n", + "# Results & Discussion\n", + "\n", + "In this section, describe and contextualize the results shown in the tutorial. Briefly describe the performance metrics and cross validation techniques used." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8LWo6UQzwj37" + }, + "outputs": [], + "source": [ + "# Insert code here. Feel free to break this up into several code\n", + "# cells, interleaved with explanatory text." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oHIjM6eMwlXY" + }, + "source": [ + "Finally, include a discussion on the limitations and important takeaways from the exercise.\n", + "\n", + "## Limitations\n", + "* The tutorial is focused on education and learning. Explain all the simplifications you have made compared to applying a similar approach in the real world (for instance, if you have reduced your training data and performance).\n", + "* ML algorithms and datasets can reinforce or reflect unfair biases. Reflect on the potential biases in the dataset and/or analysis presented in your tutorial, including its potential societal impact, and discuss how readers might go about addressing this challenge." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CLLCQpv14Gsx" + }, + "source": [ + "## Next Steps\n", + "* What do you recommend would be the next steps for your readers after finishing your tutorial?\n", + "* Discuss other potential policy- and government-related applications for the method or tool discussed in the tutorial.\n", + "* List anything else that you would want the reader to take away as they move on from the tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PkKqewK_-ZLD" + }, + "source": [ + "\n", + "# References\n", + "\n", + "Include all references used.\n", + "\n", + "For example, in this template:\n", + "\n", + "* EarthCube Notebook Template: https://github.com/earthcube/NotebookTemplates\n", + "* Earth Engine Community Tutorials Style Guide: https://developers.google.com/earth-engine/tutorials/community/styleguide#colab\n", + "* Google Cloud Community Tutorial Style Guide: https://cloud.google.com/community/tutorials/styleguide\n", + "* Rule A, Birmingham A, Zuniga C, Altintas I, Huang S-C, Knight R, et al. (2019) Ten simple rules for writing and sharing computational analyses in Jupyter Notebooks. PLoS Comput Biol 15(7): e1007007. https://doi.org/10.1371/journal.pcbi.1007007\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YguJayU8RBmd" + }, + "source": [ + "## Acknowledgement\n", + "\n", + "These guidelines are heavily based on the Climate Change AI template for the for the tutorials track at the [NeurIPS 2021 Workshop on Tackling Climate Change with Machine Learning](https://www.climatechange.ai/events/neurips2021)." + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/notebooks/exploration.ipynb b/notebooks/exploration.ipynb new file mode 100644 index 0000000..0efb46b --- /dev/null +++ b/notebooks/exploration.ipynb @@ -0,0 +1,182627 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "2NS_JdFp3zOj" + }, + "source": [ + "## Geneva Dataset Task Suitability and Exploration\n", + "**_Exploration of the dataset and Few-Shot approaches_**\n", + "\n", + "Geneva satellite dataset can be suitable for few-shot segmentation, but it wasn't originally designed for this purpose, and might need some adjustment.\n", + "\n", + "#### Dataset facts:\n", + "\n", + "- It has 1,050 labeled image-mask pairs, which is enough to simulate few-shot scenarios \n", + "- Three distinct categories (all/industrial/residential) let you create meaningful support/query splits \n", + "- Data (images) are geolocated (we have latitude and longitude in the file's name; i.e., \"DOP25_LV03_{grid}_{year}_1_15_{x_coord}_{y_coord}.png\")\n", + "- There is a \"Grid\" reference as well, but it's not exactly clear what it is (i,e., 1301_11, 1301_13, 1301_31). It should define different part of Geneva, but not clear\n", + "- We have labels (pixel-level mask for segmentation) for all the images (we will pretend we don't for the few-shot task)\n", + "- The segmentation task is well-defined: rooftop vs background is a clear binary problem \n", + "- Real-world policy relevance: solar panel installation assessment is a concrete government use case\n", + "- The current 840-train/104-val/106-test split assumes traditional supervised learning\n", + "\n", + "#### Geneva Dataset and Few-Shot Fine-Tuning for Domain Adaptation\n", + "\n", + "- In the dataset, images are already divided into 'residential' and 'industrial' types. The simplest idea is to use a pre-trained model to segment rooftops of residential building, and use few-shot fine-tuning to adapt the model to segment industrial building (with only 3-5 labels). This is an easy task, and can be used as sandbox example. \n", + "\n", + "- A more complex and interesting scenario is to use a pre-trained model to segment rooftops of a specific area of Geneva (we have coordinates for each image, so even if we don't have a geographical variable we can easily create it, or we can use different grid sections) and use few-shot fine-tuning to adapt the model to segment rooftops of another area, that looks different (we can choose looking at satellite images if working with grid sections is unsuitable). Different parts of the city likely have different characteristics: urban density, building ages, roof types. We would simulate this \"scaling to another city\" by working at neighbourhood/area level.\n", + "\n", + "#### Few-Shot Learning with this specific dataset\n", + "\n", + "In our dataset, labels exist for every image, but we can pretend they don't during the few-shot phase. The setup would work like this:\n", + "\n", + "**Training Phase (Base Model):**\n", + "\n", + "- Use the full training set (840 images + labels) to learn general rooftop segmentation features → foundation model\n", + "\n", + "**Few-Shot Evaluation Phase:**\n", + "\n", + "- Randomly select K images from the test set as your \"support set\" (e.g., K=5 for 5-shot) → these are the only labels we allow the model to use for adaptation\n", + "- Test on the remaining images as \"query set\"\n", + "- The remaining labels are used only for evaluation\n", + "\n", + "We would simulate the scenario in which we explore the question: \"We deployed our model to a new city/building type, but we only have budget to label 5 examples. Can we still segment rooftops accurately?\"\n", + "\n", + "#### We can include Active Learning \n", + "\n", + "How to strategically select which 5-10 images to label (the most informative examples), random that labelling randomly?\n", + "Two appraoches:\n", + "\n", + "1. Use base model uncertainty to select the most informative K examples (calculate uncertainty with entropy) → the easiest and probabily most effective for the tutorial\n", + "2. Extract features from all target images and select the most diverse using clustering or maximum distance selection (?) \n", + "3. Use both (uncertainy and diverstiy)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exploration of the dataset\n", + "\n", + "The code below downloads the data into the Hugging Face cache and creates a symlink to it in the `data` folder of this branch. The `data` folder is excluded from version control via `.gitignore`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching ... files: 2111it [00:00, 4570.14it/s] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset downloaded to: /Users/giocopp/Desktop/Uni/Hertie School/5th Semester/DL/DL-FinalProject/DL-Tutorial-giorgio-exploration/data\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from huggingface_hub import snapshot_download\n", + "from PIL import Image\n", + "import torch\n", + "from torchvision import transforms\n", + "from torch.utils.data import Dataset\n", + "from pathlib import Path\n", + "\n", + "# Download the entire dataset\n", + "# We create a foder inside the repo\n", + "data_dir = Path(\"data\")\n", + "\n", + "dataset_path = snapshot_download(\n", + " repo_id=\"raphaelattias/overfitteam-geneva-satellite-images\",\n", + " repo_type=\"dataset\",\n", + " local_dir=str(data_dir),\n", + " local_dir_use_symlinks=True,\n", + ")\n", + "\n", + "print(f\"Dataset downloaded to: {dataset_path}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Quickly visualize one of the original images at random and its correspective mask (label)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import random\n", + "\n", + "# We load a random image and its corresponding label from the training dataset\n", + "images_dir = os.path.join(dataset_path, \"train/images/all\")\n", + "labels_dir = os.path.join(dataset_path, \"train/labels/all\")\n", + "\n", + "img_name = random.choice([f for f in os.listdir(images_dir) if f.endswith(\".png\")])\n", + "base, ext = os.path.splitext(img_name)\n", + "\n", + "image = Image.open(os.path.join(images_dir, img_name))\n", + "label = Image.open(os.path.join(labels_dir, f\"{base}_label{ext}\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6CAIAAAAHjs1qAAEAAElEQVR4AWL07Evj+PBHnYPv8P/7oXyOjIJMN99c/MXMcZbvs/wb1s//vzsxi4tLqa59ev7Vj7cinII2/wX+/PnBwsT/mOG11C+eh29esDH+e8HGyfqV67XIK+mbTA+U/lm/Fzx25zsT02seFX4HTcML705+/8Njwq3068dzHjEZYSbe68w3VX5q7GG6IvSC97cgA8fnPz/e//4i8uXpuT8/3zN85njGxSv04+9z5ieMv978/sv3h/EHK6sQ389fP////vPjByOvzD9mOYG/11g/vbjMwSIjrKf0nfEet6jsD67nZtxWL3/e/vJJhPfT+2cyfznuM3Fqc/xh4fz6/onwK7lfyu//vv4uKSP5582/x6z3LDlUvv5lvfP/I9svhud8v7lf/uT6wfjs8kcW0Z+8UhKmYnxnmH+x/PrNcObDN3Uunves7lZWLL+/fn738SPXS1sFP3bO/4yMHIwszJwcrHx/2L9z/P3x7xsXA/t/Zrb/f3/8+PuHk4nt359ff5jZ/v/+w8jE8J3pF+svRg5e3v+M3+UFuDpOHztcf+o3x4u/f34wMvL/EnzB9UuJhfs/E/O33xxc/7/8/PHtP8dv7j+8f5n//mBnZvj47hO3uKgQMxMvJ+d3AQ72N8+//hPgYvklKvj/LQvP71evX71n+/H9A/sP9r+SnIayAk8Ef//8+/ff7d8fFV4wMTAJ/hL59/r3c4a//+59Zv7z/+/fb79ZxSRkfmmKymsZyrx49ewvm4AotwDz178/WF5xMcqzMn5++f0H1w+ml/8/ffryifUz2zthhg/Pnin+4/mgyPfj3lfm79+/83L/ZPj7i+GNLJsgJyPjy//s7Gx/mb8zPWB+9/fif1aOX3+ZmJiFBMT1/j85wfT1yyOmP3K28qLPxMTi7VTZBVj/fP3FIviF8T7z7Junfz2476Bl9Irzy6/3zHdffpBT+sH2jvUPB+udN/8s9SWe/f3L8/HHH4Ef3GzSAgy/P739++zVxXt8Ii6KGk+fXJPjEDoo9JnzF7/gy6cikmL3r9//ziiqpM4u/k/yzcMHDFKsrB+5rr35xMz/muXvu5cf2QWu/nltLyDDKc7D9+nrks9/NH9/CeQUfPaf5de313v4vyu+eOv2T2EHO8Nnhg+HmNkcvnJ/5niiyaHxlv8VB5fYpbu3+HhZGZk/yT1le8rDLvr/97s/DG9/fxCQ+cb0gvsD11MDSQO2z18+fnj9m0/+2v0nqhJcgmw8776/Zn33Ro5R8P1f1tsPDmpquohzcD1jffCP8zcLxx+Wr99YRYX+q7EysD3//ZqPl+EXq8R7QU7J1x/fif1g+fWB9e+H7wx/37GyyPxj/vbl52sGRqafvz7+4RB6ynSVhZ+H8cnXmwwfJP6JMWr/+/Hnz7/vL+SkFN4LvxLmlhXk+cnExHKN97X+T80T/79yfPz+k/entACr+Jsfb3/zfHr66sc79n8cb4Xfce5ifyH4hp/r08+PYpws37jZhX5/+/iMmZXhM6+grggPlwgvJ9u/X78Z2Nk5mX7/ec3+meUnIycL+y9mZk6mfz/+M/z685eXifkrG/ufv1952YQ+/XjJy8H/h4v5L/Ofr/8/v77/6f/tL/xqv17/+/bniezfn5//v2FikPj/8/9vhv9feb6w/mbkZeP6+PfzB4aPrL/YGRhYf3Dwi/37+/MzN8OfT+zfWF8zfWbn4f0vIiz6lu/T69tfub/xsHB//v+a8wP7Jz0BfiVJla8PH7z5wcb05/6f55Lfvn57+v/Dv8e//jJ/Yfgh8I/jHRMrP9tfhhcfvzJ/eMEkKsDJKygoxP3i+gUeZfX/b/4x/HnPJyD4X+DviwdP+QTE/vxk/8fN+vfnE+Y/fDziggoMos/En757xMgh8lvgI9/X7xzf/j37z6XB/u0D+w9WRjl+5U88b0S+fvj7gefvX2VNPVFFXjX2n09u897+KuogJ7ybW4RFiOM3yy82NuGfr9+///3348sfDJ8FX77/9pf58+s7v/9+//NHmUXP1Or7q2cfOD49/fDohRiL3H9JYRaOT69/PHlz4h+3PNtXRS6BB7sOHfvG+e8bv6je+39/hD+rCGrd/PaQR1DlH89znq9cL4Xf3BH7JPxF6bXwA567jJ/fMLBwMHH+/vr1N8u/a28+7/10X+K/KMe7v/eEPl96/175C89PNkE5LpFXHz+uZjpjxKh66vtbTobv//m4ONm4X/B/+n75PpeGqTr/K3E+sbcPv3II/OfgYv7/hOGfAKsi63eGHzzvf/25+P65tjgPLzsvu6QI+w9Wll/sHx/eeif1XYRFh42D9SXDq4usH0Vk1B69vybFLfBX4Cvj21//+VkYmNikfnL+EuX88Ozbjz/vvnKx8n7l5OFj/Pab79vvX5//vOa8xPCZ5S+7lhDX498/GP/IcIqLSP7/wMunyCF86+OTt4JfZFmE3j58/u377//v2dgF2Hj0ngoISfN+//GWlZ3x87MPr/5f43gq9IP7P9sfTg4OBi5Rjo/v/jP8Yfr8nYGLWeCfJL80MwuDgDIf/5NP37ikRBSY/j7m5/3z6zsPt5iwxG9RFmEOJuZf/5g5WP8w//n/+fc3fjb+P2xMv/9/ZWZi+f3vN8NvBo6/rF//fGVi52Bl4vz689NfRva/DMwMjD+E2ZjfvXpx4RTDqc83dMR/8TCJPfh8/+3z/4L/ZD/fvcfIw8MrovT9z1OW/9+YmPl+/3rDyMnCwszA8Ivt79+fTP84fjG852LlEfsj/5/p9c9/r9mZZMSefvrH/uvjp1/sb74/YmGSUeUS4hM+/fE2y1cWYZZv7yR4Ob58//P559uPv1k/sfzn4GFi+/73q+h/VlZWlvdsf/4+//jrx4N7+twCjH9eMAvqCAkK/3327bcM65M7d2UlFWXEOV+xfpdjZf/+8S3bP75XHP8VBLh/sTC+YebkEv7C/o3j3y/OH2IPeP/y/P3JJsT54wUDJzvjd7Y3n7nlfnG8YnjzTurB23u8HyV4JKUMpAzlf/9k4ZH2lWBh/8f95umzL7+f/GdkPMj4IlSDd6M4M/cX5vu/uV6wPmX+y/nrF/uzf8+e/nku+pf9hySP0S/O11zf2Z78VZUS52XQf/Dz1UOBT2xvORlf/xLRY/vC/FpWVOAj+9cv73lus/z++/GF1j/5B2ynZH45fXx+n+PXR+YvzH+V2d79+8fyifmTjYjR0Q93X/9lEv3C+Yz1A+9/dgFWLr5XjExcDMzsnNzPnv+Uknr34e2jHx9Y/7Or8Irc5vis+JeJ44uYuCjjjb/PBEUVxF///cLBeuni0x9M/8X52B3NDbX+/Dj34uf9f6/lf3D+evmJR5CbkeH9vz9MXCrcj//8UWcR5WVgZ7ony/79v8o3hg/fPz35++Y9P7e8qOKdr1c53oh8Zn/3i/mnwOsvbKI/OFj5/v39/OMn/9U7rwT/8f///IvrC/tHFiYhFhZ+Jx71+5y3/rFxMDFJfGf58Zbzm/zzP09YhMU5Xz77wPTm13/2P3/fMDNwM7x/xvTt++sPfLzsb3+K83LJiLC9//XwF7fAr1c/mH78fX7qyhclPhXmX59FhP9xf2b4z8LzisneQuf8r2cfJYXlWb8x80lrvf8l9V+EW1CBn5WBRYCHieUv4w8mVjaOXywMnMysfxj/M/77yfSfgeP3388Mv5jYeX4xfOT+x/mf8Q/DT4YfvxlYOP9/Z/gq/pfv6YenZ+59eHzrlqj4r7MCjLzszNI8Sn8Pv/704QMzkxALA+PPD7eYmFh/Sf/lePOHmVv63/8PTAx///7nY/j//v/ff9yfOP+x/Hv96goToxgbB9eV5/d+//zI/IP9068/v37/kldTEf/H/P7X539Pf72V/S3y+K8gr/C/f4w8Ah+/MXJ8+fadkfEXwxdGRuF3////+s/ExvCHh4Xp19fr7x4rsSrKsnB+e/vt9rfXv/6JffwrJi7yn+E3y9+/b14xcTE+U1bSZXz8+K7M29vvf78S+PH79qd/fP++fmD8IvSW4xfHv+8Cv3necnEqiX64//Xlv6/MrDwif4UEJRi+vX55lf3epzfKHsJ/fwo5CHL94vn89wv/i2+XmVlEnj34cffzi0ArbWmezw+UPzzZcubvB0HhvwJ/JBl1uJS4bz+5KcnHzcQuwfCL8eN3RUkpZuHPD7/9eMz7ip2D5c9rJoZvP36w/f7NxaL05v9JsW+CD38deH3sxfP/rF9+X5S8oKgvf/vuG5a/wp9fP/wrwCFwn4XvLzOT8huxG99fM7B9YWL9/47523+239zCHJ///vr498vdH6/FX/28y/Hr/Zf3iuxiChy87OzsrCz/hT4JPP3z/9ePd3c+M8h8+sfLyf+W4/Mrrl9/vt3/+fKZgKoAFxufmKaemblRgKrSf2UhTjGe0/zvOL6KCQpJifEpKfEK6n8W3vX50eNPD1/zsz348UNAiOevgPLTj0+4/zNxKUhKm3KJc4t8Zf/24f6vbx/Z+f7xCP74zcTDyvdR5Mfbl38YPn1j5OL4+41dlsWAUfCHioCQNP8Xhl8nz/398Pju9dff2Tl//XjPLsvKaSinxcvMwOnxT0FOnFvoPxe/8Osvd16/+HX3xzdVHn42fn7mh3/5vgk78+oJ6Cl8v/L12Qs+XnFWSXFGFiamZ0LvT7+5/ZeLTYL/jzKrDjcTo9RndjEVFR4eLl5+MUZWVqZ/zOxMTD8Zfv398pvlDwfHP+Z/DAy//jL+YvjPwMTC+p+Fk/HvbxaWb19+/2BhZOL/x8nH+e/Hv3evXr18/nffsfPMfL/VRJVlJfgdedU5JP6qeyqyqDD9FXnF+PnF35+Cv95/Zfog8JtFiPHrY0bmv3++sf5l+s/wk5mBmfHLtx+PXnx7+fXn50+PGf6xvXvz/scH3o//Xn35xsunLSDLw/Cf9/uHP9/+qQjyvmB7x83xkeE7I7MUI5+QjIgktyzLfw72/yxsbF//MvwUZP4v8vv7N0Z+jh/fvjx6/PfetbfCnAL3me6wybG/ff/t3quXv7//+8r0X5H9BS+b9Dcejt88PJLv2f/94+J59+M7w6c/L3g//fvJ9uIb/182BiE2iX8/lUS4uaTk/nD8Z2b/z/pW9O1nLl1JJVmhH3efvfix8/LLp7e/iPL8/vOdnf03A8uv7XvPH7l5nvf3P3YuoSf8fzQ/CXEKKL788/P17+f8X/5fZnt6V+ivFruwnAA/2y9GDiW+K3+fvP/8/vuj528/vPvDICzzm5v9N4MAg5DsX+Eb/H+/rnp588zX17f/srz99oOV4eutFy+v/vvx7DbDt+8f/v77e57tPvNbKTYOJk5FRW7Gd+YssvwsfBx/OMQ+M/9i4GBgZOD4zf6bnfWHGOv3179ef3vz+tu7ewxf/3H+Pcb6WJj13x92Rsm/LPIS7EL8qvx/2QUYeHneM8opGoZm2EVp2XMw/3n9n4Wfl9PExNiIUYHnC6vqF+ZPf96++fFwzc0Tq9+8Psr0kv3TY4b/f/8yMnFx8b3/+kOB/afkG+ZTt27zMQu85fwgKvuTn4n/nxzPX+avfwVZvvMKcX/6/lPo+Z//7DLcrGy8vD+Y/n1h+7vx4oUHbz8K/fv0X5DrH8erb4I8fGx/ubi4Pr78wSguelH4Hq+cpjqLyjeFvwy/OBhZPivx63BLfPn/9dOpb88+f2X8/OHrw9uP1z9Yf/3T5Z/M7I9vPrn14t3vp/8+/n7+5Cojx5WPlk85Df8Y/f77nvkTL6e6oBQnCzcT48+fv/7+/PP/9/8/7H9Z/jMwsDH8Z/7zi/H/v79//v//+/vff86/LH8Zf/1lZGf/y8DFwcHB/J+fkZv593/Or1/uvP1y59GN16cf/2T48fjfk+9PGW69fSzwQ0Ty/29dRyUGSabvPzmYWD7/Zpf7/en3v89f/nMxcv77xsAjzvLz+z/mX79+//z+meO/4Ed2ZibGP//fMLz/yvz+Bzvjr2//hUV+aPOI/PjD/p6FSfAH/9efL/h4mER5JLjf/PjB+evvf04Wxu+qsqq8gv8ZuP5/Z2H6w/Dt3//fTCy/GX+ycIiK/Pr68d7bf+fOn5HnkBRk4nr28TXbz78Mb6/9ZhMRFZYXkhR4cuXmvy+fP3349kboD+vHX2z/BD58e8v8/RsPtwDzHxG2L1++MTF+4f3P8OaPOJ8QNxPz+3c/vvF8FWJn93O35+Vj3Hn90aU9d7adPvX3P+9/Bma+7+Jf3774/p9BgZvp3/uX236+FeTgZudg+PHiH+dfwY9Pf356++uvsCDb33ef2X6JCEpxfuNUeMn4/sfXJ6IMHOe4P5178UWa4bsI00eRN3zMv97d+Pzzx3eGP68Yfv3+zP+GmeHPN1EJjl//v/39++Pm1998vz//eMn5juPDw5dMPF+f8Etqvfn5hvPNCyYebpY//D/+v3v36SOHGDsbG+eTr68ZWPnknrLwc4h6i9u5fuayFDT7w/DX9qsEqxDH77+cZz6e/Pbr8SOWP58+M4S7mQea+IvqyHIJiEv9//n9/98fTx8LK/H/4n5+R/DrG87PD94+FWD4F/BV7v/LV/dZeXhYpG/+fvz1/bffb//eu8/+6u6PLx9Y3765p/tf/heXgKigiDwf6x9R/l+/nzEIMf1nZv3+g5WZj4GFhYdR+hsXIyf7w78i73j/ffv/9Lqc4CdGHj1eIW5WaQbBZ//ey6vySr15LfJHkvv3nxc8/14ef8nNyvnu868Pr19/ZP3D8l/s3/OvjJc/vHn1/P2Tu2/2yH27+vv/7+csf7/8ffD/06vfXGyctpISeqoSNyT/fnn+mO0LmwQri9Dv/594eP5x8bAws3IxcH9n+sv889df5v+sDEw/QGn/PyMjMysj258/P38wMjP++fmHkY2BlYGFg4WJjfnLn9+vXr6985Hh29MXj66++vXr7+UH3wW/MYiLsD76zvj00neGt78M/vCKmSowi3B8Y3rPwPiZ8fvvPwzffjD8//SBlfHb9X9M738xMPz7w/D/13vezzL/fv/9zSr4/fkf5vd8X78yikroqAtz//n15wPXe94/f/+yMyj/F//MwsMg+YeBlf0Py2sOZva/DJz/ZT9qSupy8P9h/8XM8p/z969fTP+Fvn2+zcr0h43jN/v7/5ce/j5+/inn199i7ExfJKTu/mFh+P/o3bv3fz//lRRgY2DgEOTjZXjy6eWPv5/ZvvHycP7n4f7HzfmH+QXDfxYuIcVv994y8v1j/cf04/sbNgE2ud/ff33//+H351QbY0EZaSaFj0Y/uL78+vyXhfnJi48vn377+ezP41+MDCxsZt+kzn8/+f/Dn3+/PzN8/v2X+xcH20/hT5zsf/n/fnv15NOfF5+eCwhIMvCzfL/7/6fIZ0Ymps+3/wj/4ZTSUfrygYGF+Q8L4x+GT3+/cf5gZ+PmYBAQ4uT+zPvnz48vP9n42Z+wc/Mw/vrN8uLnf6YLzO/533xi+inwQlTw77+vX5j/K//9L82qzvv7l/R/bl0RRTaun6ySknc/3JvGuP6kJM/hx5d2/r5xjvfxiz+s136cEmbSuc/y8+Lf6/9ZWJZ8v33rxfPX37/9/veKh0tA8tfXK38YV30+wv+Hz+qf2rM7LwXYNJkeMP8W/PdShNHm9Y9rnJ/EXn/+9u3H02+ff77+yvSHi5flDxenyLGr967vefvqzYt3Hz6zv/jPKi/5//2/d38+s71m/sPA8FmUkf/zHzYOjh9f/rAoiP7++uQj/9UvDF8kOXl/Cvy//eW3BDu3HO+/6zJiP3h+fFJm+PfuA7M44xfur78f/v58+c2P9+8+Pfr4/vpbttd/fnz6xsvM9v/Pu19PGIS+sbPyyzAzfuISl2Qz5tS0FPukqcD15j3HX0ZRPiFJGWk2YVU2Bi6Wf3+YWP4z/P3L9Ps3MwPf3x9/GZiYOP4x/Gdk+Pv/93+WPwz/mRj//2Zm5OBmZmZhZWBkZv729cunD5+vvn33+/tbpm9/d3+6z/NT7P2dtzcf/1L4y8Ii//cn18+zv/5feftagoOFw0KMkV2A+fvnP4yfmZlY/r9i/MfE9Pe/JMtPFkY2dq7/DIxCHL8ZXv0R/Pz/z1fWfwI//rwXk+cS4Xv25T/3KzFW0Q8cvz5wffn5482Hdx9/f/3/6RuDuDD3l2+fOP6zMf5k+sjCysYkoiMpxK/wV/Hf/6+Mv1ies3AqfeF+zcjK+pfhJwPDr+dXv+85flxaWZTh9VNJEUEWBpaXzAw//3zg/c0gxMIszvufj5GNkYlR8PM/Nq63bLyfeYS5Bbi5ONg+/fr6hff/DyHO/4w/WbiU1SW5/6hLy335/+vjn08MKsIxhkqyojqfuf+fvf/67+tP55/d/Pr758cPHz5/esPw5Ikgv6ASm5KsCN9vcZa/TA+EJUV4GTnZmP78+8v86x3v3w/vf/3/++zN53cvfkvKcrDziPP/E/rEc++LNCPXm99/fv7k+iTwh+8PAxMb46f/3F9F/jG/52fg+/b/AwsjPxvDB+Y/zH//iAgys0qJyrBocMi9ZPn//f03A3axt99vsPNKiPFLCnz99u0n17dfP789uPeB7x/zh5e8jJLfHzzWE2c/zPhXU0jf67fIQZ73LM+Z2Pif/eHiFH4lzi/G9ObOy2mMOxM+OXN9/fGJg4uZhf3Ty3ccv7/uZmJme/zqsyiX1N+n7wS+Hr1/++W9T6zyXPIsv9+LinK+fvGHj/EH8wcuHkamP9w/Hn1hevv774f/78//4ZBnYWL8y36DkfWL4PuPrzn//vz6g+3zR7afL7/8ZeRkY/765yIj+y+JD78+Mpoz/P8n8Jf5CxMv+0uWb/+ZBZh//NYUkmH58uYsL5M6v/hr5n9c/5+/12Jjf8TGyPH937O/z/99Y2IW+sPCziPH/JP1z+u3X5l+8giJCQuz/v3FzPLsK5vgp8cczIJiUhLiUkJMXNwsDAwM3Iwsv1j/M3xnYmFl+S/wneULGxPLz9+/mZlZ/v/6xs7Jz/Tn+xeuf/9//GFgYfv66yMHK8/PfwyMn76/fv1NQpD538PHy888Ynn1g5mNlfMPw5MTvy/xPjVglriu9uHv43//BBks+PTFxW5cMuF+vfMVMzP716+srLxc/7+9Zf3378f/Xxws/7///fPvqxDTr1cMP0R////4g+2PiJygigTr31cSb/j/sr/79fefkBDjhw+CLKwvmITYf3///ofp7zdWVj5eTgbGX78Y/qq+Z3kgzi73Wfvy/18izxgeszOyMv36yPCI+7v4N473zMz/2b+wvb31VpD1wBsOXYaXvxnZuVlEvv26/fG9Hicn868vLNy8PL/YfrLcZf0j8P0Pu4KAuAAL/2OGDwxcut+/XBEUU/v28fM9tgdWoK6myB8ONjEuprdvXl4V+qQgw+n2le/euxc/1Ji42Rlt5WTehLz9wvDPkJXvoZQC1/d/PBzc4noiSULCUhy/niqKvnh5lp3t//ePnJLCnL++vnj/6+89wRe8L9hYOb9xfPzy6tdn/q+sDP+evv8lx/3n/Z9frL//MzNzcTN9+fhZ9BPro7ev2bn/fWLi4WL6wf1F5InQX/ZvfNwMXzm+MP34/lzihyD33/8S3/7r8yirMXJ9/fPxL9uvP1w/1UUUpcRV2dnYGX7+/vH5v9BHwd2Pbthzid7+8n4y39Nbnx8o8inq/BXS+8n+nvOX+Pefv7lZvRmUNn479/PH+2efPx5gf8st/d5A2MiJR96BQ0qH/f+Tp19//firxCGsqMgn+/M3H6vUfxYGcW4Rpr/szF8YBPhYfzG9f/b9FePb10wsDKxif5mefPnHwPjhE/Mv1Vc8LP//Cf/l/vmTjfMnB8f//3Kv/7Lxf/v0+Dfva35Jce6HHx4++y32hY+V4R//DaZXl589u3Pr+tt3j97+4f4v9OzPN4ZnzJ94uPjecv/6xPX665O/HJwcTH+Y5N7+F/jC+eufGCOrmIks64/PH9hYXvK9/vWGi4OLQeg3tyKfpLKCBIeACLcYD7sAH+efP/8Z/v38zcTMxMTA/ofrLyPTP9Z/v7+yMLAysbD8/P3j6///zL///2Fl+PePmZGF4f8/5u8f39z88I+B+Z/4u587X717++URx1/mX/xv/zBx/X5/7+4J1ovv3zAy/mRT4+R+8efVl493rrz+9oWDkfsPB5Pw398v//5/9+/Pr09M3/8y8/749J+BgfEf88dfzCzM3378/sElIM2oqazwn42d8e83tn/f/335x8z/5w3/f65fjN8Z/39WYWJ+yvKDn/PP13/fGVkZmYS/vbvK9ZmR4d0fzp98MiwSAvJSjF/Y2H+x/uL8wPKTgeHvu1+cz9jZhdm/M9x4cv3ho/eyvxiYOZj+MAuxCQm9/fXz/e/vsrx8MuyMVlLaisL8oqKSf1k/Mv78xSIsyPz/LRujyOePr58yfTH4pvTu24cfn/8wf3rzi5VRSkRc/M7n70wcPySFVeVlfCXNP/x+z6Ik81r2s5S22Dvdd+zfvt76efvt85dsPOyXpf88/8F24ukhvu9ijJysTAwfnj16/vLBa67/kjbf+Nm4GdkE+ZgE2b5z8P7l4Pvwhf3V3Y83Bb/zi/Mw/mD58+vz3/8CDA+Z//0WY3j2gfnV/2/f/3I+ZnjL+ov1nxCLKP8r1p9MQryqT17e5VaU+skr9OTbM4a/XGx/RN8zc/9mZxf/z83A+EeHQeQfB4uc5D82TgGhm793vnj69e0T3dc8cq84md59bv116eTftwqfef/ycEkL8zN8+vXg0Zunz968+nX178c3In/lfv/68/3rmw08b5h+8v379Y/tm8D53y85vzB+F+L69v6F0re/b37//cH4VOSvGNMPwb9vP/55xMLIIc0s/J2dh4tZhufbiw//fn9k/cfPIyb0T4j5DyfXD8b/AtKiCsJifIIiPyVe8UqqSSj/+q0u8+XBu5dfXv/89+nJqx+/XrMIvOZ9+/Dmuy8fBf/94mHh/fn5Kyc358ffbxl+vmb5qMgn9ve3GAPLV06O/xzfuBjeMHL8uMfKIPCZU/Tjt2fif17/+nfrGQuDOJ+I0E82Nj4+Lrb//7j/MTEwsfH8+8vHzP77H+O/P99/MTL//POTnYv7H+PfH/+///v1k5ORkYmFke0P86+/35nZOL98/vju0x/WP18V2P/c+st2++rTb9+EmJg+/fzKzfifgVPg9/en119f5Xh/6ZsmE98Jpt8HV1y4ff/Pz9tM/8T+MjD9YeTgYvj96z+fGPPXbyyMb36zM/779Z/pCxvD9z+/efj5NThN+bT+/2b68e/3ZxFuvvcszDwiDJ/eM7Ow/mBj//fvPfcPQUZBcbaHv//zMv579+f/py9MbGL/WP78YfnN8o/7v+h3KSEBTgmND3zvOP5xMv3mYWbhYmOQ+v/j+38Ghr8/vr548f/SjTMsr//9ZX7F8P/bB0Y+dkHp9y9fivCzcYiKiYqJKQmwCIlI/mX7/evLJwmm/4IS4t++/BD4yissyiHEy/L/Hw/Tf64f7388evmOl5+T9dOff18+vP1/+8/f3yzsQjzMXwW5+X4y/Gb+yXP/3+sfN14+5GD4/u6D3Jc/B1jO81xjuPD81p1r996/4n724sHbj38E2D5/4+YT5WH58OSVGIc0nzLTz+c8f24z//j1kekcy+vfr9m+MLCCBlX//fn/46fot79/GX7/+s4ow8zCJszxj0mO4z3/TzZFUWEWdvZv0lJiVz7d1mFVFeaTevnl2aX//0R/8qj9YPjH+eHbu7dPuT9w8TM//fyekYtPkuXvi/+fFX4In3tw6r+ExD+Gf7Zf5BX+cb4X+vmO5aeKsDILK5/2qQdPJb4IfeNnZ2X/+//Di7cP33OzcTxieMD7/ZPI//8/Xgt/5/nyneH7V+Zvr7+xaAr8Z3wo+U/jBddDzh9C/MLyrP++s3D8F/gj8k+Mg5Hr+z/2n79+/ft3leGzxjO5BxJvlT8xfBH4q/X+118+Dn4mdSZ1FgEGbkHxP8/+MOr8+XnnK8PnfxLiok8Y7rHekhASkfnz788nxg9/f3M/Y3mlxCD2R4Dz81s2EXU2Fg5mwbu/mThlOf7+eMf1hpVV6duLz0zsYt8/ces78ChyiskwCEtL8v3m4ublFWLh+sPyh/c7wxfGf39+Mfxj/cv0i+kb1x/u/yz/WDmYGf4w/P77j4GBgZWd7fvf7/9+sP5i+MvN+u/XB5YnH86y/NGQZWf++Ztl9pbNzC++snOyM7ILsL5/8+sPGxOH3H+uzz9fvvn8i3HntyMMz8R//GBhY3zN/IaT+ZvgD95PnB8YfvzmZGH68v8P27/vfP/EPv35wMLE9JuBk4Vd5ocOL993Rba/j/9//PJE5DPrByF2zv+f/rOyM738zqrJ/OelwK8379iZ/wkJcL34+p2V6f9/Hh6ef3/eC7Lzfv3+9y8Dy2c2bhEmaaZvv/5xsX4X+Pn77082BpY/f//9/PtH7DP7W17mz99OfGf6cumxmPI3JQHd26/v3ediEP7M9O3Ld6vvv9/yMAowCDGxs0nyfHr+4ufLP7+YmVnk1EX5fnH/kuT8eu+bmPDP73/+8H7/90OG/9v7b7yCjFyifxl+Gn179YmT99t79i8+X1Wv/bslwu52/9cdrv+MX9h/nHl/987PH3Kv5b7/fPPr5/+vPKKs4u/+s/IxMPK8//+F4TXvmz8fGP5yfBP+yvTh7bff35gFGVne8rMy/P724iObDgfjE07WPx///frP+JTlnxCzjIi43C/+O+ZPvpxh/PSV6zvXe76XLExvv7z6zcQuyiL68sFTRnYRJk4pT2Y5TQFh2f/ih/5fvSci+v3t+3+MYtLsLOKfmL5pS0t8kuVjZP4mKCb26628ON9L4e9vuP5LiyqL/Poq8OovDyMP36/PooxyNxhusf3/f+fVHw4W1d+sXML//rzhePX9309utj+v/n9glWd5+/PhExGGbwcfCP1iYeFh+8/E9ebHyzc/v3Hxc3z7+Puv4m82xg/8QsKcvGy8L7h/yX5guiv4iOeZ1O///KKsrJ8Vv9/99uPZe0ZGlq+f2Z4/evjo9xPWHxy/WX6xsPEwsbGJCHPzCt7//eUf81/W5z9/Mj/jFVD8+/7lx68/mdTFVRi5WAVeMrLKirMIfLzJ/u3fD/6/Et9ENLj49Hkk5PnkBATFxQRkhfn5xKXZBTgZGH8z/mH/9f0nCzMLA8N/JiZmJh5GTnYuBtbfzIwMf/8w/P7HyMDIxPKfhekP6x+m/39+/2X98+fPd4a3r1+8fiEuws35n5Oh/9lJho8f//3n+Mfw4+8fjt9sv5m4/v/6+omJ6TsDw1+Gjz/+3mNi+MLwh+EVFyf3X+Yvv/79+/Oeh5HnNwsXwz++b/84uX/9+s357j37HzYGZgYJMUV1CakfbKJ/nn/58/MP11fGXwy6TP/Z/71l+8LOzsb3l+k5AyMbE/M/5t9MfD8Yef/w/vgDahG9+cfExvqF9zvTlx//mb++/fSd9xsb33dRKSk2FnbG3+9//mb4+/M9CxMj848/bMxcjH9+cjD+vHXv8f2Pr759+MX469+jq58PX3ly7eqjS+8/XP/49vX71+8e3v3HzqnEwPryP4OSkMhXlg9MitLM999KCIh8Z/r1n5FTQFFKg4lDWFGeV0Dwx7PPn769f/fx2bc/UpxPeD9+leC7onz99CXOZ9/+K0uqvOF9++jv7zfv//JyfP/55c8X4a8PH/6+cZdTnJuX/Zv4b90ffx6/+fyTie3r/Uu3fl75/53zx49Xzxj4v/4R/Mr+kfP/A6YfPx/9+v3zNyPvH3ZOxv+sKloiLNz/dX4oCCkJ/ZDkevPt+5vn/5kef/7x/Pr91x++PJT5+fLvd57XPxj+/WT49u+yxA/RDxIsXy7J8pkqsbNxs8rz8DKJ87H+e/v+Ce8P3r9/7nGxWPwT4eHmP/b30a+bT/5xcf5k///60yMRYcVnPD+ZWNhZOP++/f7yMsPN1wxv3gt84/8gIsPJ/5+RR1pclpuRn+0nI+ffX/+NhR7+5/rw+zXbHwaOP8zsXxne/vz4S+LXPzYOPmGBL7//sf9k/SD+h4edlUGEieON1DsW9u+C3/59/ycsIPxNiunL/Z+fb/76+fDHv8d/Xr16yM4kzPTzy6vfd34+E2fVUWfg/vJL7D/XPz426TdSpwS/3fvN+Y/5A9OrXwy/P//nvfP3DZOwuJAY94e/f/7dY2Tj+q3Pyy8iJvT7LsOa+09/M/37x8TIxsr54/eXr3///fnz+/9fpq9ffrMwsDL+/M/6l5mZgf0fC9Ovn7+ZmRgZGL8z/WX78vPL/79MHGxsnP9/ffr8+zXXL31lKVaWnzc/vXm56xXja77/3Gwcv379Zn3D8J/v78dfjFyMrP/Zf//5yi7y5d8f/t//GP6Dxu6//WVl/y32noOV4cdfVoafX1i+8jH9+8oowPHzF9/Pnz/5pCWkhFiYef5+Zvry/cPvvxLf+f+Js3DeZvr68j/Da1aWryyMwp8///v/h0FOgvs/M9On5+94GUU5xL8x/eb+9+ndt69vfv8R5mD8x8HK/vvbN2YuMcn/XHwyHIzSHAw/GZiZub6wsDH+4PjFzcTEyvj/ryAT26eXp4Qv3Tv36tvPj68eMnz/8OvPv6tXXtx6/PrC3a83vrxesf/c099chiLi7DyibFzsH788YRYS+v39tyy3KK8E79f3L5l4uHj/ffrx5f03CcEf37+8ePT/6JH1p69cfvXhCTsfP48cO9cfBpkfPBeFXjL8+MLMKfz+7/NP71hZftzn1JJ585/j1ft3n5Q4rr0+/Z2f868oB8s3nv9cIkI83LxMLLwiCiL8bKw/eP8J/+T4/Y9ZkOEPAz/zbwYO5h9SAux3Xz36/vPzfw5hRQYmxf8M316yPn/wkkWbX/fzjxu8fOIijAyP3754ys+v/P7PT8EPcv+Vfgr8FmQ2+sXw6sGPD8rcIp+e//ggxM6m8u3XXyHmvwzyLxUvSF6//uUn649vB/+++/6DTZTx2/pXT6W+/lB9yi3DaXj089Wf8qwibHz8L389FWXg/vTmB6f47x9vv3xk/ffj82+BX4J/+D59/yT4jvfNl89fRTkE3on+/vPxG8cnwW+qDE/efxP/zcAqxM3IJczPw8j3X4GP4+nfz2ySv9leCPz4+eGN9G81TvZ3QmysT57+e8/Gys3z7++/v7w//ikzMX9gYRf58eXFv19CX3heswnKs167/YXh52/mX9//v/71gZ1HWozvN+sXSWYxbm4WHnHpD69u//715+H/H2z/RH++/Xb1+zdRlu9s/DZMzIzMv3//ZeBk/PrtN8O/3z9+cLPx/mH8zvCfiYGJmenvv59ff//+9Zfh3w8GDpa////8Z2JkYWFgYfv4/vmvM3wv7L5J/eFh+vbr66xth1nf/fsnxvD7x5fv/39x/hX59fPTT+Ff/37x/vjDxsrJ8O/nG1aGH79+/P/HwvPvtyAz7xeGByw/JN4zvmVgEhVl+MHwm5WF/dfPH4zcwmb/dFg4X4uw8Nxm5eJlYeX684+BQYCb89HfN1x8Ev//sfz5zfzr9yc2Ic6/H5gePvzzj+njf0mOfx9f//8vL8T1/c3/f2xC/3je/Pis8JftASv/Ww4G5l/fuLj4mf9z//h5R+zNn5d/2X4+Z2T7949Z4S/jFxbGb3+/8f/9/fTudXYeRob/nAzMjP8Y/v7++P/Tj/t/uAVYPp3//oORWYSH4R/DdxbB54qCBn+YbjOryAt/4v3+56sQC9vX7z+/c3Bw83GzP/3L/P7rg4fPnnz4+fL+UxYlDYUnb4UM2Ng+CN35++Hnn2cST7jvc34Ufsfwiv3zF57/HGy8H17el+MU5BDiePnyJQ/Ld5Y3/KJcglxybAbf/j34/52PXUlW4Mttls9/3/5m/cv9j+k/y2dxBsa3//6z/2f6ycYp9erpx1diz8UeP+Xn1H/L+Zbj76e3imxMXCzMH2RFPj57+/DeCxbWX8Lsf+7+/f+JjZGZ8Sc3B8+7V4/vf/ylwCf678UfMXnNT3cf8nBJG/9h/sbyU0H097d3fNxvGX7+ZOBiZ/r3/y/z+58CHAwvOH7u53jx6N8Nlj/sHD84/7/4+o2PjZ3h708uAZH3Pzk+8nz//OcB5xfeT0I8/3lYOf6//PKO6a0g2/3f3xg+McuycHCLsDH+ZmD89fs9nyAv30uFz1x8DOzCrAwyDPymAuyfRD7yfn4r8439wb8PP1g4+TjZtZi/irAwfmdn5H3F8ebD75dsPC94v3B9ZZT8JfpYjpmLX/Ytm9hPkd9SP9n42P68E/jzjeUfOyuD4H8uGV5ZJl4hRlYOdTF2SXaRt+Kc39hk/7H8+P1FR09HiIfnHzvLn99///3/8/vfHzYGTob//74zvef8z8bMzPTvD8OPf5/+/P/DxsLEyMj25+vfv/9/cTH9ZvzP/eYlw6P/DBa/pb/xcf349frQmcd/Hv3l+MP299tP/n/sbIycv36+/8n59f/7f79Z3rGyP/3D/Pnnp+//WH8ysX37y/z998enf758/MUuxP2Vg1GI8+/rn/8/vWVjYP8u9FVciNuEWfGrMq8gK+dbnndMYgz/vn1nfsL6XPQn+3/un6+Y//H//vX32+/P/3jZ/jNwvWNg4mL7+YOJgeHvP+6fHK/+c3Fx/Pr39xnTTw5unldMzBx/f/HyMrB95/jP/JXhM4cgl7AMx38h7v8civ/+CjL9+fDnH/t/dq6/f98xsbAx/Pv26e8X1i+c/xg4Gf4y/PnLyf1b7OXTJ8y/f3JxfX7+8f69xy/OHb5+5e1dM0FVWTFZJkmOv7zvORn+Mb/9zPKF4cebr3+EPrKyMv0R/MPH8EWFR8iMU0haQ/gF69dPHH/vyPx88PbJP0U29n/v331i/fWDWeSPKIcYI+8f4Wf8jGzPfgnISvN85/7P/+Uz8x+2D6/MedTN9JRY1P595eD6/o6BVZCVgfn7d0YG5h9szH9+/+ZkZZYQZP7z7u9/3h9PPz99z3rxxc13338Ie4gpGogyffnwVuLDHy0JqY+qgpwcHN/Yfv6S4fj8/sePb98/fvv1meOjBKPQG4a//8UE7jN/1pWQevvtz3mOd0Jv2S7+ff6G673MTzY2fq5PN96I//vNKi7Jy8nF9u2P9CfB5xycP9j//Hv+6em/+4///WJ6/4+Z+ddrnu9civxsf1llfv+XYOT/x8vA+YeJlYnzG897tj+//8v853ku8PsfA5vsfwYJMX4Jodc/P0l8Fv3Bysj59//HG7/Y3nz9zPSVh52H8x4ngyDX96fM7568Zvzwl/ur0F++x2zM8h91eFk//Xmp8knxiwjfI57XIu8+fn519fNfbnZ2OWYxbpbfvyT+cDAz8TF9VZSVkmJm/srFxMLAyC/Ex8csqiknyPj3wzPuH/62+naC0px8fIx//zOyMDOzsv/9yfDr3x92Zg4uDv6vDL/+MzKzMzL+/s3MzsbEwML04/d3BlbQhNI/BtbP7788+/ZDjP/PLw4mFub3d5+93rPnNtffXwyMHD9Fnn9j5PnDLP7n/w/Oz2z/OQV4vgn8+SHMAJpS5/zzl4WJ5T/Xb2EGln8sjBwMX/7/Y2Rj/MH4V+T337/srMw/+RnF1SzUPrP+/XL30///XCLfeF/+e/P3N9Pfr5/YXjF8/87DxvLjz7v3nP8YGfj+f3r1n5OFg5Hv3082HuZPrIx/GX6xMrx/9Zmd7weDkBDH56+/xNlYfjL++vHiDzsr25e/goJMP/mEpTi1lGWFOQVf/mJh/cn6k+UfA9NPjv9Mf9nYOP/9ZWdk+v2XiYGB4c+/fwz/Wdh/sT3hYBVmEBJg+sDw8f23J28+X3v55fjBZ4e+P5Z8/ZlBlJGXT/j98zcrzr/89ebWl083Of7w//jw4sL5m8z8PFyqoiJCvz89eHvi7vN9189pfWBj+8z/4PzJ319kfsg+5/0jzCP2j/Ubg6AkL9PTj3cevfhw4eO7FyyPnr358PTDMybmF1+eP/z9XPjdnydvnrO+F+Bj/fP3L/O/z29/sv34zcb7n+Md21uufz/////6gfmfOONHRhbG/yL8zI5SOrYsIkzsf//yc4t/+/dVnV3+xb+PSl9EdH8zSXGJMvz8xc3Nyi4myfTlk8wPGVEWNomfHxVYVRi5vnB+4xT6ysnCJij04juHEDfrP0ZGPgGW31++Mf3++P7TTyFuXlZevkfcX3+8YZbh0ZA1/sf49T/Ll1/vWCX+svx49vatxKev777+ZeF9+v0OP6uYgJSguBQ7tyK32DvpN6xfuNkYfj1/85Xxy48/v9k4WJj/f//L+pedgff9l08fH7xn/yPE8PUfi8pH9t8f2QX/f+b69vbHH2auH9yyfELSf2Qe//krwSL0TeA9//93Pz8zvGRgfP/j45s3jxke//78+Ye2OA/zfx5Bxu//xO68fPvhx++/rP8ff/3079cfbYE/7368+cvNziMlKM+vxC8q8uvfHzYmZlY2pj+/fzCyszBy/v719x8zA2ilwN8fvz/+/szOxv37N8Of33+YOdhYWJj+/P395svPxz/fiDB85/rPx/T/0/+3P2YdOfz/8/PfDIxfOT5zfZb6LPWc6c9LBga2X2wMDH+5/8h9+M3y/f//b6zfONn/cP9n+v/993cGZt6f3/6xcXP8+PGJ4dtn9hff/3KyMvJKaSgI6MjLMUjwsjOzfrn37qcgp8InYSZF/q/yLD+Yvv9le/aTXeoXH/8Xrl8srAL//zMzMDD+ffuUlYeXh4HlNwsTHz/TH8Xv//9wMot8YuRg/f2O8dffV5z/5b79//LzF/NPBqE/L9/94/3Dz8Uvx2XAz8vF+AWUob/9esH6R/Tr2+cM//j+MTP/Y/3Dws7AyMT2/9cbxj/83xl+/vz/9jsDCzM3M9Nv1j8fP/28+3j30quH77+T+PT21+uH547evf/w+oHzz399/fXnB/MrMW45aRUjWWFNEbnngkxq/Aoyn3jEvgj/fPuFVUKMSUjsszSD0F8Ztj/PZZVEOTj+ioixfpFhYpbifP/70g/W38IPGHg/fuF7wvXiDyfLE+FXb16z3P7KwPDpzeO/398y/eMU/PP3/r+vLKxfZT5++vHhE+Ofz59+fPzJK8jA9Z/1w+e/q/buOfb4I8szzp/i/388f/CeU/SLhrjRn09f/33+/Onzl39akuIvfinzyn8TesjNw/zw4l0WM4Uz92+yCLAJcf99L/lL64sgh6wi5xeWn8/eP5VnNmLV2vb7ksx3LtEv7/79+nhH9q/iExEm4e/v7/8X4/itKCRxi+H9ox8/eJh5ef+xsDP/fCP0ReqrKuPvT4zcXJzfOVXFRU88uvaXjYHtreJfvi88vxkkmX7/e8Hzho+TVfg/y5/PQj9Ffv39+e/5UzZtKW4BAX5BkZffP0ldUmQQ//Th71fuT7xPGX6wcTFyvP/+g/nLv1cyP4R/S775x6ykxHr37bdvnO/lf4k9+8nKI/2H9T0L08ffv78J/1D78vL1q5cfVQxFRXnVRSW/y32Q/iMpzMny/ycz57/vDP8Yv/39w8j8/z8LK9uvnz84eNkY/v/lZGX6w8TIwMLIwMj6m+E7L5fQ1+8v2X7znWZ/Lf6cU4mF9bsgz9/frN/efZ5x9yLL2desvEq/GB8z/Gdl/CvKcevTf5a/TMy8zL9u/+QQY7nxn52XhYn7868PrAwMv5iYBdg4v/z7/Zvx+8//nF+Z3nH85PzFxq7Izf/dRI2LRUjs1J+7Uh/ZPrAz/v/2nYGFk+H7b9b/H7leMn/nY/j9W1Tg7z1GToH/Hxl/sn35J/Cf4T8DI4sg+4evH4T/sr5m+8/EL/jo8x9GJg7mP795vrAySXxh/CPG9p/5DfdXXWaWa2/ZhVl+fvz/S/kT/xsmYUGOL2/+/XwqzPLryV8+zl98vxi/fmZmZWb6+ufPH9bvPG/5vrP/ZeD9y/j0z4//jGxSP77++s3ygYuDj+Efw9tXX7et33GfQebJg48X7z5k+sh15cmLD2/ZBQy2WDMqCRv8//Hmw43vPEwv3xwSZxX8wvOW+et5nlc8H7/ysrL+e3nvk5jQL0YBbU4GXl7ejy8YeD8x3pf6IvxOken1JwZh5j+/OV8wvPj+4TvT2x/sTLyf+Zn+/mD79esrM8t3pj+8jMIiTD/f/eLj4Pj5+6M4y8+3LD9fMfxQ/KzMr/v+/aPvL7m//fvO9PHb+8fPn/7mYmMR4Dp7/9ovHraHrJyfmN99uv3qBy/Hx6f3uRl597/Y+4uF782nr19ffBZ9y/WejUNRWPzln49Xvjy/wcn4XoxT6SvHny9ff35k+sj+4+93pqfijAo3f9+SYnz5+sd//n9M3PycrOKszMxc3ySZGNh+/fj1T05K/NE3Ma7/HDwsP/+/5RPgf8LNxKQiyMXPz/n7BdNPVkZelieCP//y/+C89UH/H+/7/z/ETXjYJL4z6Yh/vftL7KvgO5aPDP/YGRV+fGP7wfKL4f23D8IMPBzcjFxiivz/BZkUngu9Z//Ez/eb7ccrWfZ3Ii/YvnP//8/2VYz1lwoLy/dfIhxKj5hvMbMyf+b7Z/RDTkNMxVBAXVBJUpaXjY+L48fXbz++/vj66fvvH3/+MTL9ZvzBy87Gy8n08ee3Lx//sP5lFPjJ8vfbExHG7+y/vjL+Y3///rPGZykBwR+/hbmYWXjY/r7Z++nZ472PuLlFfgg9/POT7Rv/zx9M9/7ys/3/9+/v/3+g4fp/TL95mZiYPn17J8HM+5+Jj/cf8/c/X/8wMQn+52T/90PgHxPX3y//OWV4dTWUWYW5Pwl8UX4lw8rK8uPfzx/cHP94fn/5+e3Hd252dnbujx8F/3/5w8r2keHXV0a2Xyz8jK/esAqK/Pv1658cz/cvP9kEmf8+//nv/382bo5/73n4v4gxCP9lkRT/+/bvX0Fe9hcfOJhY2H+IcH35xv6Ij5GDhZeBR0ZDm4f7H2gX4o+X3E//MDCz/PnK9O/n/z9c31h/cn5j//mL4QPzD+H/HPx///9k/fmXnYvxHyvXby7mt7++33/0dv/m2//v/BSSZGXS/8HG+OP+8+cPjjPcentd/Yv0xx/szz7d/MPJw/Xj9usvb3glX/G/E/rO9u3t/RdPOZnZ33Gwcl069+oZq7zka6HPzGyMIvdY2AU4BVgFZVi4eL7+eMn65d6nN79Yfn7g/MrE8fn/t79MYn/YdYV5Ffm5ReR+y3OyiX79Ls3AwMvILsLIyMIo9VNMSoJJRVRMUFTiAdttFhl2zu9/xO4LP+N+9e296AcWJlY2/t9/+YXkPkq/+nRHWkL19tM3BjKm7JzfPjDzcGj9/viaWZ1V6uene4yCfMIP/wpyfvvEyPhS4LMcH4fgL24VTq49P+/pvWX9oStg8fjrZ36xr4zf/jH/ev7krpaE4M2/X9+/fMEsIPP1+hUNbYcHf9+8+/1L4RPHN15GXkYe/i9s3wRZ3nN+5v78V5dJ5d2fe1LsLO84hF5+eC3/S1hYnvXmvT9cd/6xCb/59ouN5Ybsj88vP3L9ZOL7z8LHJfzt7S+Of3x/uUWkfz/k4GJ9zPyXm4Hl98+Pf/4zvXkpwqsrLPzrkwDbD97ProIyFwV+c9988Yjzm7IcZ5milSiv1H8edgZ2jj9/f//4zcXIzMj278dP5m+sDJysrOx/Wf7wcrGx/WV/8eTd2TvnmT6wv7z7TVHw1yHBH++5f4swcL1+/UZSWNyLV45P7v8fBi6GbzduX3p78NQ17o8Mf/4zs/yT+MPFwPj86T/u3yyfuX/yfGH89uWvODPTOw6G759/8bKyMH74+4Pl77dPHKw/vzKzs/36yMDEx/QP1HQSNWAxERdiYWN58/07y6ufDxlvMMoIsbz7+4fjF9Nrtr//mXn+s35ges3PyP+elVNYlkOKhe/Fp4e/vn3+L6H47dEdFhZJxk9/eH6zMTJzMTD8YPrH+ZnhI8sH1i+s3Bwv/zB8E/rBfv8vAwvHR+Ff3Gw/vt1iFRb7/+szAwfvZ57PMm94mST+PeBjZXzC8Y9VlPXHp18M/9hY+X79+s7wj4XpL/sP7nf8jKpfGV/y/vj1Q4yb8R0zI8tHpt//Wf79ZeFk/Pz5lbCYNKshI/tPrjf3n/D8ZPvx582F5+xsfK+15BQ1+D9zvWJ/9I+PTZn7O9dvdhG2L2+/CIsJf3v98bfEz39cOpxCzN9uvbot9lTm9b+vPwS+3HwqJaF09/1reQGhb88Z3or+YvrIwcb05/Wrn+x8X5mVOATYeN5wved4zPuP5RsnoyQ3/3s+Pu4P3zh5+X4JcbAw/mX+KcjL9e4TD5coY3xxuBSbNLsCJ+975j8Mv1k4eT6/+cYvwSzyi/31H+ZLz8+xckqLgidweBlZnrJ/ev2B5d33ywIiinxMv7l5JF/eusKsrinDKMTFznDoyy1RfrG/V54pKMi/YfrH9vfPe8b3v/790GaQuvP3GROH2I8PH4U5uN8/fPpNglv8D8dzVgbrj9wc8pLbPl7mfvBRzEiP+cXDmz+Y2H7+FBCQ+8Pw4PsXfikO9r9vP7yX5pDhZbj+ge3T95fMr9j+czD8EvnEf4vj+/cP//5J/ZR69O/TP55vkmxqHJ8+PmR4z8vOwfXj2w822X8s77k4ZJlZHv7+LSn098sfJekf39n/GPFYXXh3n42H2VvJRJRb8CcTB/PfX0zc/5j/8/76/4XpBwcbE+NHhk9sfzkYORn5WZgfv33+6s2f2SfPc1y5/vM7+/dfIr/+PhGXEf7z/utXhu//v3AzSDCwivwX45L99Y3rr/S79/tvffvDyMbOx8jy+u8/Ts6/rD+Z2UCrxn6/+PZHhIHlyX8WPubvv/9+YWNg///n10eGP19ZeIX+fWX+y87G9OHVH36mP1+4RQT+Gdnosv5he/mBgUuM6d+X93++MQlw8XwQ+i346tdbjv8MbL//fmdjef/9twIP073v/3h4WRnff/3PwMrBz/nhOwOLwDemDyw/3/3/rcbEevkfjxILPyfri2vPObl5GUT//f/OxcD8Xfg/46d/zO8Z//P+ZmFh/P2BjVuc58fPt2xv/v0UEGD5/vnl/3evr3/9/uMtM7MIE+MfBsY/DN85/gu9ZvzOy8jIyfj/3y/Ob+zvGf4J8TCz///z5wPzB57/XKwsv37/55aRYnn6TpHvJ8dnttviv/7dZv0h9/XXpz86340NTc1+MjBKcl28d4eBiYvlr/Dzv88+ff3Lx8324vxb4d/ffsuLCYhwcPx4J8TH/fAfH+PFn+8Zr3B81voj/ISLkUvun+wzhi8v/nz9//Hj7ydsvyQZxWUEvrN//fHnC/Nb7n+83yTYdN4oXWZ4Ki7wX5j1+2dFLsGP4ncV2CweP3389ftTpk/MrCL/frH8F3vF+/HN52ev//38yPv69rs7V7g/nb15QUBRUZTzP5uIKIcI508uhjevnn/jfsP+SVOah+evIP/7h0xq4gq/mb+w/uC4xPhGnYGV+wcDuxLn42cfeP59/fvhCy8ntzK/xrlPn5lesX3981OWk+nPZ45f8jx/37M8+f2TnYvlE9f3k/8vsX38f4/3zd1vj3WE9IQ5WBUUxd58uvbrJSej4LcnXx++UOH//ubbz2+/1Ll4eT7x/RL/zsjNYPhP9SvPj7c8bH+YP7Ex8jKzSTCL/fjDwPZfkF+MQ5JZ5Dcz1x8OPp6vH/5+/cn4/v+3r9/vcIoxi3GoCrJJnfv3XENAzlVMl4ON6xdopeCvP38Y2Bh5mX7++fvlN+PvXx9/fGX7x8opwMbN8O/xg3f9Z07NW3NQ4M5zrt/8PPySopIfRBQUef4wfPnDysUgwCj9h/MFw5/bvDcvXnx+996Twy9//fzBxszK/O3H/z+iTL8YPv74/efvV5YvX7/+4mX//vkvC2gtFjPr/79c/3/8/wca7WDgZ2Rg/vv/BfPfX784v/3/J8grLaYmL/yXm+O9zL//sr/+PfvIyiYKmhL9+oKVgfkdDxfbj39/v/NwvPv/R4nj+5evLIy/Ob/++CnDKfibh5Pz1/ffTL84X/39ycbLrcos+o6RR5vp8yeGrz9+8YmLf+Bh/vGLA7RigJ/zHZPAVzZBJaE/DAxsH1i4BDl+v3nLw8b/5z//d47PP9m5FOQ1FKSluERl/v15w/DnP9PfbywMDKz/Rf+zfPvz6zcrIwMrizAbzy/G79+ZP/1m/SX1V/43M/uPn1JfGX6+us/09fuDT+znBX5w3fn7mYfp33+Wv3+4LrJcOfzulyj3XfZnYkoq/7h+/+H9JsgsJPCHienCp79i/5gVWSXEZLn5mN7LSb+59/X/G+Y/nN/42GR/srxj5uQT/sP5lufFr89vhL8y8H5n/cH+jxG0t/vb358szPzcXCI/uFSFPzE/FripxKj/VluQ04SH8ZcY65+7LJzffpmZyzMqqTJpyip/EuN/9PzGt2cfn4oK/fz9lYNDjJ1Z6NHR+2wygozf3z97d+feuw+Pn99m4PgrJK335/1HOf3/rAzMHz78v6lwj/WflCYDL/OHx1I/+b4+YeT8/pnnGZe8pCAPAy8z+3cBlr8Sr75/Zvrw5wuL8B+2dyzcT5ivKDMJaSjKMPH+5/3469rff18fMPFLCPmI28r8Y1n18ZKcsPjtN0+FePlfcn1j4RFW55YV/P9RmU30+q9fp5/cEhJmEXvHysT98cnD39xiHPxvmf6wfWRh4lNX5WRi4+b+8JyVjeezxOv/H1jZ2b4xfWWWkWfjeMbNKSjIISym/Iub4eebZ/9+mbGxKgrz8QsKcbByMbKwsLGADg9g+f/vJ8t3pv/sX3+DVq7wc3N8+/9ww7trs5ae4j76QvT/15/svz//Yf7N8vIfCwPzv9dP/nznYHrx9e+P/x9+fxf691/oF8ePX6zff3L9+fmH+w0Tp8wvgW//////ycjFyPua5S/DD85vnP8/fuPkYXj7/z/T79/v/jH+fs/y+8NfdtAs1e+fXxkZhP59/PKbQVhMnkNXhYeVT/Eb8++/115xvuX8Iv3z358vf9kZ/rLy/fr9je3lx68CHGx/WP6yfPv78b/4X9lPYix/fzMJ3GL4Lc/G/IOdgf8v208eBqbPb8TvsL1jZ2B5xcYv8uvTi++MDB/5mTj+sPxmYH8l8IHpy4+3sj+/333JwcL4lvcPw5f/n//w/vjy8Q8nI5MQF8+nN+/ffeDj+ymkw83JJvfvD+s/To5/HH/+gRZXsjIw/f/54yfDj78/fgn95fj+m4X9/8/voPbOLz7Q1Ar7R/bPvBx/uf6xMDB9FGAQ+vVL6ON/QRYGBpbfTx7vfXBX8ovU1T8fP39iffvt/TuePx+FP78TYmX7ziUqImklIWauqe3La/Wak+XXo08/v//7/ZaV8/8f0a9czFz/3zIKyQhwSUpxCfHx8fGzC3zjYJb6wsP4k/2fEPMv4X//WP7y/eZS+i39Tf0F76s7TKw8335+E+J/+uXp4+sveP9+ZxL4wfT9P4MCD4+osKTWFwbRP3+ZP/74++6PqoEW89dPHOxsQizakh+eqsgZfWb/x8rwUfQXB89/jqdsf9U+ctm84Xnw4/UDDtYvUj9v/n/3TfivCIvAXybm3z/e//z2SkZInOWTwGdhRik+blVZof9fPvP95uFkUvjHzvv872P5v0wf//+X/sclzi7I/erj6w9vWO9/Uv7B9e/Xd753/7+zCfDysDKeefPqM4PUf+mvMl91mVjZGZif3/30jfPnlzPcj5kv/7vP/VnzO9sn7m88n18x/2Lh5mESEuRm/sfC+vvXdy5mUe73r368fMvOyvSJl+cf893/7CI/X/7jtWYXVuCUF+AR+v+fjYGbg4eNlZnl/+/vf758+/brK8M/ZkZ2IW4eVtYn795ffP36zuYXf7/c+/vv3Zd/HL9ZWb6BNshws/7l/PCd6feP91//czEwMv5hYP375hXDz4/MDEy/BTn+svxk+SPz5++bvx/+Mfz+xfzzzb8v/D/+cDH/+PabmZv575v/jFzsoCBkYBTmY2EALW1h/Mb3j5mFhYPzFwe3pIyYirYCCy//F7bvvx/8/MvKxsj7m+sR+/s/L4SFeJn/MfO9ZPimxM35kuE30xs2cUkO1p///n3l+877Q/jHaxkmptu/Pr39zMnC9Z3lC9cPVt6X0ozsDN+ZmBi+fWdgYGD7zCbMz8IgxynE8V/whejH/99573B9EWJh/8LFxsLwh+83J+OP94wf2Lm+cD/58lGIif3dhw9CnHy/PwmL/eURZGT4z8bIyvD38y+W/zz/+H8xcDD/Zfjxn/kjO4vo36+f/3D+YH75+/uX179YWVk5pP7++vvr56+vnK+YWX/9f8318+dPxu9cf5m+sv8VfHqW4dSNh/o/hLl5+XnecTL/eGrILvdH5C/jb6aPbIy7uW5xfWD/yfDy97d/Xz89+fLtwzuBz8x/WJ8xff/1V8jg48/nLFzvP319L/iDXYWbQfS3wE+Gv/xif76//y7w/eeDv5yMIp8Fvks8/Sf+RViYi1vw3zfZf4I8cqxsIvwsHGxMrz49+fnhHcO/f/8Yf//gZGb89Ocbw6v73z69f3GPRZTty5/ff/g/CkhqfH/7lP+XGBs7r5SADje7vMTnn9/43t7h5vn49R7D19eS7OoSTIwcHz/9+cD+ifnu/V8sPGxib59/5mBg+Pn6Dy+LwG8enl9vfr9l+8z2/yfnr0/2DBoC/PI/n99hZWVi4HwtL67NJPGPUUzpKvejZ59/8LEJ/Gb59PX5r0+SDG84nj14/5P36R92YV4RYbEvIn/+XP7NLskg+prvvxyDDIPUb95/vL8/8f/6x/KB4eOT3z8f/v7zkE9C/Mfff2yCLCzcP5/8ZGH6xczNK8/ySUhUQ1ROmpufR1CWjV+EX5CTn4HhLyMD05//vxh/Mf5m+MfOxMTyj5P5+/ev/xbc2XX5xqMPT5/9+//zE5PY148f//z+yMb64++/r++/PGV8x87Iys7GwPD/33+GH19/cjP+/872i5/x78fv/0GmMP7+8IaRm/X3/5/MLIx/WZn+/f7MyCnzl+09018OJl6W/79+gkZ8Pv1h+Cf05xsvA8tH5k/83z+9ZxfmMZTh+/eL8RvDS/Y/jIx/PwkLi/759usvyw+Bv/Kvnn35JP3nG4Mo87sfLBysXF9Z/v74KC8u9OfvL1aG3///MPA+YXwr8p5Tmp3h2382pl//xESZ+Fh//fvM+J/xD98fDl7x/9y/Pvz68f3hx6/fv3/lfybIKP2Tg5njH2jPN+8vVgb2X594PvG/lPvDx/79EzeHgCCHoCLvB3aWD5KCfIJ/mJhZ/rJ8//efkffXX6a/HB/Y/vzj+v/rFcsf5p9fXzMyMDP+4vzN+oNBgPn/m5+/vj1kY+P+94uB7emnXy8Y/gh+ZXzx5x/b5//crAwMr/8/f/7g/au7r89+FHovJsn/hRvUlhP6K8gs+kv03w+uT7/OX7m9d/+5n19Yvn7nZPj/h+0Vw1cuTkaGn3eefbv499kLho8/mH/+ZPvP/PfnHwauP3/5Pv14+Yvtz1/mL2y8XPICrJx//j198urv429//34/9u3l77/f5PlUOf9/ucTxmImVgfu3OPu7T2/+fvvM9pv5rywnyxtebqZvXCIy7J+4hN4z8PFwvfj7nptD9MOri58eMbNyfWD49Jr7rxArF7s8D/8vzn//mYT/MvwS/MPBLiHOzPldX8TCiI//B/Nn9l+MZ36//Mv8i/fLp2+fH/BJMn56cFeWX+He6/snn3+9/ebme0XBz19fsXNKPPlylYeZ7/+3x6JfZFmE2XgVhARvfJKVYBB//4eZX4Tr5+sXUtxvv/5m+sfEz8r0VYqBkes/kzifAPffvxwcQtLcYvyq71mYnz57+f7d+69iH7h+MD9mefD3qSDTf6YvSjy8DBxmwuIcosI238XVBQSFJNT/sPzn5GZjZ2T8w8r688u3nz9+cf9nY2Hn4uNgZ2Nm+veTedatSx/3P3y8791/Zv7PP9hZGf59Z//K+pnxLyPzF4avv36y//n9ivHHj+8Mn//8+/9L9Dfbd97vrG+Zv4owcXz98fnHL45fjIw//339x/Dn+09WZtZP/5lZ//7+8OX/F5Z/rD/+f/vG8Ov7/y9vfv/6wcTxg5n1M+Ofn9/Z3wjy8mhriDJJCf/68v7fD4FvbD9EmMV/fGcT+vvvvzrPv69fmL59EfjP/UPgJct/9j8sH36wcbH85HvykPPvj28Mf36w/uX8xcks9I6L+dlvRlbWPxx8bO+e/Xr+/Tvjd75/Ij8+f2H68ZfpF5fgH4E/f0GtbqY3bIwsHxm4vvz6wPb76xPm/3yM33jVuRS/iTK9/fGej4nxz33G3//+/eZ7zizK+OMr489fjD9kPrN9ZmD4yvfr92c2cSY+lr/s/xS+Mf5l/Mf27zfnP5ZPTF8E/v/8z/z/F+t3oR/f3/zmeP2TS/Y3LxfrK4H//LzcH5j+/mP+81+E7T/r/xuMX9/yC/xkFxJkVeERe8z1TVFBnOcLlziTyLs3LGfe3Hvx7dPPX2/Y/7P++8H/7y/D7++/P736+Yv9/acvXMy3P7GwiTCIMH5m+snwgfHnp19s3/j4335hZ5AVVWAQ+Suifl+a7a/kC+ZHD66+/POLRVKG7/Wf11tePRM9xc/05TcD21tuURaBOzw/X7x49OrZf251VgEGhv8M/8QE+dkFBBk//v3y7t8z7p+cbLJPWd9d+vngFcvP9/xsYl94hL9905Z1lfz8+R0HA/O7T8K/eZ8Kfvz67h0Xm5jUG05eEX4tDvkHPx+KiUiwcSm+5eX+z8tx59nb9wwC97nuiHwQMhfXZmBifvzx5Z9fivee3f3/nU1YguP/py9vPv37IcIpyy8mpqGozyUvw8tn+IGf9zXX57+fefkYJaVk/jH/+sn4887Tpxy/PvwQ5WR/y/Tz3m92wd+SClLcTHysKmwczyUYBX58Z/4q8ZmbW5VbkEdG9z+HhIg4O58AIx8HMx8H07dfvxlYPr358PM/IxMD838eBkbWH58+/Pr65dvfr7/evfzE+0HoP/svhn9ffou+//Duy+/fjN9+s/348erfr1+/3n/6zcn27xvj7z+cTH8//f4KntN5w/Rd6QPDi49/eZgZ3nz/x8T3i5mJhZHj/x/O3yx//v/+y8DN8ufvfyZ23v+MjP9YODm4lf4zcTCy/2X5KfiDmZNfTFFDW5ybhf05w9dfjOycvAwCvNwfWX9/+vnky29Ohs8//wlwMLFz/njwlf0r77/Pn5hUeVkZuX/xf/r948M3GYa/XCw/OF9zfP31RYkTdNIA82+m3ww/Gdi+CLzlYRRmZP7GycrHwMTM+PnZ65+/GYT//v/Byfyf5ScPI/sftn+cLOw8oj9/vf/N/+v7r78Ccsx8n7i/f3vFzP+D8fv7vywKLC/eMvF/Z/r3l+0BAyPTD05xBm5Wpj+cHH+4X/0T/8DMyvn3P/s/vh9M//7//vub7S/zL2EWpj//f0tzM37++1eAnfXX4z/sv5le/n4L2mT14z/z5z8/Pv35wnbvxfN/zxjfMfzk+sAq/or7xccPnz/+OfPy6Y8bb/98/cf8+i/Ld64/Yu9+Mv/8/Pffr0/fWRm5eT99luCT/a3K9p/tAwu/IIswLzsnA5cALzMjyx95MQ7BH8zveF5z/X4j9Omv1Ndv7MxsIsJ6krJ8AsIXXj78+OkLp9h3Js6/f+/9O3/4wVPW94y/Obm5xVjv/vnFJyjA8+/751cf3/189/nzJzbRzwIP3rJxM4mz/xf5xHjvxevvTz5ycPKxi0hwfX0nwif95uOjuyxMz27clPgjx8LA+PL341//frMysvz9/UX6j+DXr/85vj4zZJLTkdNifHuLn+O/3kcWHhn2r49e8TKxKEpJirA8k5TXllaSZv396+uv78xv3/3gFnn///fftz8Yfr1mExb6zP2BT4BR7MOXz59YGLgZzVS1/ov9k+eT+/+Lg+/n1wf8XxkFeUQZ5fmk/olw8fz9wSIoLSokwiLLI8bEwfb733cWPiYVbg1GAT4GLkZO9j98/1m//fz58+tnJmZWFmZmZh52Jsa/n99/n3x547ZjO15cu8Hy8ttnzp/fPjB/efWB+QMLEzsDC8P/b18////CzfDt1z9u7v8/vnz98fk/84/fHxiYv/37+ffdT+Evfy8z/OTiZf74lZmB+c8vHiYWxn//OBhYPrP+/v+LlfEv00tWRtZfXxj+M4JO7fjN9IXpJ/vvj/+Yefi4eXnVRX4KC8n+VmLjfPSVl4n179Ovvz//4mb8xflN+hP7r///f7L8//1V/Dcb1/8/v3/952H5fe3LX9BqFUZeSTahj2J/fvPwfedjkGHjfczwm5n93c/vv998/MHyR/CDMiPTt6//Gdh+/frAzPT/Fxcv219Ozj+fRH99Y33L9pLxJ/NfVu4fP/9wMfCw/7/P8vXjy/+P33P9//ePR/IP/28WJkGuX1/+iUpy/mDjZmdmFpVi5eH5pviWjYH7+3vGn98lmRgFWHmYmBn+/P37nY1JnIHnzTcmAeZ3HP/+/GR/xc4gwC3D/ltUR4aVmeknHwvz519M3wV/s3xhZZD4y/qS4YnAk6dvJf6JfOdneST87vXzFz8Zvvx/8/k/LzPXb9G/Qmx//jD//cjA8JWBhZnhP/ef7/9+sYpKcv77Jvr3LxuXFPtDZgb595xa4qzcP9kZX/7hYpFm5hBkZlL4zPLlEwsz0ztxVi1BE8avPB+fsjz5wvhHmlOEQ1CciZHvhwivxk/Ol2+ZWWRZxF/cvib/i4eHUfgOw7Mn7xnuvL7/+Z+QCLPqOZEfP19/FP/HzicgbSivKiTMcOre7afPrn/hY/33/7Mgp6TYV6b7emy8H399luPm+fj/O+f///+5mX794BEU/fHrFxev4Mt717//fqmirMjP8u+eOMtTxh/ibPxswsKP395n4BPkfvmeif3/77c//zNxszJ+Ff7J+p/hJ4sQ07X3v+99e/78y+9XL978UBDVFuNm/ffzDyurLDvPfwHmP8xcDF/+c3z6zcnA9J/3LSsbA9Md/q9CXxQluF4zfXzD+/Xtp7fGDEoSz9+/ZGflY+MQ4RXk+C/4nekbMwPzzx//f/7+ysnOzsPFyPL/84GTtz4d+XPl9I8tt25+efaS4SvDV+63vzm+fGPm+fv3LePv/6wCPN9ev2Rmkfr59csP3o+sv1n//WH6y8H259c7RhZ5lvf8bMwf//3/8U/w70/+/wxc35i/vvjDw8f8iekn61euH/+Zf3L8+fH1/49fjOwC7H+YGTh+M//98Yv/KxP7T2MdZU4tja/cPxhuM7Ez8bF8Z2T5y/31H8vLX3942BkYv31nfcnFxcTO8+z/189M/+R/Mv7mZBTgZvnCxszP/e31y7/fv/L/+/GHk4/1Ods76S/MvL+EfzAyMbKxMYq85b3D8Jfzj8i/X3/+cjMw/eVjYnz3i+Uzu+A3IeZf3L+VOFi/8TGzcbGLfP315j8jx+c/ghz/WHn/inNyCP1n/Pj/57/Xfz4Isf79/kWPTdBbgtH+I6+gAMd7vh/crFwfX7AI/v/F+YGP4zebGi87A8fPz29Y//Jx/mNmY3r7h+Mb65+/grIqvFJigp95BIV4WZk5/nExMjF/Zvv8n4mflY2Zk435t8R/5rt/HrB+eiHFDDqikP0dNxuXIN+P/1yin/j/MLKxvGFjFfrL/J6ZhZ3pBysTx9e/X98y8bN9/Mz5+uVXfmkGkadKX5ge/mBk5BOSF+cXlmJX4ZX88fLXuxcsL8TZ5UUNfmjyqn3n4jlw48nHSz9/CzDyMX9m+sTN9PfmFUUpXen/rB8+3ldUUP/8793Hv6/lWTU/yn7+x6vw/8PzH28eqPxiZZNXZmdiFJBQFPn3X5CfQ4hT8sbf7z9f3mdj4BP7wf+X+ZXGG5GvnL/4Hv9kY+Zn5RP5/OnB63+v+AVYeD5/f8Dy/6nAP553XDxcXEyc0uKMv4Vfs3By8Zxjfy/3TZWFiV/kM8uzf794hRnYPv/8Isn9Q+zns08vfzH+5+Ti/fuaA7TImEVChPnX36+8yr8Yn7x++O0XM/u/v3//ffj3Q/gHy29RAX4hZnmGJ38+CL2XYRbkfMsUKGjuzSb/85fkT87fb3n4b7M9Zub6zfj/79ffv/5+Z2RnYmZgY2Lh5P7789vD229vXfxw8+lboa/f2VkY7jx68+Pvu28MDFyv/nz/K/n/3ae/rCy/37z+9Y2Z5T/D1883mJlY2H6I/GVi+P/3H8O/rwz/WX7/eff/z4f/f2WY/jEyfeZhfMPG+unTN27eP9+v/GXkZvjH9f3//z9f/rCwc/1j+8X67dMPdr5/L759YWFilOK0UDOQ4GQXZ2D7+Z7jP8OXX7///fz1lVGQien7Nx7Of+9+fuTl5P3NxPv6+0dWWQE2QQa2pz9/CjH+evxeUI7z6+93f7+K/BL9/0eCj0X4/zeFj0L3eP5+Zf3F9+6LGNM/lo8Cn/g+8/xjuvL09z/u338+cbHxf1D59pn5179fH7lVmZlf/v7F8e7/l2dMP8R4dZh/MTCzfmf88eHjj5cMf76/Yv/O9vk72w+lT3+//uW9803gD4vwTxZRO15RCWnuvwxsfFLMn59y/uD+wyrOwMLILMn4m5uHQeg7A/s/xr98/9kY2fmkub8+eS328fMfVn5Ofll1Dua/3D84fzIy8X7/+Yzxt+jff1/vfPj95NzDn3+4X/JwiYkzC4pycHzjecXL/PHtnz8/GHi+SzAzcYjzSooLcwqKsbL/FFKREfrz7RUjI6vwJ47bD9++u3Px1zX179y/2XhYea58f3r/HsMz/jcf/8iKiCnLSTKwct76fPXnqy+sd/8yf2T58v7/r+//mb68/y+oIMf9k02ch/e7INvdpz+/sDF+/fKD69c3e2YZia+/WVj/sooJi/+X/P3tCROPAMvPT6/+PX/68zUfL6MYAxefmBALE8+NF0dYuTm4OEW+M/K9+f7onfivc892s3LzKXPI/3gn/pnxz/PbT8SE1e5/u/OfU+jNxy/s33mFpCS//vtg94mLXfzT8/eXnsiw33tyn/W/qrA8h8gT1m9Pf8n/lnn67SHLv3f/+L9+Y/v7WvD1gxffXr6+dVngP+OHL9++Mv3g4v3w+R3zp5eCf7lluNm4/n74wyumqyak9YVdUkZG6C+zqa5RWaixhJwSs4pApJwpG6vwr7+/mH8wfP/57f3XT8xMzGz/vr/58urkw1tb9xz/+P3hV84fP/98/fmJ4zfjRyY+0OmdLN9ffuZ4//8t+59fHH9e3//HKfyPgZfp5+/fb9/95+X6/+Yn639mhv88/39/Y2Hn/8v06C/rv9//vjP9/PeDnZn7l+T/T59+Mf5g52FiYGb4x/XtN8dXJobfv/7zs31/+IuNh0uZwyHE0sde96nO3yeX7v3//47x05e/Mr+/SjL/+8UioCDE8FX47//7DF//MYp94GBh/XLnAws/FwMDv/BvQQ4e2dd/PnF/YmOR/M3JwPr2/XOm+18Y3zP9FP/FIvLl3w8p0e/SnJx/Gf4zMwuy/OXkYWdkYvrz48/3jyJ3BBn+Mvxg5fz16icjIwczMxubqNq/z6/+XPvHK8PE8OsfgwDjP/4frIziv3/95RNjY7nx9/9PbmF+cTkB5p+s7F9eMrHwvvmjwc3y5z+DiPAfoVffvrHxff7A8I+Dle8zyyvRX2wPv7GzMH1m+c7+7C+bCO99Iea/jN85GDj+MUsKsjNxs/z/wsTw4y/T7ze/PjExveN48O7fgzPf3j99+/Xmyy88P9//+sLF+Pfnu2/vvzC++P31B+sX/v9fZNnZmKUFhaQEvrMxf/nOx/aR9fOnhxzfPqgw6girfXP/Z858/eVHhu8sDB/uPXj94/MfkQ//37x/duXHsx//hR59+vTrE4OIKTsXw+/HvG+YeAT5TrI+5xTmuMHwWIpT6KfcO0lG4U9/P3/4yPj29xsOIQYxbfn/7z9/5fz37et/QSbmj79fc7JLMb2X+sz7hv8/H9c7xm8CX1kZ+N4z/uRl/vbzz/efsnxsj39piRj++cL69MO3/Y9PvhVi02Zn/Hjrmbas4/cnj4XEWDj+/fr19+MnJq7Pvz7+/ccn81/xxfPbvGwCJ79e4frF/YXjHfuf31+4GTn45H+zMsgJ8//l+P+VjY3pE8dTOW7ZH/zMPHwCYhxfvjwUVZD6zM4hw8Xx558Qt8gvMW4OPmaxf5ycDD95RSWl3/NxysuqmcoqaXLJs/Nwf/v+4ePP77+/f2H+z8jKwfjrx/d3jz/uPvGC/eWHv78Y/r3l+v6X4QfjD1YGBvYPEt8+/f//i+HH1/+sn/9/+/IZNPnKxPnn7zeGv19+MvEyc3H9//nxPzfbN4ZvoPNmfnH8+vjzF6PQny9fmDg4/nD+YWL48+v3M0YeHaYfrL9+PWNk5mL6xcb4RZTxD9uf989/McowK4rH6EsGSxqycnM6/5L9KMj16wOfsIY801Munn+M/z/8+8vDwMDxne07F7MqG/N7DnY5Zl4Oib/PvnAyvPvA/4ad4e+/738/ibEwv2P9+eIbz2d+BhZWdk5G5g9/Pr//w8PG/uvL42d3Xn9l+MZ6/z8fvzAD4xc2DrFPzL8FVET4WEWZvz36/4njG9eHv+8ZGO6++cb49b8C5//b31lF+H4LsEq+Zf7y7etvBs5vbz/8Z/7CqMagLs994M4Hjqf8TOw/eCUkJSQ52JSFmFkYmJnEeZg/MesLsguwMjAJcfIx/mfhZ2b5w8DIyvjr158fjExf3/5lY/jD8uzfT4V/TEw8f/j/8H/+zcD3g+vTX2aGnz9ec71n4Pn3mus1z0dWRm7u7z/4//z7xCr2i/sv03NBfk6hPww/GNjuf2b49fmpOg/v7/9f//H+/M7AwMr6T/G3NJMAA8/jz8/fnGSREpQTkhZkVmES+SnAJ/2a/+lbQW7m3z+//WH49enPP9k/f14y/BZj4/jLy1g3qebP928Mf/8//PeI6wmHpCb/m5/c3z6/+svIwfP9zQdFKdlvvIwMrH9AB4kwcvz59/fvn4cffogLs35+y84uzinCyPCV5cfLV//eM30RExXm+PmH/xc7nxgLyz+e9y+/Hed5ovLt75f3/xi4xD+yvvv24aGOrCnrH4F/rA/YPjI+FPonff/fXTlOxYe8X6XeMTDzsX5/fePpR3Yu7k+SLEzPH/D91BLi+/fi7R8tdcELX29zfxSU+Mf8g5Pp60/Ge+yP5H5zMH/n/szyS4tb+/P/bzyfP14T+qEipqjJLCglKMXGyy4sycPNwc7CwvP+49tvn78z/WMGTa8z/PrFwSnC+PPp0x9d6zYK/GblE+R+xvWV6fG33x/Yfgi9/vvsHwPfH4YfvO+//+X4+vvH7w+/WRmZhL5yfudlNeBkZmL7/e7zd46fvP/5GPiY2T/9Yvr/48t9lm/fP7D84/jzg+EXAwMHI/M/Vkau7/+/CP9l/ivI/PHTHyFRlg9vGFk+/PjG9peNS1ZbOs5Lh49d6i87zz+Gj6yMPP/u37nIzvTp+P0vkuzfWb99Z/stdV3wndbn3/d+cvwXZGL4yCIu9uPvqz/f2Dn+MTDwMf/5+ovhDw/b/6+/GPkFOb6/+8jGJf7/Fzcj47WP/6R4v767zysq+/sP//NP16UYJf9z/vn7l5HzD+unLy/52QQ+8v5mf/PrN2gDy89vzMzsP//9keAALRF6/4NL8h/bf8EfP398ffuYiVWC4dtnJgfJYDGZF/9PbLnK9vXGG25xbj1dwbf//rz99uvTiZc/vvz7K8b8XeQT+2cegZ/MH5Xf8d9W/vDl9bdHXAx/H/HxaXDx3maS1GD5/OHPa57noo+Efgv+e//76/t/vxheMzPws0hxSP5jZhThYGDk+/L3K9OP7xwMPz78ZPn/hZmZ5Te7jhDPvec//4i+/vmdnfWv7H+WD2J/2D9wPuN/LfxOlEdIkIeJge3/h0+MPH8E/rOx/xAQ51LgV3ny4RSvhMb7/2x/X9+//+Dfj7vvWFQF2Bm/sDPzfZD+xvLjzTtGGf7/79+I/+Zm0hd/+eQVlzBoxv35q7tSUrKC3/7yM/z79+bzPZb/EkysrMygoxlERPg/fn/yhP07w4/fyuKa579d42H+Jffp+5Pfn5VkBTm4GJnufvmtKPFX8JPSf3YJPv5/7H++/v72k42D9bv4z5cf/6qwiH8RZxRilXr35pnkzz+fvhxnuib0VU2R6fUXjt+/BFk5mditWWV/8wt+4fh59sMjdi7u+8/+/Rfm+s75/gUTy/uXnFwSLJIvxLiEPwmA9gWwSLF9/szz/fJPVhEeZq0/TMJcPP94vgnxirMyMv78yfjz88ff3/+xM3F8+vONjYnpHzsPC/d3xt8sZ+4+4nr8+R8727v//znfffv8keU3y4c/z78zMDL8ZmH/9ukZAxP33/+/+CTY/koy8AkJyWipaX1l5uFXOnf73BumT8wcgt8YvynpSoo9+PNI/sOrf5Lvrt368ZWH9c2///w//n/g+cj5if0L18+/X3gEmH69fcPAxsT4m/07L58Em0i+m85/QeV3nz+/vfeUg/G3iAQ7j7yKwZ9vc+VvKDz6z8glwvbz0U8eZp6PvP/+c/xmYGAQEP/55SvPz+8/2ZT+/3/Iysr66+sfHlbmT6xMzL9ufPknw8L95/O316zf+Vj5OFm+M/3Sk7bk1HnN+9/sKc/Ftw++fvnJ84H7Hy8rGw8PE6vgn883+Phk/7P8/vb+P7uAGNPnFywfvv748o9N9t+/zyxvvjxiluPm/in2g4lBSkLUiVdOUEz608cXPsZsKz68YPr868LhHzLKv74wf/3KIcjF/een4m+RW9Jf/n38wvuf84vsX9bf3z+wMLG++cci9uXfNwEWHfb3vz/95v/G8k7wjSyfwM8PEr/42EU+PvrHJPVX+C/3JxGO/29+MIu///Pyz4//rPx8fIxC//98+8Tx6y/Lrd8MvEK/frMIs377/PT/NVYukX/MoNNfPr0TFxZVFef6wvj7Kz/Xt2/fJT7wff/18p+E+Ldnr36JqAj8Z7jI+ECMTeT7t2cM0uw8/768+cct8v0T9zcZpp9c355+//SflVGcV5XrN7v4Xw6O129+P3gsJiP79/1P9j//3v158ZWPWU6Y9Yc06/3v936I/Pz9+sPnN+x8z7795P73/8UrHSZZic8C/Bo6QkK/2Jk4/zz68ERJ8uu/b78fffn7+dPn1+//sPJxMwvKfWWTE5XhYP71++HD17+e3vt96/aPt+wsbMJvGcVZFYW/Md1/dofts6SQIL+WoODj/zf/iHJy/mKQF1b8wvnyN+Pnb6AjL1lffHnNJPBZipfTU0XDmM9KiUNQW1Dgzx+eLz8YDeREzH7IiInI8AmKiXILsfAw/vrF+PPT928/fvxg/MXw5w8PEyMD019eTmYpYWHm339uvXnPxs/4m5P717/vnz9+/8z87s/vz9+//mL4xfjjyWuuPyy8XP+Fuf6zSTHyKjD9lhR5d//FJV6myx/vf/7MwS0k/OsR23vGz/+Y/p6W+qsiKvuTj5FRS1LVXEpK/g/HPxFmkY/cXGwsLP9Z2di+fH7Hwfzjzz/uL39ZWPSZcrz0fvEKv/n75cf7zyxMLGwcX27fe/vl/TuG36xe0hKvWZkFuX8x/Bf+8/3zF46P31h+sbAz8nx5+5+b+cdv4R/vX7L8E/ry5BcbN8PvX1/42QWYv4qy/uD8IP+J970UOwvXnz8M/768Enwq/fPlmxs/7vzl4/308+ezW5w/BH/9Z/z25zPnT45Xwv+U/3CzcPz8zyD1+/+XZ98kOb8y/xXhZv39jeHPt+88f3n+/Gdk4WLhYvn59cOzOW8e3Tp/WorTUpiNy1NJ6cc/TqY3/97c+835gp1L5SOvJKPgfx4BRW5hTZHffNy/7n3++PkTh/hfdlCh94uN7fcfhud//vz7/OMBy29GNtZPP9hZWP/xSggLS8r8/fqR6d2Pr99fvv72/Rnz+x9ssgxMAj+f/Xr36wEjw/e/H38yfWL5+J+PVfjP798sbOLiggzsv7g4/nNJfrMxs/6l8/0Nx693TD++3f3MxMUoJ83NJcatIsDzSPrPI4ZPR55c//fmy+1Hj0WZuZk5/zNIMnOwML4R4Px/j5mJ8cfXv08evX70+/nze2/f3GPkEn4my39XgPHmswsfePh4GQSkfsszcDML/BZ49fa+FLc4318ublAR+fW/Br8Ft9gXgT8fvz78wsPD+Oo573eGN0xff3Cy8X3n+PP8AY8Uj5SQLvNvFj5OgX+//34T52B+90mUT5SDn52PWZSFXYJbiOfFk6/3pD7//Pb51c83nMIqj9ifcN37c/Xm/dd/OG5fP8/Nziv957v0O9VPP//J/uKQ5eLR5FYUFJHWfPjrzodf9x+cZ+Dh/PLvy6mvT9jYxSW/snIICTPy8P5nZWDj5P3968f3Tz++/v7H+OcfB2jWheEvA+s/ZiZ2Nu4/jAysvxi/vP7zjfPXn//Mf36wfhb8+vPxh99vmb5xMP/+/JPh7/9vSv+ExLh5XGS41XhlnwoLvf359+sn1nff/zN+ZVRgf8P0WEiNS5Gb/QfbIw0BuZ+/fohys2izc334xfyF7c/vv7/YfnAzfmP694eP4d8vPg7hrwwM/38zcjrxN2gbsqvKfPnByvKVlfE3s5AEJ8t/ATlJvrd/vn3//lVG2DTAWOvex2/CQszs4r9YHoj+ZvvwT5Lh23d29j8fmUS52PgYPv95ySbzh/E3FysHz7dfX/k4GL8K/hB6zPlR9Cfjh19M8lxvOH/+uv9w28tXn5++v/Lq2tMbP5nYPgp+52LkZWL+/4+JUewvw3uG319//fn5/5/If5Y/zMxsf9j+fGHg+MX0i5nh/w+xXzxv2SWY2Tg4mO/8YHyz8868E+deP37B9YfBXM+T0Yzxl+i396++Mr9lFeERVRWVZP/A8Ybzqfg/DkHBP/+ef///i+H/o58M8gx/BZkYOH+yMwl9+PmTlYWTlYPjLxsDy29uHhamLyIfxQVkJYV5WFh//njz7x8j/8d3r1necUp+5GRm5WJi+PyV4wuz4B9mLvGfDH/+83IzsjKxcP2UlRUUkBc2lleU5hfQ+y3H/5uXk4nzscCPd39Zf7F91lLX/cTI9OLzM643X1hZxYVeSfz895lbikOGieH3H84PIj9F3/z+y/ufRVbUQJjp2Td2sdss18T+cHz7/e3Ls5eCP0W5/0ozCzK8+vTxJ5sw+5vXH4T5pT/y/BLi+fn///uP/39wsfM8Y+djZXzI8evGkw9Kavy/PnHw/pf49/nJDw7G7+8ufhcXY/72guH285syTBb3b3xS4Ll/75KytM6f76xCf0T+/PnD/u83z9PvSvyyj19+Yv7P+ZbtJ/M3JplfXCdFHgl+F1f4wMDAJnHz4607975xveV9z/NO+C/LNamPHK/4fPlFeUSlbv+5Lsct9eDu5a+sbP/4WKR4hQRFuBh4fvLx8HKxsv5mZv754xcHw1/Gf38YWTj/MP1lY2BkZGEQYhX59PcbJxPz3+/f/n7/8Os1F8vvJ195mNif/f/BzvD972uu78JfRb4KsvALagq+Zviq/OPbc3a+B1J/JNhY1RTN1Vi52IQZ/r/kZfgn/ldU5NtTVlY2nvsf7jwW4fn96w8Ps6AQ45N/7FLf/nH+FLn1789/rs8MTFz/fnxlZvr/W91AKthWQfgrz+1/P9j+MDF9ePmXiYvhy++/7Ex/3739ws3Czcj49ddHYW62AGOjvWdPMgvxiXC9+8gq9+XNK25xgZ8vGdmUv/399Zv9Ny/76/9fGL8wC3AIfPr/QpST79+vb+9YeTm+/ZBkZf74h5eF+78ktyjHB9FnYu8Yv/x+956RkfmbLh/jD1EWkefMX97+5uUV+sv84dfb/+9+/+flZHvyhkdF5u+bt6w/Wdg4eX8yvJcVEHj48fWjdw+YPkn++fya5a/I0r0nM2Ktbv46nKlgeoD58oW9n158+KZwR/K10i91WbnfjD8+/Pvy9yEXozgD26evf9TZGP6yMnB84mASecPwk/H3Wx4m4V+sHxl/i3GJfv/xi/X/+59P/zBzc3L/efP3H+vPP7/e/GWTePfyA8s/FkZGxp+ff3Kw8suqi/4U/c39h5/l53fBz8p/2b/JMP1g/vmX7Tv7xc/n3rNIs3359u7jWx5TER1BafYv/5+8u3qR7bs0g8IfgXdfPvH85/7N/orv5ev3Qtpq0p8/fvv68/cfBqE//5j+vvp0h++9GAez9k/pb184Hv76IvSNR0NXjF2K7f+/36BrKUB9e/YPP1k5RQV5mFlfP7jNIvSZQ4ZVlI+bk02Uh5lLho2F8f7b+w9unOV4yPVJiO0PIwMPjxQTqxS/saSYkBeD6mXQXU//pZik+N///MTO/ITp2dXfXz5+Y/jGwf2c5Z6UuIKsjLictBIbz+/3nP8N/6t+5Xj3+s0XUWH2T59Yf336+uLPPx7Rv+84WZR+idgpKMq8///u00dTMU1Ghp8PxRjeMf+34lAXEBHnEhPlkZAX5uNhZmL+9v0Lx2+OT/++MrFx/GP8zc3CxMbOwcrO9JfxNyszE8Of36/ZGH59/8nK9ffnt8+/P3/7+fPPNy4Gpr9Mv1k/8vzj+y726cntb9r/hfi/M/nzK6UJ6RuxcWmwSHN++f/3PssHhsffv3MwPX/OxMv/4/Ef1Q9KLp/lHT+IKDEJS6hocosyyul8YHnPzfaH5w8756+vn35z8IlZy0XaqrH9E77CwCrIwsDx8QMrjwAfxx8mZjaG37+ZufnEeXlYedjfff7zkV+El4fNTUPlHyfrp6//BT7+Zf4p/J7hAyu3JOOjf7y8vGxS7P+//fj/4/dPhs+fP3zj/fDr70cBLnHWnz+5mF7/4/rHxsDLziHGxfSR5Zvov++v//5iZGIQ+sPLysfJ8Z5NhPffPw5WIdb3gl//MH7nEeD585vhHy/Hr5eMv5n+MDFx/uD/LcMj8PD9k0cPXv99z/bt2xMWHlZGRoYvj95MOLhe65+hrICUu5KRjKo+K8u39y/vf3/+5/+rpxr8MqwcQgoqAgJcP3+p/mf4/4vlz182dQEu6T//3t9hY+H+/u8bIzcTjzTzzz9/uP5zfP7MxPD9F9ufzx9+/WT6+Z3pBwfDN/bPLC++/X3968V70AGb/zgef3ou+IjxD+NPGS5ePpYfthJC3Ox/H7OzX3r18M6nf4+e3r/+4+3vX18U/7IxPnpyh/cDL7eI62dpPu7/H75y/WZ5/u3fb34lZgbeH7+fPfsrJmnCL8erKvLy53um6zzPRb9y33h1+zsXKzc3p5qwCC/n31dX7vIwc/z9/Un8Nzfziz/8AhIiP/58ffDkPfsvXUVTGRZR8Z/i3wVZXr6++PDTbSExrk9/vz/nEZZ8yfad688fzr9CbLIffvx/9voUIwvbx1/vhSTk7r3+xsTG+4ePh+Xbjz9f2P8xfZFnZ38nycbwTuAB61v2/wxMX98qMIpzCHDx//mixyf+98mfTc/vvr/2guWbEIvKK/F/MkzP3zMzswj++v1dQPyZkMivNy8f/vsq/Y/bhldKTpCTX4BPRJhTkJ//z7//X37/YP7F9J/pBy8zz9/fDD9+/GXh5mRm/s/KyM7OwfmH+d+fD3+l3n7l4uD58ebt11+svz7zf2H+z/WZkYldjJOdhYONgf+jiqAIrya3KhP/n18ff39nYOQVlv/y+e3T/68Yuf/fYHnByvT/wefHj16/+/+F9fXnF6///uHiluXi5zDi0lYUEfmhz8JuIMDJwfbz3btvrIzGttqp6o5MEtwvOX7wf/3/5dmPX6y8jL+/MrDyMPz7+en5fyaJ/3/ff2f8/Y/n359vr9/94vvFwC0daGL95R/Tc673Epy/eD79+//3+S8u5s9//vz49Pk/rzAHJwfzezYGZcHfHIx//736wfpDkPf3fx7uj+wvxT9wf3x4m0NCkAN0dOVLZiYO5m8qf9gecTCxsfxh5eH4/+PdR/ZvkmyC/O+/P+f8wvpd4u/vz2++cv5nYmPn+fj1zcu3Nx4//fHlL8Pvf0xM7H///+fkYeDn/fn3Lt/Mu8duv7rGLCURZCHq5aQv8P3jh4vfD7568vXjB1cevRdi79glfnC9k2H9wcHNwsz889u/dyy/GHg/vPv75c8/tl8ibIzMf7+KPPv9mIXpK7vEP0NObhk2vp+Mv35x/GT4+Yn3iyIzsyADpwAXDwcD4y/298I/ZRn//3l3hfv/X7bPd19++vSPX4yNTUVAluvvf2kOIV5BbhZhsUc/P1+Q4Ppy9xXrr//HmT9dfH+P5dcX9j+8H1k/sv4RYRP//+87x8Mv11nlee14hQQMpJmY3vxlfM3Oxi/I/O/XP/b3zO9/v3rP9ODLix//2Z98e/GPh1FQRIL9HdOzb/eZWASEf3F9+vnptQTn6+cPnrz6yM3ML8Uk/+7ZP3FpPmtJcQ6WL0/eX+NhVXj7+Zrorz98X5h/sTE++/b/03+m//IsMgLsrP8Yb7y+yPzxn5ioxLMXz19/uPfl93N5LgHmr384RIQu/3vx6sOHL+LSd5/d//v3+48zn1+++MMo/VZOXPGnIvMfaV7Gtx+YXv15+eXufbaHH1kYVJgFlSS0hERE+RQV+bg5WDg5WP4w/v/3///fPxyMTD9//v/zl+nv/x88AjyMP/4zcTB9+/X3y7fnrx99zb89c86RG6++PPn0889P5i9/GV7//831n4tRSOAXi4AANw+XpSlrkJzwJ0VGZWEDXjauZ9/esL378/TXa9Z/Qle4PzMwsT/9/fbXPw5JAZZnP1+xS4v8YHr77MP1F3+/X39wSp1PyknAXkNYgJmd/bc4l6G+QYgsF6eiyKuXzN/vMvxj+8vByswlyfrlNytolT0jm5AI44c7P37/+fP74zsmNpZvb9+8ffLnB9tTVu4frhoq///zv/r+gp1d6N9XBiaGzxzvmNlZBH+Kfv378d/fv19Yf/9j/Mv+//s71r/ifwTF+DlZWd4wfmL9zS4qwsjAwPz/xx9WXuZ/HxmF/7H9E2b7IyDAx8LCxifEzP6T6f0/KT6eT//+sPBxP2T7zvGViZVPmvcf559/D999YX/P/vv//T+MTH++/2D6+4/h56/fguL8nz/d3P9k060XnG/vsn5nv8DA9EuK/zcTs/BbXs4rP1+8f8b/+R+bvIGA1n82PsbfP4TZnv7/+onpzyf5H7++/fvDyPr29SvOF38//vrL/0/7P4/2X3Z2WXFzgR8KQgJ/3vIzM37/xvbyx//fzNw//rF/5Rdj5JD9y/GWi+U1F8tZrtcP3z/7+fWfIJu5jqoQ30dDI9XvWgx8fKyC2tyaEop6/1h+SHCf//Lh/bsfPF8E3n9l5ODhF2dl+s3+5udXdnZObmMGMU02DTYDOQfB3yzMf3juy3/RZlf89Okpw+8fP7k5GbnfcfyV/vrylbmU8ee3Hx/xvVD4zsclIsHwlYmDU+Dt56v/P/PIKyr8/8r2V+jP7ZNvROT/C31nf/TnCz8fv9BXlhcvn4tIS//48OWLvBTPi0+8klyyT0EbQ5gZWT98+CfwV4BDjOHmvVfacuJ896UZmB7++sHx8vvTx+f+/5X8Kieo+vzw1Xef+H8zvWb7ysoqxPGL+b0ij+Sb+5ee/+DkkuH+/1P4uOAz3jsfHwvxm//+w8rAyi3BzMXHxcfJ9vP7t/9/mf79+MsCOqnr5y+Gv/wcHLy8QoyMfxn+MHz/8uvzl688H57VLzvI9vTm+R+fvv1jZfjz8y9o5+4PXk5OCRtpuW8cV16+fivL9I+X+R8/n9Q3jl//3//894ddiOH1p8//P3I8+3aP4SsjF7PgV5FPzP+4X/xj+ffv5/OP72R4xb8J8r378ZdXgOXH5y83mG5L8XB+sRJVfC4YbmTyXlD8J9NNzp+cXCLcjIxM/36xfL33hoNb6PuvD7ycPP94BAWYvv1k4Xj9/acYExOnqBjr/78vPvP/fHpdUVXNXYBj67N/kh+/fpcQfPPpJ4vAv7+vHrC+FWXh5fkk+5/xzkdmAUUmpq//v7/7/P0775+/rGL8TJ+4WVl+cPz+zcrOI8zP/OjPrz//7jJ/0f/N+IWB+fdvkb9/33GxvvnG8O3XOw5WVtbX/1h/sjJy8Ap//n2f8fztj19EvrP+/sXEocgAOu7y138R9u9f/jP9/vTpH4sI0/8Pxz43/r3K8OPf3zt/BdXF+Di+f/n88fRHfoWrt8wtDJ7/enWF9aegtMC3G/8+SrMz3fjEJPKQ7Tnfr68cr9i+fH/0nZvlo9A7MVkZnrtPbv/4yf2K65cej8gfkY9Pbv1gZvrB/EP095fPHDyCfzm4mH7+e6fym/UnK8ezv7+YPjOpyTE8ZvjC8uH/X7ETLM+4WQS1GRnv/X7x/5c46x8WoV//v3H+Zvv649fXP4zC/578ecnJxf77zl82ZpZXcp/V/ijz//72+YswD5Mek4gqp8Vnieu/n7NwsQlyqvxhfKYuYyTNy/yL4feHv3+f/3on+Ynr9983P5h4/vHxMDx6JsAtxvOZ4fSdh7zC/P8//zS2lBJhF/r69+tnTsYnN28zfhf4C7oR4jfzd9bvX1+zvv/96uuDl2L/fjBwMrAxcfB84WQWOvHvA/N/1rdPX70Tv/OdkeXruy+3JFgeCb/+zPDj8dmTr38xvn/+8tPHj7//M33hfP/9PtuTJ4/fSAtLcghpcUl/4nlg+YlbkVeKV4yTT0qGW51dSECcn4frP+hAUSY2RqavrH9Z///89fcfDzsbMyvb73/fmBhYvvz/8/nb739MPz/+Yfn1+a8gg/zf78K/v339xcrG+FeQm5uPX4RR6NffOxr/NRX0ZFXZBd6zMnLwfHn68SfL7ycvnjD+4nr08Nmvn5+Y+YSYPnO///3t+t8/79n+vud8KiWoIiEm+IPpO8ubP4Kcf389//vj7z8mDnEGcUkXTu0AT6/P4ryfvn/+9VHmLwcnKwfnn6+ffn16xyUh9PvPfzZe7r8MP3+9/8zE9pdXgEOYHXRP5a9/P3///iHCyvLzreR7rndcXOwBmoZPfrCx8nBx/Pz29fHHL4IcLIwsX/kZeB8x/xLh+vfuJgO/GOfnj6xC7D9/cDH+ZGIS+/r9148vbIzCjNyfPnz99/cTw2sRLtC5yEwMH/nY/vL8ZH//T4qdUYZF4Ac7Jys761dOf3XDn9/5rly69ennl39Pv/3m42Ni/M7A+POf1D+mryyMPz8z/mD4zf+V4ev3/z+EGG68/XPqC/ubfx8fv/sl+ZWNhZeZ9dG9j7/v3773hf0DI684L7cAk9Q7xh/cHAIcXLyKfEKMHGzvfv7/8vshz1fGz+JMzNd///jNoPDu9+cfzDKiPN/chMXE+bhY/ghysf7kFRAR4mXgZf37l/G3wNX3XIxssoq8lqLqRtIKcmIslz49vfTyHu/tr7pfBd+wfPzOwX7m3d0L/98yMXEosnLzsQqwMP9k//VD4su/nx9//f//lUuahefn+31/T1969/j7m7srPp9i+vL393XeT5pfmHne/Gf9/1WIRe7P5x9/xNnEJLl//rr9Soz90od3T/8+/vXi6+O31/9IcTN9/3+Z7bWShvTfZ7c/MDxjvP/5Oe/zjz94FL4zSOgpfOX89oj3zcO7n76LcDz+/P23jIAUi/LP21+ev/r++duft7+YHj4/K/aRF7TzieEz0+3vP/kZ/vz6Iv6PV45dyJxf/y8Lx/M3D5h/cjD94JHgZGD/xMf39Qu7PB//J0kvfi5pUa47XGyXf33n+fbNhF9ZXFZOiUNWVEDkP+Ofz39+/Pr598uXPyw//zOws7Fz8XCys7LzsDH/Zfz1++f3X1/ZGJiZ/rOx8DPx/GP8+pP9I+N1BqYfDH85f8t9Edbk/cvB/fLrTx8+KT6ZZ/Kv5N7+Y/hw/8PNX7f/MvPIqyiyMPwXFBLlFRThZHz/j+EbD8N/2Xs/eX5/57/DzMz4/fmn5x8Fef7//f3/3YevbB85mJR0f/Nq/pcVlBH/8vXbt3ef2D5/Yvv8hZOV5dXDd++/cbGKCfx7/46Z+T8zC8ufHwyMzP+ePOZk+sfMwi7w7+9fzj+cP5n+fHz/k4f117c3/xmYWfi4OD31lR8zvRCVFBTnFeT8xPJHmov93bdfX9+xf+Ng5GL6x/njOysL66+/f0XZuJl+f/vyR1KYh/sb681/L5l/Mvxh/vKb8fu3V78ZBP///8HE/OQT83suri/v/z4RZOBn/vTlF5M8HyML6z8Opld/vvz+/PGX4A/W778ZGX8y/v/G+YWP+d/P39wM/36wc32V+MLy9x83aDMK2z/e3zw//zxj/XNNjFWSiUOG74fU74/vf4GWov79+5r9NQcfv4AUz78/DD+ZP/1k/fDt/99/v5hZWf8z/Gd7/eHl5wcfvn5/8/MTM9fvV3ycrB+ZmE1kRdkE/nKw8XGIMkgISnBJCQh9/v+Gn///G+EPTD/fyrNIvGWV4xXV4jF4IflZ/Kv4LbaXLN+FuL5y/Wd6/ef+E35+kU8vvv3kesXAzvb7m/yn1+/+vvz75w/Lu89ffvOJ8TMInPl169H7z3p3RRgTknxYZERePvloZaPx6+mnH8IK3z4cl/qrx8T8k0nw94v37z98YldVEv/65ud59lfCj18yMYjIK0iycjGwfWf7/+HzXyHGNy9e/1AQ+XHtq5DUv7f/uV99PWMmYv7tM8OLv/dZOeVfvHgs+F/mEeMz4R/vOXnE2NhYfv368/LHGwFRpe/ffgh8//qZ8zfozIAvbz7e+XGLkeHP1e9//rOzcX9i5gKtwflmzuCprinGIPrq1VcpXo433358/smpycGpYKstxs7DzMnK9J/9589ff/78/vfrD/O//4xsbGyMDIwc3DzsLD///fjzm+U3w58/Hz//YGT69es5KyNXcdNi5g9vfvz495f5x18hATknBitBowufvhpISbD/fsbDqfXy0ZNPLK8Zv/HKyUg/vnydWUCAheevOBvP+2/MnLy/3j7/zMD/m/kdE7cSOy+D3DPmBwJv/n5mE+Nl/fD/tSCzqgDX+7eC3BKgw3kZ/v9h/ffp4Qt2ARFuhrff//Ex8v77/pON6x8Dw78fLLw8/z99f/nvv7ggz9/3z1n4RFl+ga5F+Mb878fzX6BZ1F/8TFzMvPzMrExcDC/f/RX6tW7fDRVW1tfMX5kZ2T9+/ML1488fBSHO36ysjN8ZGARYfnz6z/Pz8yteLu4vnCy8jAy/Gb4z3v/39uP1x0zSChIgIWYRSclzt+5+/s6sJMDxV+IHCyvnl1d//39hZFHk/vL16ecLPz9++c7ExMTI943pM+8f4e9sH3l/q35jec3K/OsP88+/f1l4/7H8ZmDgZmB6z/aX+x874/+fPxj+8Io48nP//MRwj/MvAzsbwzsxXTlBSZE9j6/9ffXyOwPT//vfeVkYvj5n/PH/C8NPVm42Dmkxnv9/GLj4fwuy8HELS35/cec9q9g77qfMv5nZfzMxCkoxMfz8/P83z7vvjCaSPNfeqphrMD758/jTly9sb/6/YxOX5P/K+1peSOvyh3ffub/wffr6nVfg18f/bH+/c/DyfHz59e3fD3/fsfP8/cOjxcH3mfmp0F+ONz+Zudi//n/H9EWEm4Hvj4C44I9Xv76L8t59s0eCXf2dFMv3v99YP/GJimpwi4rfeHTu4/vvKmyiojLKPyT/fvj4hOGP4Lffnz7zcHz7w/GH45/QX345TUXGF0ySnGzq/9SeMHzm52TV/6f29uudv3/Y7jHf4f796aegsJgAhyAHG5sI898/X4Xef1QWEfv47asQO7MSK+Ozh+8fveH+9ebl/z+/mKRe/PvG8v3rJ2ZRTlU+KdG/4j++vv31henR+/8Cv/nEDDnkDFUlxYQY2YS/f//94eMn1n+sv/79//n3/x8m5h///nxjYGBj/feH8f/n779///z17evX7wwM378/52AW+PX/1Z8v/39///ablZ+Ll5dHj09cWP02yyeJL28vvDn66qXUq3fXecRYGX4w/2X78PLhs398DNyMDJLMfO8/M/Kw/2RjZf324zPrH0FxZTnmX4wf34PaeQyCbJ9ePmN5/5dJj+/bjWOsIgr/uHh/ff/588fP3///MjNyMAj9ev1DiI2DneX/fz4mZsav35//Y/7x6v1/ZjYhVrY/9++zc4j8+PbtHyfnH4Y3nGxcAhL/fn1i4ef7z/Pn57sLT1+/uveRlY35/TcrRe17fz8wfmTk+8/Ly8v6RZCF4z0H24dfn9mZv7949Z2H9c1jAWER5p9/2Bi+f//Ey3H7+0eVf1xRNgapppomUlKCanIvPz4QYOH4/uW7gCA741dmhm/sHJ++cDMJ/vz4ivs3q5iSFKsG25e/X74//snE++XvV1aGP/85ngoysvziZFf4zyHzl/UTI/NfBp5v/78wMTKyg44H+AIaR2S4+u4d06dHgi+evnv06A3z/QdXrj56rvr3r9BvKa7/rP+Umf9ocLHJC7IpcjFxiH5h+srMziIszPafmfvNzz8Xnt5//p79l+gnERYJcVVxNl7pz5/vcHxj/vb52xfWP+JPf3DxCzy/+enpm7s/hH+xCIjyGfPwSDOL8Ald/ff439efEm++6gqoqjGzqHz5riQqJfaJ4f+7Z9y8LMx//whLcX349JCfiZ3jDusPLkEmLjaWn3+Z+H4LvvzDLiXM94md8dvr50pcap+Yf3359Zrp768Lj2++OXuS4fXV3z95jzFe/fbqNfPz34ocIkJ80myvPvzm/svwjVXwy1+O30wsz18yPHstqCzx6/vvFy/+P/v19+Ob168FPkl9E/nM+pHxv7AwvwQLE+/X93/f//zw4tkfVnZlFkmJK3dvS6gJ8rDxvL7+9sMH8c8/7jB84GBlZv39898vFi4xVlZDWR5dXqGvH/8/v/eDgfO7iRC3qrKEiaiJvLQ0HysvaE/8t7/MTMx///1i+v2fnYONh5udg5WFix10JvPXr19/ff/17du7v3//M//7ycUu8YcJNIz3n5Hx3z9ODomfLA58KiqMn9i/fXjx6crjP3dWfzt08uTZC4+uv7smIC7Izs7Ix8/4j+EbLwPrfxZGYSFm5u+Mvxj/KckpPv545d/P9+wf/rMyffz1mpv1O58I33/GP/zsz1+IC2jxff3AzvGXmZOJjZnhx4dffLJ8v1+w8v95+vjVt/8/mX98+PaPi1vq07uf/9kYmRkZOX+xK8j+ZfzBzcX/5/PXn18Z/375wMTA+Z2X88+n3z8ZmD4wc/J8ZWVh+PiJUVxO/o+PqtE3PuE3r27z/BL6x8389/fXXzyMDP9+s3Jwf//xTkLg/4e/X4UF+T/xsLMI/vNSVGIyVJSUFuXl+sYvyfPr30fW36qsPKzcnIzfvn9i4WD+/pX1k/CvfwJvmf6ycv3g4JP5bSllIqjBycDF+es9I/Mv9t8sL/+w/mL48+8X09N/DD9YfrMz/WP8/eEnOyPjN8ZPP798Y+CTYfj46e6rPz+uM4u8ZuYz5v7K++7JLYE3Dx99YvwsLi3MzMTE9ZPv5zfOb0yf/3FyCAu/Z+eXYvj2lomV688PxpdMX/99ZPwlz/DpDxsLD4vwH1ExEXbev3z/+f7JMLNp8guKMrN++v730Ytvr799FuLilmXhYP/7883Tl8yMCr/ePGLlZuKQkH7G9PHWvzc/mJiv/Hz2kOP9J3HuH3cYmZiZ/377oqhq/krg2y9OFuavj9i//P77/B/TV5F/7OcfsTGwcTALfHn/6/WTn7d+32N9+OfeP+lTH548/Pj7yR+Bt2wcMj9kudn+vP795+9/xgu/brAIi374+f6d0NM/P/584vr1hJ/r/x/WK7+uMf9i+i7+Q+EvMwc337NPjLcYfgp8F1H88kfp20+erz+fMfz+wswn9ovxtcA7tr+cyiqS795/vPjx9a0Hf179vQc6wZGV4RfLr79vedgUfoiLiohrqXKw8nDy/uRg5tZmYBZS1RRWVFCWFGQT4fvy4+9/RgZ2dsb//3/9ZvjLzMzMzcTwk5GFmZP15y+Gr19+//r1i5GJiYmZ/f+//6CVc/+/MjBwfP7AwMbNJCvHL6TEI8L6nUNA5v+zr2/2/X935xnDX56vL348+/VH778GG+M33n/Kv7mYFQR0frGx3f/w4u/XP+xSbG/uPWVgZBQTMXn17CcjNzezoCAL27dvvN+//eT5K8337cE7Th5GNhbWT2+efmH4zsbKys3O9evLX87/334JyMpw/f/39zc7DxuozSUgyc3+9+cfJjZG/l9vvvxj4nv/4sMvZhYWPp7/jCxfPn7j+//v688vX9+/+/733x9RjjdPGd6+/8bE81dAntNHgf8nt8Tf32/lnwj9Ufv/58Vn4R+cf6T/cf7g/8vBIMgq+P/7759STO6/uIwVGCRffrz9/s/D99zXPz/+85bn16/LbJx8LCwMPzn+/ePg5P77nZ1d+t/rv2ygPdMc3xhYmIS/6utqSStKffn559/fr+w/+X/9+8z6hfnnn8+/uT7+Zv73i+En+3+2byJMzMz8f74y/fnxivkfM8vX95/ucT6T+Mz26regpCgr+6dfP3//u/PvKccLWQVZERUxDkEGFkFOqce/3ytz8nJ8+S0oxsbJIcbJIsUm/FvyrxSrgJu8vIq80K93Hz6yfVGTkv7x49snzn8vf/38wif0U4yVR+iPvoq2hLDgLwGm9xz8dyR5Gf++0JVw+cH75+X7Nx8+fdVgEH/N+0manfcv2z8lZmku6f9CHFzcUlxfn/149/vDD85nH3/+f/3+MxePGhPv34/fNGQ/PH559+O1Pyzff7MxSvwXEGHmV/j9hvk78wM2RmkOVhb252Jckp/Y//HJ8Nz69k3wC+uHbx+E2WUkGXnfirEI/5Hm//2Bn/mP4hu5H7zMwp9Yf/7//vc/GyvnPz6O/+o/v0j8k/7LLS8swSYmziglKPpGikXnl+SLf7fPfrv3n5Hj4dPPn7+94vjG+pvx9R/mH7/Yv/HxiSjw8XAYSlz5++Dp5Ru7Pz/+oSOopqYlJiEgwsfHyMr1982X3z++/f/LyMbGzsLIxfiH4Q/Dn58MLLxsjNz/mVj/s//98ZPpP+iSDRYOBk42BgZmVkZGlt+sX19+/c4r+0dBQUZSmMNMXvf787ffLn/69u3xv9/MTP+/sP7+9evdz+MP7797y8HI8YLjx/dvLK852Rg5v3z+I8D09flP5v+8j58+/f314Q+WX385OX7+e/frKxPLfWYhBbk/904pm1n+/f2HkZHx3y+2b9/fv2P+wMHz99s3BibO72y/P/3j5WP4/f8/CwsHwxsWZgZ2XiHOLy9//vzJxsHMzsPBzPH/1+cPHz8zM/z9wc7xn5Wd7T8fLzMHPy/XJyYmXjG+L7KiPG9f8v78ycvExeNurP34K/Nntvf8r0VZFHi+/eH89+o7IzvjD9bfb/lf/vzELvjp/9Hnn16zfNEW5Tr+9PvZX69+P+f+zvrmD7OkvKqgjjy3OI840zf2Xz9esYGWzTEzcwr9/8/M/uLf4yfv/rz/ZG6syqn84+ef/z+YGFh+/v7Kzcn4h5fhGQPLX0Zm0H0/vCwfWf59ef31DwPDb/ZfHBxs//8zcHz7d1Xw6dUvPIwsIvwcP3g5XzNwMnxkkvjMyMb6V4qRg1mQ/Y0wO8dL7k9/uf7Lf2Fk+/dTnO0POxu7MPtz1n9n7n5+d+3za44/v+79fvL/twgfnxy7gJ6UnsDPT5J/2RX42AXk+X/+//fo/wfuv//FnrNd//Dgz88H0k8/MTEyfuHlef7/m5Kgwbdvb5TYeJWlhKR5WH+Iff7HwfP7HYORgAYjg5DQYxFGIa53Pz4w/fvOp8z595cQtwqn8HMJgaf8z94+/vxG8NXtvw+YfvPoi0mLMjPK8kj+ZH0kwiHN/ebd33fPVURVmL8++f6V7cfzf8xf//xi/8bxXeAzH8M3/o/P71+V5hdk+8p9kvWO8CeGp1zsb5gEn3C9PPjl6tXX74SY5P89e8zy9esN9ofMzDxsFz5dPfPj752vjAzsnFKsTL95OH/z8PBICot+ZOPndOaVMP+hzigvEyHtGCqgKKSu8Y+V+wvTt69vvn/5z8Dw49/vn38/fQedFvSPkYGFk5+XnZmRkfHH33+ff31h5GL7zcj87ceXX19Zf/xlYPz+8i/jf/ZPHxmluMVl+B+qf+V8ybLv4GfzF/9//2D7zczP+pGRmfM/Gxf731efH9x4ePDA5e2nzv/k5vz0genD5++/RWXe3Hjz//dPCTEBZmEZqR/sAsIMv369fffiO58kHxPr939sn5hUdL++efaNkenDq0esf74KcEv+/3yXiZONkZ2R4TfHXxamv/9+cwqKMv78xywg/PX3v69f3vxh4fzBxvTtz//f7z78Yf7/9/97CV4OFkYOPknpZ9dfszKxs/z6/PML2/unHzhEFf78/PDp868rd579ZmLn+/vdW1/hIf9H1g/PGT+wf2f7+F+U5e/XX6Bbu69zfFH59ucT6/MvX+6+Erj8jUtW4jPXy89/WP7//sPEwPTz3Yd3nzn4X7z++ePn9y8SfznY2H8psrB/ZPjO9Y5JkJP16+dfH3i/vf9taq4pLiD6j+E3yzeu/z8///nCxczC8F34x/8fLD/53v/+8uMPMyvD/5fM/38x/Pn6+x/rP4lfvz///MTM/ejW7Z9MP8U+ff36ment2w+nvjz/+PPXf05hGRExRk4ubp4fsoLinAz8DP//v3z99eaXB/+v/Xnz7vOr52+e/34r+OEvJzvDO9A6Dk5JLvEfor/e//8lrywgyMP24c7XS2efv/v95vH5q4ICDILc0h/f/hXlkwXNUr1/9OUBx4UPh9VYJe/8Zn75/LHIZwW+n7zsP779EnvPwsHB/PHfN/HXTI8+/vj7n4lfiJWFXVSA/a8Al5TtN24bQVlFfiVWZon/b1j+i/yTYf7HwPJfmE+F/9Xn679fsXFLivOIMrHx/OcS/cT0lU2EmYHhK8ur72dZPv74+VWAQUZSXus/8+9H33/+efPn4w8Gy78s7yWY7nJ/lmL8L/BbhOH/j+t/H0kLSzhwGzx79PLVh3+fPjxj/8L5U/Ib72eR/wb/OYQ4pMX/MfFLcmkKfnzz/bn4H1NpDXlJPhZxKUYORmZGBoYfbN/+fmP++v3Xr99/fv4FHeTz/zsnFy8vM2itwJcfv3/9/MfGyc76H0SwM/1nZPzx/+fPHyy8bII8bELi6gKGnjJqIf+V1RUk+T5/u/T8H/uf1///fGbg+f3nF8OXPz/ZOYW/v+P69fbT55dfL5759vvDM14ZdtDqIBU2Jlae1x8+v/11nkNKlOkD71WOL3z/JRl/f/n86yvrndcMP97/YGH8xfD/KyP/V5F/jP/fC/GI/Hz78tnrp//ZeP+8/sTE/Pft+48MbL/+f/stIMDJxMD+m4OP7T0jCzfvl/ef+f4zsPOJvvv1/sP3v5/f3ecS52P79+svuwC3FMOn788/PX399TcnJ+dPYZYPdxi+vv3Fxs7CHmPh84qB+9+3D4Ivfwi85fzI/vPfZyYGMRaeN4ws7P+F2YVv3n165uW939+4mFhAtx3/52Jg+MP26urrH9z///7mYP3yg+eF6B+mr4yv/v1mes/xS+Dvy9+sHBIMIr/+cHCy/JNxNuBlkP//k1eA9wfb/z9v/3MwMzCy/mV+/+vF53+snH8+fmD9I/CD8dMf1p+M/IxML78wMf/i+fXj7wf2dw8+/2eQEuV6x/SFne0tA/vzH7+/f//66iGHNssfZfE/+u9/MPA8/f+J4Z+A5R/BX7z//99+8Znv658PjG///3sm8kvoMd+tT6/Y+H+8fntDnl9F6K/I268/9py49vLDix/XX/8TFr315x37h68fOT684Hl35+cv0S98rwTu8jEJMb398+bX67d/hR+xPBdlE3r16Q/3f94X7x8LCjL+luHiFhPllHjHdJ3pK8PPz5/f/vz1+g2voDD7Ox5eaZ4vf1695fj57z/Le/bv97i+/39wT1hZRYSZienrG342xq/vPr/m/y7x4zvzDz6O36IvFP5Z/mT9x8r88+NT6d/MFz7eZmT4ysnDffP7Iy5mXgGen3oiEt+YfqjISd389UxYQIzt/bcz9y4+fvjpx6f/XO//8PD85fz0/+/33zyszILibEyacioGfHavBF8Js1jx62mJCgjLK4iJ8TMzcbD8/cPFzMbw8+fHv3/+/v37/8/nn0yMrP//srD9+fPj76fvnxg+ffnL9Ieb4e/X3/9APUFuzt+M7Lw/fnMw/uf+xcjKzsTx752Ioi6fJI+mlBIH79d3f9//ZxFm4GP4z8T87+8fhr/vWJn/MbCBLqhgfMt35/2te/d/XDt1neP3H44nf1/9/CbI+1+fUfHBnw8///yVfSnMKfmJ+TsvLysns5z4Hwb2r0x/Xj2+8Zf5Kw8bIz+f/Ec+7gfP7zwRfv2O+yuTuCDzTxYW0JFY/75zsD19+p2TnY3p53tOsf+Mf35+YuJk5Gb585Xlycvf9+/ffvP0CyPn53cM7/+z/P36ifPHL/Z/HEzvfr/lYOEVFJLhePvvOdPfrz/ecjP/stZR/cfK9v7397/vuP5xfPsHWt7w/SP77/9f/jMz/mBkZBb/w/+LieUTy99/b9g/vvzy5z+oOhJ+9Jfh9/1PfD9YOFk+P3rKI879l1uAiZPlPxvDD4FvLE+ZXr6/z/Pt7zdJUS1BVQEJhi8MvzgYOVn4WRS/Sf+VYGX/zv/n2/PfLKyMXPzMP6QYuRn+f2H+/53z7w8WBoavP1h+/vzN8+jT9Y+MH+R4JX59ff3tMzvbh5/iH8VN3vGafpBUZBISZ+H98YPzJ9Oj7z8Y3zH8YeH/L/2B9+f/D+++fxB6+Pfbt89MX7g4f/NyM/K8/n7/yuPHu0+/ePb2JdPT119eC76+9U3tNeM3OT4Tca1/z74zsbPy/PsjLiQpxCj4kvu/BAcvB/Pfr4wvXou///b07ePfDz9+5/nD8VaHSfivFI8uoxyTMqPIS17Ob79+7md5fuXtdTZGhvfvPvH952T4y/af5SX7V3bunyyfxQVeg84q4TnD8/Pm7//nflxkYGH59OnDf3bGOz8ui3AJsP759/efyP2fD/9/+SfIwqvDISn0668cj9xPNlauVwyifzlF/yl+4fgk9OavFIPgtSu3Hj/88v3pJ1aWv3+E2L5zcfLq8P8W/Mv/WeQH308ZiT96X6SfijKJMonyCfD9kxXkZgMdNcvw79/3v4yvf7xn5QCN2P1mY2Fl5WZgYWBiYvv5+/fn/0zsf5l/cnNwsv77+vvXhx8/3n///P3H7y8/X7x69vz1l09f37z/9pHlDwMXIysLm5SmsBC3p5EJKzOHEoeoLMcfhr9M/36ycP3h+f7rP+P/n//4v7P+Yfz/68vN598uXf1x5vF7RmYmZrnvd5j+/Bfj/v+C6dO/txzMv5iZRcW5uN7yfvr+8xcHB+vLm6/4NdWvCHyUePab7d2T9bdP3fj7/9XrO1c/v3j29/XPn38E+QS+v//8/8NHQZa3n969YGH7//0bA9PvPzKyfL+/c/JzsSjzsn4VZX3y7uODW39ePvn76xcDx1/QrWwfOP4J/Wdj+Pv14+//rH8/fH7w5Zu48LvHP3l5/7haGb+T4fjI/Vroq9Bvpi8fJf6yPeb+Lfv9D7vQq3/fWdn+ff34hZP9/7c/73l+sTEo/P/6/etHbo7fzAIM/xmYmNgFBIz/vHzPxc36/9cXZjE27h9c/zl+/v/J8/L3h3//mBSMZOXY2RgF//5h5Pn79e2bHy9Z/rD/4/vI9F+U/TfL34/ffvF+Zv7D+O/vp1/MbCzcf3/85+Bm5/rD+/7vE+YPD/kev7vHJ8TD9ObX4/vv/jFyveThYhB89/oBM9/7byLvGX98/XXz3yfOZ//khKX/yjH/UGIV+8HFraL0T/3zP8H3Jy88evnkxZ3bP/cdvfX+7XMeJtbXP1i/vPr3jffp73+sKp+ZNv24z8Yvpvn9L5OgtCSHOBfrL4H/f1SZud/yfNWUMn3+6SWbpDj/X3FJZqbvz7k+/vxnwiHCL8zAxPT3HfulB8z8rNrsEgxfuK//vf+Q573Qq9/mEmICr4TZOUXY/v679eu56P+/X789kPjIofaXyULU7P/f369+sf79/V5WRFn0KccvcWEehndc/xWPCT5l/if8VZBJgFdC4vcvBo5vLOzcr75++y3w7t33t8xsvFdePXv+gvv3u1+MP1n4fzMLc7KIcfIysAkKS3IwybBZyqmrvxV9L8etKSVirqLMJ8TOyyLA+IPx/88/H35+//XzP+dPZrZ/jD/+/+P6+/8f2z8xPn4GRqbPX/6wffvzg/EX168/P/6yM/9gZWb4IwoalPkj8Jv3Iwf743N37z55w/v9PTMDGyc7Jwvbty98fFLamnYaUoIOXP/VZDhlfjNw/fj2m+H/v3f/fv75/4v7J9dv9ndsjL8//v7z+8qpmw/ufvr755cyu+C73294/jKLKsm/4XnHzszx4tMTRRYlplc/nr17Lq0uZiagasepP+fv6/7d18Rf8jD//i3AJPXv+6fTV66fZ3j3/fmr3+xs7IKcvzi//2TifvWX6+uzV79/fH/08jMr89/3v97842WU/SX2+vefX6yfPr36+PvZDdAVstz/hH+xMbBxM/5i+M39mpNFUErl97fHHxm5/7Nwi7GwMURI6X7/zPjz3V8ZVh72/7K/md5/uf3+PfsL1rcsr3h+///x6eNPbmZmpr8/v7B8Yvz/kesv+0c2PlaOf2zfWD5+4nglwMb+4fljJjFOxgdfvnJ8+8fLLM7Ew8Dx/d/nT/+/samICGob6jBy//j1menrp/+/Pv7+84nzP9trJkbWv+zv2b5/ZnjH+Zf9FxPHt78//v//+ffPr38sf2QZ2L4zfP3y/h7bqy9M7OLMwlz/3kr+Y3r/SUhC4b/YyyvPPlxifPH7FSfP7//CYvz/2L/JcXD95RL+zy3y/tcHmb/y/FxiH5n/fX3JdOvHs29PP3Nyi/76y8n4j+Hfv3eM9wTPfnz5/P3H/5+/CrD9v/bxya/3T8+/usHwQ+T5/89XX/z48OHtndMnOL9IfLr59v/3f49YX3NqifJzCr19//38v49MnF8YuMS55LhkRZlZBDkYlAUNFX+K/JHgvs/G8ZXp5y++X5zfOOVYOX4LC33jYWFgZf0oI8H5jenT26fMPJ+5v7EKcUtvZb/778fPv3+ZvvMxv/ny6THbx0e/XrBzsn0W/8Pw9vdH0C7/d9d4v2l9E3376teD818/MPxgefmDVVj6N+/fj0wM3z+9kfzNxvf5M78CD8srth9ywtpiYorCuhySonwMHB///fr1+fuXz38YfjEw/Xz/n5HhzcdPLOysf9iYhYWE/zB8+fuX4d+ff3+Z/rD9ZXr+4e3bl48Z/v/+/e3bux9/GXmZ/nAx/2D+90+Fg+33518/GJj//eUVZuPjEmfj5RCW/GFmZCPJwq6gLyUvKsjIyMsqwPrvJwPoqPX3v5m4GL8wMbAx8zIz/Pzx6dOZx29fHfv+l+UHJyvPd8FvrP+Z+H/zvnt+4y0rz2f2v+/4XiszCH4X5/z8+eXfD58EPzIIC3z7zfz3DxMD409uoYdfmVheP33/+ML966wMLAw/md99E/3Dxcz749s/JoY3oN2ybxj52fj/cb79xvLlzVfG/1/ePfn6lePXe14eNgauj29YPrB8+ff/HyPT598PeL4JM7359P/bb5a7tx69Y/n27d83BlZmW1nFt6Jfvvz4ysj4hFniz/8/rHx/2JgZGXnffv7FzC3OwPRd+gcrG/Pf1xz/+Rl/fvrJ/p2R6dN3tn+8rG8/PP/Fyi0s8u/ez9+yoHmrn99ZPjG9FOeVfvH4y8uvL26wslgqijs4arMpCjP/+PIftBhH/C8TBwfT199/uH/9AY31MrLxMHB9+cPMwiD3joHxyx+W9+xsIqx/eRl+f/5w6cO7T7/42JhYfv96/+vr1f23pBgkeDn/8nOwSfJxCAvwsQowvmBiFeFn9PorIyrx+9/9z3++/eH78Y3j/5dPP35/e/OKkes/47fvjJz//7Gws/5kZvj+69vH34fvPuZlFLnw//t7Yc6T0l+lGUXffn38+i/31y8vOfmEP8sIvGd4+/83C5/4P3UReS9mTSbBL1/+f7T6JsL0XpBRgl/9258XzEz8bxk/f/z5k+HLy89MjO/ev2bn5/z55RWnMMenb+//P36v+1H6x78Pjz4/fc38Upjb4BHbr0tMf/+9e+LKoXbr74MXIuwibH94X7N/+/n/7ctvv799f/n653WG31zc3yQENPwZtW68fnHx153/Lz+w8P1i5WJjZHn7+xsrJ/NvCT1JJWlpZSM9p69yb4QFDaWEOFiEGHk4f7P8/vmLgeUX2+uv73/8/MoEulyL88O/z+xcnJy8rGIi3H9Z/n39xPL775+/v7/++8Py7eO3vwzcrMzsX/9+vfrow7e/jP9+crCy/VcWFpXll38n+vbzP8bfX94xff3EyMzCw8X3g1H6szCXpaqutIjkO35OI005KSN2aSmFPxxM//99+fvsK+tPhv9/Of6z/Gbj5vr94/+9R2/evnn35w0zF8e/X5dfsPDLsX5j/fPuzft7oLuqBHik5V/zLf/+fNf3+z+FeH6q/GV8+ZX7F/vPX6/vyzAxqijw/vhy9//X46/u/fv2Q0mQi+s36+vvH9l4OT7zfX3LyvD563sGDi5pDmZmjd880tIMgn+/f33Hwv2fn4uVV4j5w8tvzz5+uv7mPxfnF0EO/n+gE9G4WJk5GF99+fXl139xKRFJJl9N67sMXzg/sAr9kWEU4P/4k0FAhefDn/9c/9j+ffrN9JWRUU6AgfXPH6bf3N8Z/0n852QW/Mjwlp2Fh4/h/2uWD2y/WH59/v3z21/233+4GP7+fvbvryLv38e////89ujtN5b/bBrcQmzC/P+Z/jKwflF0NAg0VxRi5GD9y/b9z/d/b38yvxdkYPjN9vLfv3+SLN/+/Pz17S/7L3a2fwzfP3188uM2yx+2n79/vRF8yHr3w9c/XCY8Qn8F/psLiSmLK4lwCsj+e/WK4crnG3fuP/8Dmqf4+omF8znL17f/GBm/CzFy//n969Xff4ygyz5Bl8sx/PvF8Of5tw/fPn5l+M779gPPK25mFoaX//+x8HPqCosKfH3IIMTDdZfvvxyL9H9W/s+cNz6fk/8g9IaHT5aLhUn+C/9Phs9/+ESePrrDx6Tx/cd90OVEr/4qMLP+Z/zN9w20aJxbUPk542MmackfYuzyv//e+/7n7Lur8h85vzC9+Pzt643/Lzm+CbE/vy/EIszGLsjM/fct8/+rb5/LSEiy/3wlzC765e6Do3funr368Octht9ioA3+X6X+/nr1n/vnX1kmqZ+ijB/+PPn3WfSZCIedmCgvv4SYqCg3OysbAwPogPTvP1jYORn+//v84+c/Rgbu/7y8glyivLwfvn9//+4nKKz/M/1h/vLy1eM3Xz+zfHz55yvjyw/vZJmYxf99/8nEwsHCxSUnJC0hpiGr+PH3ux/vP917+vrnh4/cLOysf/8L87P+EpRz5JfR0OJ/J/VXnUNdS4KDk+UfKy8fCyPnn3///v/59JvnNyNo1O7Fb4b/skoyAuJsbMIyP4S/fb9/n5GfgYGPn5vx/T/uP0+Z3r3/fM/kFyvb959sr77LMknxaXDy8QgK/2biZxBRfczMKMgjwMf65vXfyw8uf/n1hU2A4xen4Lt3j2U/sX5+/ebJhx9fuVj+/PvJ8kZSWVhMmJlX6j/38+//nz76+P77Z8bvX7lZf/58+/Hir9e3z19lZvh17/Wt3z9ZHzy5/ZuB+cGdR+/+MzP9++MnrvTq2/cX725zvPjO8fP/x/vP//8V+yn/6xXDF843Qr84mTj/fWP7y/BT5P+f97yf2L9JyMr+//n9nfBf2ResP6T/sPOy87IxMLOyfhZhfvfrK+vD1yKCYnJ/mV9/+nmb9a2ckay+rpTQf+G/v997/PqioMAvI/qPi5/p37//TMyMbAys7Kw//spK/P33+C8DIwPD97/sP3+yfGMSYGT9/v3d5a/Pbr3nF/z9j4vjnSC7Nq+yjCg7y18mLsZ/PHy86l/VXv57e0+Em5+N86sox/PP//8z/+XnE+Zg/SIgLsasxcLMIfPn+yfGv39Z33D9+SfE9O73/49MH699ZvrO8EtQRJr199uvHz/L///E9E5QUdCC34T3tyCzyHvuP9yPfnw6/+Xl5e/MZ769Uv//7YeAEJMArxTrN27Bjz+lOSV5/77m/y35899fflXWmz8+sX34+ZOLk+E3g+x7Bkl+hdtnTnGxiPL/ZOD7zyLCzsb4n1OJRfzyz4+Mz/5yc3y/9/jD1a9vVQUZ1N5y6X0DHVt16vdzbSZJrhdfj376eP3yzR9PvvP8ZWf4w8L1m4/rFxcnOx+XPLusgbQdu4a6sBHTr39aAkK88pLcPDLsvKAR9P9/WH79/M3A8I3pJ8N3Bga2f4y///1g+Mfw9OGzD+9+ff3w59vXL9+/fPz66cW7h1/OP3n77/mjDyzMbx/de3r27m7W+5cfv/j/+ef3vx8Z/jGxs/FwcoGuhf7PKcj27du3T+/fvnv3688ftr9ibJw8vDJ80cquf0SEnv1/fufbCy52gT/cDKxSHH9+/vnD8Jf5/b8/oFsH/v9lZfvx6t3XT28/vHnx/4+IICvDby42FvYPqpp2hj9ETjO8vvn47f+/3zlYPvJycbP/+irFKfuK4ftT/jd8jB9/sXJ9evb2/4s/zHo/bnB93Pv19td7j9n//WITErz58CY7r+CbOy+e37n7k4FRUvb3z3efeHiF3/36++7BCxbez9/fMHz8+QN0+oasNBMT40vmDy8vfv7A+JOR9f2zV7wfv378+vH5KfanP35zifKwWjrrP2MBzUkwfPn2n4+dkfGj8EcBJsZ/7MI/WV/++ijKxiXAzvlOmuX7B9b/f/68ZfyvxM9xn/GXhCjzR56/b3+yi3L8FWER/S8sBNocyvP25eOvgpyM/znt/sn+YmMSYOdTdNT6x/n765NP7779E9NSclNXZhFh+veX84PAR+bvXCz3v7L94wYNB/zn4/gu8YeZjYlV+g/DP/afX169/HLl9j35L7KfmD7z3X2pba7G8fL3B04+fjlFJm5GMREudlYOFjX+bxJfXnN/+Mj2h/E/HxMb13+pH8JsvNxqwv8YPv0T/s30jYvp7yMGNo6/3Ey/nn5/de8F93HG56//fWDlYP3ylQd0/LjIc54P7789ZWFk/83yQoFR9DPbe6Yv/1/9//n285dNHy8wffj/jJOHhfUfCyM/O2hOhvn9fxHJT49/87DxfhHg+sL96y7nj+/vPj9hfCIko/zt5x0RSTkRLgY2NtZPgozP7n38zvGVT0SIkUNY00SbkeEfC4ugnCgfj8w/KRlplbdf/vwS2P310bdbHxj+83EK8vxnf8/4je8H219uJhZ+mY/mEkrqfPx8XCIiQiJ2hhrikvKSAoIcbAxsv1l/fP/x+8ffH6BrHHl///7F+vvnXyaG77//3Xn3ZtrRyy2rD357fOvbl7df3r9/9vMjqBD/8/81t8D/fww/fny7IyyUySPLzSt05N6FP68+f/344+Pfb0y/eIUFeFjE+P7/Z/r/h+Hz2ze/vzF/+vOJ9e83RgZJFmGBAk3rL7+4/v1l4Jb8rcMvLmvJxabDyM7J8uOXwN+f7L/YuRh///zG/OcCD6MwB7vg/2+v5AWE/3DLCku9FXz/7d8XnXd/BdQVXnx5LSii9ZvzL+MPwY93H2iJCxv9k//6h/Wp4FdxfsFvYj+kv3OK/eP4+PbD8Z/Pvn58//T689ccrP++fvnH/evhky8v7r9+zvD9Pdv/n8yv/wvwMn/9//TBO4b/H78Is7Hzcn//+E7o9X/GD/y/GD4Lcsh+/fqVRYD51t13b3/+krjFwMn76bOwtODnfw7mZh8YPv9i/MP6Q/THv0/vP379//Hbp2/i/xnZ2V9ys/zn/y/y/As7C/NPlk/PX/x5842J+Qfff97PTI94VES/vPrM+OTrm9eMf/595PzP8FOU7e2r99L8DGwCrGy/mF7x/BL9zayqoHuQkeXv+xdaf//IizInGBn+FfrJ8ITl16d/PyT+/mbmZvsFOrP2m+wr1o9//v9985uBmZWJgePXr3+vmc4/vyb49N9VLs49nx7JSolIyLA/vneFhZ3tgQALFy8zCxOruJAShwY/G9vfV19f/WT5zPSd+RfDJ3aWn6zsfH+/svxkZmBkYGL4+uXvT4a/X/98fvLtye9Xz9///P3tvsxPEUZ2kaNPD17//PsnEwPTmz+MTLy3/rOrfuH7K/OP7//XD9zCph91mf7/5Pr87uNDhqcXfj399eWbCJsM5+u3v1n+sP/+zvb+51/m/7IMYl+ZmF+9e/f+3WsZBpm/fzlf/mOTZubgePr5k8g/bUF1Dj6e798fsv1j4P7C9oWV8dnPVyz/+flfv+dn5jty8c6dK++/839h+/vjFzf37z8//vx4yfqHR0CJXUpK8pfkd04GNg4+ZmEOMSZeDiF+LkYezj8ff3388vb3T4bvvz7++8f6h+EfA9cr7t+Mi56e2n305KPnj3lufvj7+tHrr/8ZOJn+sPMzvGIVZv4hJsHB9fHby49ffxlKhpsYMqqrcAn+/fP8+6lLd9jff/334d3f3+xMTP+5WTh4RWW5/nxk//bv28cX/7/9/MfEyvT71x8OJi5+nnBjZUl9cWE2pp/qnEL/2eWNZBlV+P6xv+P49f//HyZGht/vX/+Rffjy1sXXD199Fr/PICYrpydh9ufF+2OvXn//xP33zsuf7IJv7zxg/PT63Ye/T6U4Pn34+YyD9d+1n/+u/H7O+Jb9xYfvH/7+YRBg+PrjJscDEU7Rv3I8Il9+MbPw/mPj/8v25R0n66s7b348/fX+9dfPvN+EWFl/8rGyv2f4856b+fMPFik2bl4BaWGmb1yMLOxfmBhFldh+/GPk+cr1i02C8+WHb89+fHrBy6z+4ZODgfZ3VtZP357x/uUT+sX0VUSQ+e/NP+8eMyn8//Lm9c9vjJyf/7DyijAzfOPg5/4hzMH0/Rsfq9jPF9+ZpFjZmIS/ib/98esv4xdBYVYu5s9s378zHHrz4PHlbxyvOBm4f6laK4nzCTOyCgmIir/79FmW70uMhso/VbY/jF857rIx/H374zsH85ePzE9ZmFgZmP8ysTB//vOb5c8fFqZ/fxgef7h27O3tN2/Mn3OwSL+T+ywozst158MDhlv/nr779FDi15v/n3m+s7/lYmL/8ZXxk8Sfd1+/f2b5zv2DS4aPme/HH7aPbL+Yf/H9YWD485ftC9tX3ldv33+/+/X/Sb6XN9++//yE8Sf393vfef9zvJf6DloIyPdPSljElFVUjlv074cP77h+M73/9eTZx5eyXDJ6LFyv2L6/4WC7/e/Zw2dvmJkEfnAxSD/nZPn/lUuMQ+wt/x82dkFepk+Prn349err3z//v3zjFf7/+9UXqeffWPgF+G7/kBNhf/T/0d+Pv4Q4uV+9enfhxa9Hn++xf2dnY/nN+Fv4x4cn/3+LsssKCsqyGarKGwqJMTBo/2IRVuCXYOHnERXgZeRmYfnK8PX3T0YGdtBo4B9mRkYGRq5/Qowyb3//+Hjj/5vrb1ne/v0v+UeakY+Di5eR4d//Xz/kZIV+szJfuv/syvNXXyR/6nOosPD+//rtJxuXoKO++r0fvzeeuMD47ivjt7/ffzIwsf/lkeJmllJnF+Ln/fX3+7f/n159/v/rO8tPbg5BQXUNMwclaUZpma/Cf19/Yf//iUFQ6ae4stp3gS9MzGyfPjNcfP3m1xP2sw8f7L/x4cS1M3c/PL3w4uSTey8U+bmFJRlYWP8IfecS4BH8zsjM+fM54wOeTzcf/uP6w8DDKKXKp8QswMyhzMv8hYX5kySPtAK70Cex+6LCX7jUZN7/ffft/ScRVmEBpq9CHAIsvx6y84iLvfz7VZ6H6zubiKzY96/3nzx69Pvdf1b+bxzCgmJCfG/vfnvH/f8XMwMzz2fOn8yvHzN9/vH47YNPT5++/MDLIykk56mh8fPHj69/vrxm/CDIJ/id4S+/hPT3Lz8YuDgFBJh+C/1l+M/EKMXB+Pznb8afP/99/v6TiZGd4feLX5ysP1gYuL/8+Mn0m/Xfkx8MYt9fff3N+ZT1B8Mbdu6/b999+fPqLrMu1x8PNS5RmXf/eO+8ZJCWENLm4WUQZf7Ox8D2k5Hx94f/vH9/s35hYmT4+5+d/TfXf+F/zJzcf/594wTdyPv7+bnH15g+MDOrHX1/6fydvy/ffPrK9Erkyx/2n3/4foGOeOP4yiQoJ84i+vub+B/uv0xsDP9YfjGw/lFg5Ob5zcrG+J3jP9MnJgbBf4zvud/wcPL++/L934t/v3/9/cvxn/2jJpPYT04GcUGWd5/5Prx/yPDzxocXb3m4eTkYrn27wMQsL6wkLsn2+d/n318FX4tef3zl46c/wtLMrz/f+/VR4NnPr/fY//16++qTEuc/vu8M/5l/i0urvGET+8z1k09T6Nf/34JcX/99EPrLcZjvw/nbp/7d4/ikwPby9qsHP3if3LvN+eOfpCAno5ggCxebCCePEBuLgqSkqhwr4x/+258/K/Pza4hwcohL8ghwsnKyMH5n/PznF9MP1h/fv//4+/s/LyMnExPLh6/P33w6e+XB7+fPfrP8uPHuwbvnvy+/vs7y//t3BsY7Au8YWZi5GDm//v/KKMZs8l/+y+8X7z4zMTCzMPxnZuTjCzFUv/Hy9fXLN94/uPH128f//9k4WP+yCzB+ZmX5y8fDCNoG+e7Xx98MLL9ZGP7+F+DTkzZ20zX59fj3i/OvX999x/+SQUCdS1Nc7J/CG6ZPjD/uvD/1/A/Lh//s3348fPl+5ePT315//Mcnw8D15S/vf2ZGrp8sv5n//hL9IyogJSkm+FtAjF+bR05KmA90KJK8pKjUd4a/DG+FOcQEmP8xMXznFbfg0uNU4BNm/inOwPODn+X/3/8MLBw/eUXZ3r5h4hZief7rC+PX26++/RZk5OYX+8Dy4fYzhu9ffzCwf2HmZeL9z/bjEwuLCJswk8iX3yyMP3jf/H/66fu3R58+f/r3lVuZwUZZ8w8Lh+gXnr+fvnGx8n/l/i/yjvXbn1ffGHmY/vz7w/+TW0jw5f1fT969fPLrqTgz3w/WfyzCvB//vGd49o6NU47x9+u3ct+5PzJy/uX+8fnZN9F/f36w8AiIfHgp+uz2W4avfN//vVXm+Pz2D+OzV7/cxUT13fWYRH7//sjLyPPv9w921p8CfzhZGX+BBpCZfgn+//WOlY3v76//rALvxUV+/2Zj2Xvk2PUTP98/evrz4z/Ou2z/H3D+e/j+57Gv7x/84f/OyP2Tl535NyPPr/+MzD/eMH4WYPqn8ISN6wMDI+9/hu8M/7mYmfiYf7L9E/nBwMDE+vX1zy9f+W6wfOP/ovqc46v4D/avHD9+/fjx59/jLz/+/vj3//O3Jwws7H/FmaSesXJxct56842RS0hKTlTw1299ecv/n5i5PjAycn66LvqF5967f3/+vnv769dntk8vP/789va7puBpxpuMaj++vWb4zvXnGdvPn/85WV7//MElw8jx68MLxl+/Prx98ZiFjfP/L843vJ//v/v+++PrPywczDoc3Mqc4pyyf9h+GfJKSUlJ/5MWYRf8x8/K8vcvw7dfXxn+//3+/cOv3/8YWBlY/rL8evtx15WH209euPPixddXH96/evj03rtX7658ecH59vmjf+++Snzj/8369dXPX1wyIpZqep9+M31mYeD58vXXx08/fv1kYGFkE5fMcjO6+od736UXzC8+MH/7/fUfOysThwAn518ODgEeDgYGxu+/f/98/4PlNxMrB/sPVm5NRkY1PQ1u/r8Mzxhe//wn94VDyERUWUqPkffbjz//f3168//vTxbWP2xskqyHuPY8vyv8+8VfBv5/bILfeP7zs/7iFhYS4Pn+/Y8A848vTLLC/55++PH9xQcxQabXH1nFJd9K/ONkY5H6x63CYKzyEnQIMjsDE5eu+ofPzz8/ff/759+/TG8+vGJ+IPH5y6+nn96CjgPi+P2N+R7H588vvt3/++HDm3sv77+9zcPIwP79/QNmfjYhxl9/mT6ysL569uIXFzsfP7PQ/ycvbj35/vu9sIaWuL2y3HOu70J/fwr+E/v/hOkT21dJRrFPrz78/8/FxMD4+dyjN59AbSfWD1JvuJ7yvOH88+nPb14GRiaRv1Kvfn1lZn33/xc37/fv79nFpeQ+cPFo8THc+vOH7434bwHBh58kvjPxC/ErSoj9/fuFift3ECdblKDxD+lvvxn/sP3iZvnPyPTt/1+RD//+sfxj+s7wh4vp/7ffbJwcEmzakkpfvv6Q5BSQYf75j+HrPza+f0yfuQUEPn9k5WTgeHHp2ZsPrz7zfOOQ4pf8pvNV9B/TP26OX8ycP9g5GbRZ1L8zif3+w/D/z5cHrH85vv3+wvxV4o/oP5bn3C9+/nl989fbl3/+f/jz++cvFiEOVkFBcc6/Aky/Gf8z8X34JiTIzPSZlfs7N9Mn8e8cjL/Yfv9RF9L4wvqMkUmIl42HmfW9zhtxdgm+/xLiQj8Z/vN8ERGS/8PGw/GBQeg7K9vD13+4Gdie/hVkE3l/88sfEaZvvL8//3/OxcH/RYT5OwcDywfWH4q/fnz/yf5VUFKESVNKwFBIToJT4ub/71JcmuqSPJy8HFL8EmxsXH///frG+Of/X6a/3/79/PPnH8s/XgZWpu+PL7z/+O7hs8c3H/198fgf+49XH4Tf3rr567vg33fPtly/v/Xuhbd33r368fMh148gZS0hXnY+QUapn/y/WP89ePSJ6fd/0CVIXAIMQsJRFpq3Pzw9tvfCm0fP//z9/uMPAzcfFw83xw8mhu+cbIy//n4GXSD2je3rL1Zhzt8S4oEMwl4W1sISAryvmF4zfX7zm4NPQ9A4WJX5849/DH/ZWLj//Wf//u/zz/dfPj5gewU6Moif8fk7EX6evz95/3/9zSQjwSfKwMjC8fn/JyFlbWFJAZ2fYqxs3/5d+/ybT8iMRVDwPxu3xO8nTz+uu3OW9cZfmd8fvvz6z8rM+u3j22ePnjN9/8z0ifnTIyYWyX+s3/99/f7xg/jHL3+5/33/wPKD6dMbRqYvnz98ev/+0xd2Zr7nn34/e8f05e07JpZ/75/++cn1+a+QlBw36y+2X+8ZOOUUlQykBB9xc336cJ/tz/cPr9mfMt3+/JHnP/MXVm7+z3/5v7L+4X3PxsDHKP6L692fV8xff7N8FuAS/8n0kJlHk4v5Dw/b18/f/n/4zfbxlyDD6yfvP0v+kPrPxa7G94uF7dG/359es/75cO8bM9PvX3zPfnxXUv9pqMXP8V+Y4fPPP9+/sv76+fcnF+O3l3/+f2Zg/8/MyMQn9E9BUuGWJB/b/a/v3r56xvnzkyAj04+/fwR+80n/MhdX/CcJWhn37g3jzycf//35wsD8iuvNN0aWf78Fvv0QYObk+8Mj/JObwZBV8CsTK/Nvhs9/Bdj+/nvK8JHrH+PnH8+/fXv85eHzh8yP2fk5/3ELibF8/yDGJPaCh4f52z/ONyx/nn5gun392qcnj4S+8Dx99O4F05sn/94wP2cTkOV7Lvid5avwd7EvT17+uXrljKKCprKgKuOPX59ffGH89UVCSJqdkUuUh/cSy6UfTAzs8t+EvgpJv/op+J1ZQ4iH8w27MAMDE89Prn8MMswSbOI/fqgp3lf7psbKyf7uqyCrsIQw2295bUkx0d+cDF++vn3/4fu3V98+fHr/4ddnZkZ2dh62r29eXHz48dWNZ+9ffWNgY3r88u+7+y9/fXn5nZ3pz9ePX/+xXzr68syqO3tuH7//46EukwgnEyszu+A7pr/f/n99+uaHsoIYJ+NXVibez1+/87Fw/eTmzAlwOCv2fteJY38fvfv56+PHv7+Y/v5lEeDnYeNiZmBhfvnxw6cPH96/ZfjJxSUiLGCsbGCiIikn9F9A4Nf9V79evnn/9z7jE5ZfLEz//zOApk/+/mR684WFj/nb0++HXzx8cfMWLwvzN34GAVEOQSGW39xc31keySlJsQhwf/h+g5VJk4n7z5/vHOy67OY/hBiZRP9zMmh8YPz3m/XBv4+Mgt9YOFR5paTuPv366vfv3394f3J//veW7x8vs+A/Hn4+LgYhAf5nvL9kvgpwSyuqCHExMbzmeMvEyM7Iwfbw9hWW77+5WL//5ZD6/OMZ338B7o+/f/18Jq4mxPT75/v/v74x/NAS5dcXF3nx/6eQACOX6JffbwQZ/nz6+/kH0+PHzP+/Mv9n/s71+8+Xd+84mRgUuH6I/wXPZv5i5f33j42JnYXtLzOfMBsj20/ln2/+sfz4/p/p6xsWdhY+BoZ3n78+f3yd599/Rm5JHq4Pf/4y/BL7+PdDrLiukK/Mf4Hvv/9++fmPkeUdOyunCMtXnr9Mn38JsslqsLGK/Pl65eTjH9//vGZlfM0nKsIhoM/K8k/x1cvXbzje/2dm5pYQYeT78+3pz493GB///sr8lp1L5CfHLx6mp4yfGX/8YhDgFP7CLSXCwsj7h5mV+RHoEArGr/8Z+EADN+zPfv95y/rq2/tvT5h//norwMl97stDpnvPHz14+ubXt89PhZjYRdjevvzJJsn2i4fj1xumdwKswgLsn+7dY/vJ+JeT6cHD169evfrDyvH048tnHy98+/vlKeu3238e8vCLyPEIvf38iVNA4tej7+++v3/87MtXgR8Samrn31y5wfyBkYvjhyjLpwdM71n/KImIySgKOn/X+MzA+ZmT1ZxHXVCSX0SEiYuL+RvTv0+vf/z49evv779svzl5mZl/MP78//Hvx+fvjzy+9fz9q+e/mD68fvbh1Zv/n5g4uJlMlWSFBdnYFd9JybP/ZmBQERKzYdD+yst89s7rb8+eSn77//kvy7ef/zjZ/v3jEXn29f2/nz+//WH5zczMLiZZ5uj3Vojz2JkHX589//Xt289/jJys/9k4ub/y/GHjYv/34vWX/4xfv37+y8IoyCUkICflZ2ImL8P3VO4H58Mvf8/+u3L1IdNXbsZvX///Evv75xsLB9u/bx+4WDl+X/2w//XjM9/vi/5g5uD+z8DAIv6VVYRZjVGUUebtz288/wT5/r1n/yslJv/nHx8vM/sH5ifvhX7++/VdVolbglWA6dsnhi8frBSVZQy5v7/6xs3EyP6Di4HvN/t/5p/cX4X4hDk4vzMrMXM/4+dU+M3wnZVbkIflB/u3n085mJk/sHH/+8rF+P8v849v/3/yvv//9BOzKC+3FDMz539mAVBz7MuXdwJSsowftGTV7379Kcci+ucn24e3r37/YvvJy/L7K8N/Dnb2nwx/ODgYPn5mugO6RI6Fgf0r27//TKJvH37gZP7GJMX58Rsjj+BP3r/M3xl+8jIK//31V/Dbrz/MbO++PRB6/1eU878AF6cgMyfLr69/fwh/YvtbKsdUHWjKrCz598sfFravvxl+/mP5zvRdhE2JSU5C7s/nvz9fKnx78/jLP5YfUi9FmTjVGHkZ2D+++cb45D7b988/ueTecSvw/fzP8/vFV4HnfOwq/BwM/1kf/mf6y8745REHg9B/oS9MP0T/8L5hY2D6x/3mB8uvP3/+gpoEbL/+sYNWDH5++Orvq9+//n/l+M8KukH2mej7L58/Pv3w/M9dFlExlV+c9/nf/uNgZ+VWEPj6/PN/Dq5v3N//fRL59eo+v7z428/sP77/u/X/trew03GGw6L3ZUUkf717cI1BSZb99k8dPrHLP87++CjG9O7FN0nBp9+eCAtLyoiIXb5/mevWfx4euf9qb+TFtdmYhN8Kf3n58Y0Nl5qorISQMAvPP/Yv/799/vCLgYGT9dvnX8yf/rIJMzKz/nn56vqLjx/ZGe1ljW48PPXs1ftPb799E2bQtNBmZ2KU+sdsxsnHwvjt9TcOcSHuN4ri/9j+/P34663gt1+/fuowcH1+80NBkhG0hebXP0FGJsEPb+4Kckj9YmHmlGDg/1xoZda39cqf8/8tWFg5JaV///7NysHK+f/3XwEhFjYOzuev/0soM7y//VVAjY2VS0haytfQ9MH3/7oSjBvvPf/6mpX973uGvwyMDC//CDH9+SPM+ufx9++fWBgFPr76dOUL44/vz9y5+BhFBK79vS/HJPnu0YvfIgL/WPk/fH7z5yPLWc5nQmzsz54+Z/rLfUfq3R8RNb4P32wFJN/9/nbpxQN7Ld0QKfUpv94/u/xGQlmE6e/Hr/8Yfr0W/aTwl/nVvz8PGH8yPPorKv+L/fOPV384mNk4WGRYf/MIiPz9/vX3/+dff/9mYhcXlmT9JCDAoszw7d+HH58/fHvx/Nm/H2x/zZgUlMz0ud8KM7CcOf71D+M9nv/f/nxj4BRnZuPiZnrzGlTQcPz98Y+P8ccfdib2v0LMIo/+/2N8z/7/33ch3m/fvzIKsjK//vyJif3f/w/yvKJcsrzf/3z++fA5N5PUDyZWBh7hrz//cTJ+Y2Rk/vXnCzuHuKGBJpPklyo5084Z3V9fsfGw8vxhZ2T4/4zllcylLzdAq2d+c3Bwifzh+czLzv/uN/uDR69ZGdm5vjH/kr3P8JWLSUaI/QPHN76PP77++/fh418uYZbn/36I/vzN84P/k9TXN89+MfP8efmI858YK8efP5+5//74+4/1F/sH/t88v1k+gbYJfOb/8/XNB0kp3qMMz1nvsD7/fZXxpeiXXx+ZvvEzfXnx7C/7/y+CDA95/798/OqHJNeD73c+/v357cdHRhVupsff/vP81+WUUPknzvj9h+U3VQVt/g9v2TklFK89ufuThe/qj6cfX3H/vPv5A8dvjrtMDH/+igvK3b/0lvfbV67/ohzKLy1YtS5/ufDi07PnX95aMooq6aiLCLOy/2H59f/P67cf/797z/D1408Gpv//BBgYv/z68XP74Xu7Lp+5/+zll3cPr3149/nH1++cjMK6MhPc3CJ9gti1+Dj5hRgUFA68eMwiKaT/i/n4+2eszIxOvDJqwtJvX719+OkTMysvExPnh0+///1nvCfNLPWHhYGB+++XD3/+C3yXEC90N/jx8/OJ23de3Tv/+yf3l7+/eLm5Wdg4WVhZmZgYvv949/EjB8vLDwy//rLzc/EpqBQZeAXKKSV56HFw8v5k/fPjDxOHMDOb2F8m/g8/P/MzswkxMv7keMnE9FD8wuVLB249e/7yJQPL/0/fH8r8U2D/zyr1mOXWj9v8XP/FX7/m/PPjrhTbbf57uqw6X/5/uvT7oTQvNz+DwPu3r54eO/H443f5z7y/uTlePfv29/UPFrH///+wfn72/CszMxP3t2efGR59fyvwnuPHr5d/WP+z/Pr1j+npF5GPTF/efvjB+IXvnYAQC7+4zI+3T05/Y3zw8e23/y+EpNgY+VjfX7n28vVbLmkOTVFZNQXWb4zsXBwiTMK/ftxm/8749d8fRgYh3m/fvrP/Y/kq+pWVi+c76+OfMlx/eVmERHl+fX3J+vwPxwuW7xzff/57IaOi+uDX228//7F8+veNifv/b2YFcZ6/Pxh+sr/i5xf59f8Pl7iuvhr729s/jjD9c1JkmOdlIizO+/X/u7////Awi/x59enli59v7skycv79w8rCycwjIMX+gfHre6Z3v5if///3TUBEWFBEkkuARegPPy/Tb97/bH+Zxf5dfcjwmfG38D+O7/9ZGAR//gQ10Xjf8zOL/v0m9Z6ZX+73XyaGfxw/Pn389evtH2aOP4Jfub78Y/rH+PXTD55v7H8FP7B9FGP9ysDIz8rO/Y1Jkp+PmV2Y9w+T9Ef+t8wPvzEwPRXl/PaW78ev94zvv4uqCvDyfPopCpqoYONhfPuX4feHZ5IcfxkZ/vH/5Hvy8+XfC6/+M/39wvmVmZH5JfdjZjZenqefvzM/Y2ZQUNRmNFU0V+UU1WNwf/37l6+knq6ZiaiiMB8zx4//v9/8+PPr4/9ff9m//vjKwMT4k/k90z+u8wwP7j5+9O37r9d33u7dc+n9qwef/n2QEJTU4hM6wPT5979vSqxaPKx/Pv/9rSjBcfnQkQPPHp7cd27f4cff/3y9wnj/2qtXmgpsXBwc/77+fCrwjOvzF/XP3H9Y2D/+eMn4/8//X3///mT6KSzioydx4tjT5/f+MH59zcDE+I9NlFuYh4mThYmbj+HHH+afv758+/j29WdRTl5+EVZGNrYv4nIyPPyFYQpqIjL/uRhYdVkM1KR55H+wc/z5/5nlJ/Of/3+Yfv59xfKc9cK1Z+dv3ZZ4zfSS/fdXuf8c7EJ/xL7J/+D/xMHEI6P0+/tHZS5x0f+SR/7c//3p5TdhkddcTL9/P+R4+/XMh+9XTzz5ovonUEfqJwPr8z+Cf35+YeZ7xvaJg+HlD7b/wj85eJmefHrw5stn1l8c/1n+Mr5n5VX6cfkvF4cEp4AIAyMHw59fT35+ePfxz7fv336++/7rjzD7H1ZJaW4OLtnbN15+eMPw6s8DfUNlfTmuD18leEHXpX3jfMvA8Pctx28+ll9sX778EPzD++XnR67P/Mwvf7GJ/f///P8fVk42KU4BGbEvTN8EWPl+P//ExMx068MtERERfob3nxiYn779wPj/qwCD0tffn/6zfbdUYP7FwveZQUD+Ff+brz8EjRV7Qow5lHhZX37/wfCP8R83ww+Gz58fswkx8HAJsn39+fXzx5+8b7m4Zf4y83/m+fHnwb8/Al9tGOQf/3vw5cPfvzx8HL8+cb1g4mT+yvbhH7sK/0epb3wsItxf7n+VYWMWE2DnFmXles8pwMsuysbOysnCzMzwHXTm8xemH/852b5c//ji4i/Ob0wCnOxiOqARe3ZODSbWn//ZP3z89Yf569dn+sL2fN/fy91hEvr76afkXzZGft7fDEaMRly/nnD8Vfj+7sUD1u9fv7CwCggdfXSC/c9PsQ9/fqhJ/vvznYVNkJ3hPaMcz7sPTzb9uCouryIhwsLFzPbg05NDn16c/3OGT1FFXEGOV4yfm4Pj+99vH958+fP5J8OvH78YXnLwi/1m+PX7I+uZhw8en3jO9v3Pl+fMLx89fPjyPTszr5wMNxfXD84Xv67vuHL4+lam9w9e8L6SZBIy55G4/vLnsctXGF5+O3zmxIPrL2zfcH9i4f/8ipmV+eeXf591vkr8EhB5x8nFwMDAxyXx9d/ff//+/f/37z8zJ4O2cqmjw6F3j69efsb44fuvrx9//f/JI8TPxMv3/+/HD+//vnjy5sOXv18+v2Jj5OZhE/zJLiYkJCegomGiraqmrazMzMWpqCKppiGtyf9X8SfzJw5mzn+MHIxMPz4w/OV48OjfoRcPRX/x8jHJPPp6ifuTsKCcsPJHNqk/AtyCIj9fPRBilP30970Kk9qbX3cYmNk+CHD8VWb/xPblw4eHVt94uBSVHXQkFDl/fHwq8J71J2jroSjHzzeP2P/+4f3G8IH1MQ+L2M8fzAw8Ugw/n7BxcX599+4z43OFv0K/3rB+YvzA/I2bQ5RTjOvvn8/vfvGwCLL8//T++/dfb3/8+8nyXYCFkcNM1Vha9OeLj39As6BcDL9Ymf7wMcjKKPDJcbL8YeRm4mOS4WH5/v0HO9ePv29YBLl+3370j/OXEIMClwy/oDiLrIDMn79cv5+9YucXY2Vm4OHhZv0t/vn3FWYGJgcT899s/F9/CPz78ZGTj4ODRerUF2YOea2FkcrcutLfv/H94vrEz8wsrszFrMPJ/eP3U77fL9/8FfspxCbG8JfvN88XuRe8Hxge/dt76QnXs++/BBj+/nn9j+fzJwaBp5wfmD5zsL/5K/5G8Cv/O15mWQau77/vfmD++49JiIHXhpXFSoBDleM/6JDx/4w/QJslWZi+MHNy//r1WZBVWIj9h8CbX+JiPML/nzL9YvvzW5CBmeE/MxPPfe537168fsX15Z00O+cfMZb/Hxl5xc58uPZZWICR9/WTj19Envz/y/zv1bdvzExCv4VYuXh4fl36yfiZm+0nA6MMvxOHqrqsiTaDigr7ny9CnG//sH1+//f/n5/iEuK2avJyKqK8vHzf33999fTjj2+fGb9/Y2X+w/SX6/+Pz3+//Hr/4d3tE0/ePX7x7cfzrz/evP7wjZHlPY8IBw8bn5SIiKICuxwXq95zrn1/3jB+4/n47Ol+xnd/hUSFJLi5RQS4hJnWP79+5cG7b98/iUswffrx5+K3t6+Z/v77+vHH739CjD9//HvPxcbLwcj06/e3P7++/GMQZdZmT9E2XX3n/PVTF7nffvr46//Xrz+Z2DiFBaQY+H9/Zfrz7fGjlzcvfvzwhe8vg5TYXwZW5qdiHxgYmAUZ/jF/4vxy4bPYH055PQEjfqE/Igw/X/3//ZvtH7PQH6nXDF9YHz5+dOnkkydvLigzKO3jvcL+l5VdjoX58xcuNv7n/z88+v/O9B/fC8FfZuzGXH8+iYtKyPHIWWtJqavLnHv56fWLa+LKQjw8TD9/sv5+/EuCm4vv7d/vAqy/GD5/ZecSZJbk+/H/y7+b3358YhZkZ/j885XAP7ZvvH+Zf3+Ufqv4U+wD71eeP994hSQVRMX+MHPff//+w9fPnAx8j5+9+MvM/I/xJxsHv6eVmraR4H82IWldCbNUe8t07XsKb1yNDVm4uN7wvGe6z/lLnV3gCtNvPhHW3/9+C4u+fvDhE99Ltp/8PIxSn/5/kVYR/f7ty8evv3gEOb++f87I81mYQ0NfVej3719ffzAw/fzIzfiX4euf1+8fKvwW/fLrP5ew3KxYUwEdJrZvghIy/1QkRL5d//5K8pPwLz6Gl8xP3/35+fApAzfvd64HLG9YPrx4+/bzA87/gtzcDLyfGf8LMLOK8nDeFfjN9fXns++/xP5K/+R+J/9e6LviN8XX/37wsnMLMHByMzD+ZJXn52XjBS3a+8z897PU/08MjD8Y//76+vP/P2Eu3nfCv39+/8nMJsjELizP+5OblZ+Hh+2r1EdGMXlV3l//LZjkOP98/PH7/8+7D0UZmT4w/f/y4AO3qNSNr6d+g1Yr/Zd7w6LOKXnp06tfTF9/vfn7R+ZblKXvIdmfn749/cr4T+g1o6gQ92+W7zy//1oranlqWmmJyTP9Y/3y/8/r91////7/59/fb3/+/GYR+sv4/Tsrw4uXbw4/ffT63Zvnjz99+fT1x/tff4XeCXKIWClL83K/FlOU5ecQeMn1fN+//0yfX1x5c/028/PPIswsyl9/Cf9/JfRVQY3LTJVj+flrX198537+dNPbuxo/ePn+/hLiEWT7//M1EwMPi9CvP9+//PjK9peb5dfXf+8//+cV5ZATSVZV2/721fHjN/6+ffv/91dmASZGXiYeAWlRSREBVoavrELvfj/78/Izwy8hPi4RLXZZGUWBr+++/vny89fnzyrMAkx8QqyK3NoS7CwC3xgZfjIwfvrzlJ2J4dXfy4L3v7w7uv/55ScXGX79fMjB8fMb32Xm27xvmGUk9KQ/f2Jg+n/u0/2nzN9/8f3+9O0ZmyDnl+9c8hwSP/g+H/j248D9+zxyP4U5vnx9/euLLCObBLugpCDDF45v3/+LSnMIyYiwsSj8/PXv5cMnf5iYOV9+5RH4/ZWFVVZI5cPrF6zCjP+fMdx7/v7dh++/X724e/HBb0bW379e8UiK/H796+PLd8+ZfnOrKJtKaovaCEupKsdpG4Qq2JUrhV9/9PnP61/C77gYf75hfs305u/333+e/P38g4uHE7T16dX/H6yvGJl+S3FzSb/hEFVQYPn5henbT2kufi5ONk1NfnbBX7//8//6+YObm/GPkNC7378ZPr1mY/z+kfHjla9vmARl20IUzFU5n8iKfXzxiZWVW4CZlY3vp6Aw66+3X/89ZmR++OX/y78Mjz/9Ymdk+cvxn+MbCwffd2GJf4Ksf/jesfCyf/v69cdr1lcMTz5x/Bf8Iiml91pCQo1V9Tcv9zc+Zi4xZi5GNiZWjr+sYl/ZfjH/4/7w+8v3Pwxf/vz69/3pn1efP7B+YfjOy8zA8oeJ8eP77y/e3fj39tOfL+//v+P8wfJO8ueDn0z/3/Ixfma78+flJ2EBxtff/3GIcDD/ERDXZXv16uvXfyz8/HvfnJX4K8EgxMLDxWmsqyMp+LdAzI+XW1X7G+sTabEPV++wsPArGkjoKinLy8hysXJ//vrjw9tff77+YmRg4GFg+SfAK8T0m4X9x7V/T549ePz6/uuHz+99fPfq558/zGxfuMSkFeW4XzEzqEob8/18ffXTtUvMf4X/f/7575ucqJQWu7D7f34Z1h8/frJJfRf+8u7fuz8fwu1kfr18tvDhZ09BFVlJHmYB8U+s33lY2FkZOX/++8rGzMLKzPH9zwdmZr5/HEzMoGOrBMUM1Wsd7bbfeX3n7B2mr4xf/33n4xfiFWMXkFAUkxTn4JdgevL93t17z959EfwvIKuoriwn/EGRj/cPy4ef7z99+8vD+v8Pn8A3Oz4NYcG/f/////Wf5f+f38z/QEOUD94/ev3+9SWhz7+ZuL/9evb11W+GT2x8fBKfeJ6Isjz9/1uHhYf97/cz355//POVh/Mjhyjbc8X/jj/5TRl42b79+PaK+QsL06efDFcO3uP8wCL7lfM3FzMPzx9uNm62b3/EGXh//fn46YfIj9ffv7L9/vOD+Rf/d4H3H//zsP15wPbw7cf3X19dYXxw9cpb5r+sso585tpajG///xVkYGHhlmRkuvT+BhMLi+VPDu0//38xibCxPr5+7/GVF9e//n39TfLDR7aX/39xsfx/x8qiyvDn95/Pf/mY+H8K/Pz06M9Hpl9337xhk+Zk/PSeR5CX4e/PbxqSKqqKHKxff/9R5WT7x8/P8peJ++931t//mX7yK/75+Vz633/elxKvvr8QZ1eOM9RkePj7yqOXnP8YOJiEWbiYfisycUiycXLyfGL78fk7xx9+Tgbl3yp6Ej9VBX/8/MDI/4XnLxenGC+zwA+2V7yg66QucPx7842D+c+rjxK/GX8zvWX7+obtzYPXXx99eMfw6R8/M8MXka8Mn5necTHIcP/9/p3nE9uzf+/fMrNwMP6XZOL/qcrEdPPrNQZuyX9P3rP+F3/Ix/XyzSNmDr6332/9Zvz4Q/jnH2F5kSdvvjH/FBARuP3poxoH8x8ekY98v+5/+sj5nkNR5P+3D98/8fLK/2X88UNu98fTyvc+3hZ4+/HZzXd/OfSVlGxUHeXlZDnZeP59/vThw5c/334w/37/////X+wCrN8/v/v1Zdnv639uvj19+/mHaw8ZfjH8/vrxtxg7I4ugpZi4lq6srqweF89/dh6xqzxsnG9/isrK/+NhZWNhO/7vzfVbb27xMUr+5ZOwE+KSF/7ynpX5OeNnxj/MH798f/ruBed/ht/fGf4L/2JkYuFgZf3P9pPhH/O/P0zMrD/+fP//5Tvzt9///oOOW/ohzpsdbLHr2dM3D+/+ffH74/+fvKy8zKw/GUREOBmZuDm4eAT4//55/v7R7b/f/4hqa2a7uFwV/yDxgf3iuUuvX35n4WYTZ5Bh1GLTU5Fg0RT4+5P5/z+e338/s/37z/zv14O7T19c/f3q2YtzP2/z8Gm+Z/n7lPWeDoOoEI+kAC+H1Mf/Bn9U/jP85eXhFWIU/vX66VE14e9v3n//8eMLh4gU20e2v7+Yf3Peff/+1u9rnNy/mdgFfz578Zr3zct/P9n+sLEy/+Lg+vv9y5/v774z/weVQp/+/P318zMjH/eXR78+Pf/AKPVHXFNW6N5/Zn4eHj6un/94mP4y/ObgUvsvxsnDziQhx8THfe3+hWtH3lw9eo773UfmP2w8H3i5OHRYRRm+CnOws379Icj0V+jrn/8veX8oCQoI/H7PwvSLkYfxxx8GNqb/LEraqr6yfL+Zeb5+Fvz38/m37x8//njz6/s3xq9vf3798P/VQ2Y2kT+/GVm5//34zHPvx/MPrAzp+gIcvGrfv35+LfqMU0LoL+8XLhYJRTsJQylpdpG/zJysYl8Z/1zjYHj5W4xF7i/Hnz8C7AZCHFxsshzsf378fff3/d+PT3++fPX6x8sX3x99/fj36+f339mf/fv3gIf3Gzu/MB+76H9Wda6/7J9+P/nBxsf8k/Pf/49/P7z4+fD//1cMv4QEJJl4GHS+/3zNLyjwXvCj6FOud2/esb1kZ2Tm/cvwk5GNk4OZ/THrV46vvxn/fmP7/PvNy4efxb6+efPr+//PBmoat1mZ/7L/FWL7Jf2V597LW1KXfh3h+Sn3keMPu6iHsoGmvpC4hPhXdobPn75++v79x5+/7L9+/WLi+AnahvWZ7T/Lux/Pnl/9dfTYibePv378+v3r9/csfJwabByCkkx3/v4RFlTg+vHmxW+uK+yPhf4IqHxmPv3pjC6/yVeGvz+/vH8nx+j+S9xAXcHqx6twYZXPP5i2fnrw/d8PZU6eR2/uHH54lf3zZ3a2r4wczP++/frP8P8/098/P/4yMjAyM/5lZGP/8ec74+efnEw8f1g4eeUlYs2sNh288vn9+69P3nz585ORke0vJ9M/pm/f+RjZWRi4v/I//vr32Z1H3xl/6epJGXraPJZg+MXBw/CA6dfLnyI/GF//YWfRFeAVYGUR4/jHwPYflJe4Gb+w/eF79una8/33brO/+y39n/3715s8Pxi4OYVlWFl/vWO98/fTpe8P1LkVvvzgf8T6hpeBVYWJjZnvp9Qv7re/nr/+xvr3/0+Gr4yfv//49lzw9/cf/369/yLK9vwcz5ufH3/+/8jNwMzGycnCwCDIzc/C+Ofl53/f3v7/z/WR9+ePF8IfOX8JMr78++0D58ePTx8IfeZg+Mr15SfTny9Xrl84+ObBq6dfv718yyXCyffkz67jF198eSzGKszDyfuHTYr185vf35nFvv/7/Oe94Gsuxp98bJx8mqqiikIcXDI/dcTEGF4x/v31kYWTRUqS4/kvkZv/2X5+Z/j9m52LR+TfN56/399//s3IzfHyF7vI/Zdfn3768/PrH/a/74V/sbOy8/7y9Z9YFiAkL8/5gZP131/2l1xcqgw32d48Y/vEwsHC8uLP06csD5695mRg5DNi52bkFeMS4pVRZ/r94+c/HnYebq5/f/79/sH8+DfXw3/cjKLyQrzSHMI/ZJlYeH5xggbu/jPIcXLzcnBKizFzM/36z/BL6AvTbx7G39//ff/x7T/3jxvnmV7+eX1V4DPD238Cf/i/fbkjYqajIyBs8JeDj03ux++3cgyMn0RZtOWUH/98+Z3llaiKqfg/oR/3PrEzcj65cZZTVFxa+L+ftjKDpPgXZpYT7y8Zvmd9/uWvuqyalKqQHK+aoKQYw+e/X95+ZfjGwPrr3yd2Zh4WVgaWX6zv3+378PjRw89/zr158enbjz+Pfv/jZGBiEeCSZuIVlFHhd9bXevDkxL5Xv89/v/jh3o9Pfx/94hOT/c37kfHTs7evGL4LyXH/ExURuvH1xm4Gjqfff9vxSJoosXH+Eb336urbZwz3djy4+Owh6y/Gvz/+/OL8+5udif03CygF//vNyAjaJPeb+f9fhv/fGX4wfv3N8IdLSoZJ3EBn6Y7DV2++Zb166/PHH39/MnLzcTMw8f0WYPr//+s/RvZ/9x59+PKbi483XcUh1tHhgyQT06fv799//Prut6Co4H3WN+LSghLG/H+kfzMw/PrPwvHn2zu2L6Ls33/+ePn22t6PGx7fZXjx8T+X9Pcfby/eO/+e9/fPf1/lOWVefH4l/Ifz/d/nnzglPzy/fVuJS9RIwoGBnf0fww9G1q9MLzn+/ZLm5//Jy/D567vnZz78YX4p9I+Ti5PlL8//jyIsHDxsXzj+Pf/08u3rd39Z2f6J8X9X+M33WZz9y2dBKQ42xrf/eLjY77Ddun/j2vsvD+8+3XT4ytm9d45dvP73+49vX7+ycQoFWOqoaSo/e/eBm+XPb857f2QEWX78/cPOxSci9lroP8s3xrevQSPDHCL8/F94H/z/9ZWDjYGd21abm/mX8PUfP74+evHgN8+3nz9+fPn9/++PNz85//3++O+PHCvzAw4+MT52ZiZO7n+fWJ69/vHTWF9fSE9Nz1hGzPLHn9esH1gZOfnfPPrMe4b3++dfnOL8Pzj//rz/n0XwrbGBIevrvyLq0iK8jN8+/mNkfcv07wsnEyezFBOPpCCrpOpH9vf/nzF9Y3j7V46NlZXpq/737z9Evukys/Ey83ELMcuxikoK/mf+//cOG8Ofd/+YhH78//P9/beHPP+Y/om/4/744f3LTy9+PP3Bw/H+zg2Wv4zfBbmY+H/y/mH5zflTl0/59se3v5gYFESlPr69++XZg/8q/7j+8YrIyQrcfSbHb/1HmOv+g5OcP39JsQjs5n+sIKutIa8qJSPHyy348+unjx+///r68+Wn94xM/1lZ/v5kY/z65c/NF194n/88euj2h/vP/z1h/MbAyMX6S0qCXUqM/a/Uz5/sbAKvPr57LvDg3ym2l8J/2T/+v/v7weuXUgJSpx9f+CIgLMD47fpXpk+M7CIv/jy79f7k1ecsXJ+lGDX+C35UFpAUEP2nxSuyaffd169f/vzyhuMPG8O/33///mZl4eRg4vj5//ePvz84GTh/sP5k+sX4j5nl5/c37JxSLmYqntrqqy8cP3v52r/nTxnYfzIzs0uJC7DxyrD+/sHy8csbbg6md9/vPvnKwvbNysTQxE7jmcjHv69ePr79hO3nL4k/jKzf/8lKC0pLMTPycP/79/I/I+t/JsF/H39yfVD7/+PTi0OfnrOJ/n744cL7y0Lc2nwvvsn+FHn/+8lPTuErb09qvuK6/P2SBLuq9JfPv9//4BEVUxdnY/jBwfCN8w8D4wv+Z/w/Of/85vrwk0FJUIBf/j8Pu/wX1i/8r///es3/48sTzl88YvyMXEzvhT+Iszz8w8r48acAx+tPfx59ffzm679/HP94RFW1ZVgZuCWlBUS/Pfj04vt7Js6/zEz8jNyM//g4DGUk/rsIvnj0jeMvK8PLD7+5vn3l+vr96WfZTx+5uLn5PzPcvXH/4a2Xd6+9ufDoOvO9u6Yq4qxCcn85X6p8eiEixCH87TU7G/vH799YOAVYWd4x/f/39NeH31/4eDk+cjJ9Y/7x7hULF4eZnjQLLxfTq11Pjtz5vYefQe2jwF8uBgYm9ld/Of7/fcP8T4xJX15VyZAjQtPmzccLMnrKan8FpLiYBTn+C7LzsLHw/5X5zKrCyPuP7c+3H18/MX14devXVbZv3z79f/fr/00Whv9/OO/8/cX2/T0XE7PQ589y73kZBVl5uX/+Z2D8/obj1Z+f3z/9uv6ZSeIOw2cRmfesv368+sHxkZGNT/X//9+/WL+xfPv/m1Xkz/s/Qn84eX9+Zvkg/PnWt2/M/wTlFfm/CX189+jFL/anEqyi7P/ZfzAIcMr+f/r83z9hMx5NQ111cVURQT6enz//vnz65sv3X7+ZGfgZmH+ysPIIsLP+Yb789O6242dOnz7/+d2j/0xMDJw/uXnF+Pl55SRE+Ni/i/wSU//G/+Ltm9NMHyQFBA1MJAXffBMWVzLh5OViFOcWkdZi4Hn//434j//nHx8UE1IX/P2TW/TpOybuV//uWMhKi6goivFyahvLOav9mX309g8mTob/oJuEGfm4Wf7/Z2BgZGD8x8rCyfj/B9Ov38z//jP++8vCIfCT4aegqLiKsVqKgdnKSy+e37v79+Mf0L2on7+xcrL84uMVFOBTYWVn//X76+dfz57+4OLmSVQ3SzDw/MrF95nh35PHr1jucb97w3b973sZAVZRFam/2kxMDH9/f3rAKMr2/et9jj8MzO+/nDtx9df7v1J8Ij/+PuAXE2STFv36+T/n53fsv5UZObj/szN/5nihyafBIf337d8PL+UlGFi+s4n+5RD6IyonbSDH/53tL+vf90/+v/7x6fPP74zcH3kZvn35KfGJhVOK77+EgDiXspL8t0/vv3Ax/ef88+frb47PvPJCwjy/BJj/fRPlY3zLxCYpxOKqKycowm7Iqfnv//9PT59/+fPzz6efbKJSkQJWXMbiDD85RP8LCL9mFXrG9pv9x98vrF9eP3319ff1Hyzb3l8+//OyAwOvtQ73b8537199Y/zKz8zBK/rrr7Ao2xemDzxczDxsX/nZ+NnZuLh+/vvP8JnxJxPDb4ZX/4V51CQlGdl/373VcnTl4sPLWD7+4mVm+fXtJ+tnHo5ffAwCT7h/Clp95zIX4fvDI/Gd7R+/qKHk83fCgqJCfLqsP978+MTF+OcXL6Mo/xuu30yM/5je/mPjY/jI9enOhw9n333+8obxATPD2S8f7/358vs74z9W4d9KrHf//zT7LSzCw8LH+I+D6RfXf8Y/TP/fMrG8/Mgu9vLtC4UfjIxsHxnZv/y6x/CFieMLM8NPhh/c7/h+8r9j+cHIy/yN56cMC8dfXtYX758wPfr9ToSd5e4nfyvDvy9e3xR8KvCD+fMfVjENYVNpBUkpYR5W5m/v/7/9/P3nNwaG/x9ZmTi/Mv3l+vvn09ffd1+8enf27bf3jO9/3H8r+pHxBQvnD2Fm2Y+CnFyvBNm53/0UYfrFzcHy5AuLDOcXgScSv1le8osq8bN94eNSfPfio62MwLVHj///537H9Jv7BeMLxndSklzcfxQ5WX5/FRKQZOf8z874h134OdMdHW2r2xeObdzwLMjXn5+f+z/D/7/cLH9+/ATtVWVm/POXhZWJ9R8jAwsD498v3/9zs3798oNDWEpF90/gd4sllw7lCYjwaqtwsvP9+vXuNxPPL7avv1hEGVi+i3z69Jyb7ffjV2ISTCr6MmlfbaY/2cl5iOOJ9HON/2ICX0Vuyn1WEOV59/gLA+PP75zMDB9A3fKfH/+xMjH8fMx07Mctc01ZTh6eP8z/Pt/+zCL+49MX4f/PH76VFtdm4GJjZWdnZ3jFzMX4/4nI53/sbEwczExfWJi/Pv32iPc78ysORpZfH18zC4sIfWP9wf714wcmIcZPb9i5OL6ws7JKsP78/umrxE+Ov6wf3rKxMH1lZv/27PtnGS6epw++qKgrCLIxfmFg52X6KOMso8n5l5Gdn/nP299M7D+Y2L58eSsuxOcqKXn4w7WXf77d4mH9yfBF/y3XDb5vTGpCtrLqJm9fcfHoKnCzMvMw/uT88vu/9CfG24x/BZgZv4uIin7/9ZvxL8evT9/+czD9ZOR895eNm+ufABPXo9efv//6I22nLsTCt+nrxZ33zil+YuNl+M/GJvlT6ocUo/B3rk/cd0R+KH/lZ+C8z8v+4f0XpkdfP1r8lfom8omXj5eB4eOz0/yi8i/eX/3DxsLz/f87Zs4//75zi3B///XhF883tr+KTH+/sb3n/P7n259v/39zMkpfY/ou8ubTpY+MvyT5XjNycTF+/vj6Oxsn/y+2z/+/sLHyshxgvSHxkEdBnVdFUPkG433+93//cnF8/cX/U+I5/z3Gd2qgw0Q4v4kKfHr2T07mx/tXX//zvuC4y/lO2MNW4dqTp4qyQjzPX1+88dLOwkFVWpNHgZeHh/Xjj49fP/758vkTOzP7tz9M7KwsP3+9e/Px64t3vzdt2M/59df7zy8ZPn1n/sTHxssvJ/WVjVng279fTB9+SLEK3WL4cPn1r78s39g//ZFT/Hn28zdVDr7fXCzb398W//xHjE2O67e4IM+3jw/+yehoPvv0UlxQkfv3lzuc7JrPWf6LSvz4+0H42w8OZoUXbM9s+ARfc7B9//aK/xcPi7DAH1ZGDibOv79/MjEz/GT8z/KfgeHfv18MrAx/P///z8T1m/HH708M3MI6Jiws/DxzTx1OZ/77R1GNhZeLjZ2BmUP424cXvExc/4VYhN59/8r0+c1jJklpKXVzllC+51sfHhZ4/uuhkNi9O89U/7H/+f+PU+U/123+Z6+f/fkizMD8iYWfn/H9Lwa27y8/fzm1hkPVQfie4BMdCT0G5j9/BRlZ/zE84Lon+1ZLWPr/wx/ftXmkrqk8VLshfE7tE8PzD/L/ud8///zl5WdmTuZ/v5kYuP94G8mdFvx8Y8tDnk+8PJzibGzfOfllOW+/fcP+Q4VV+OWPrz+4vrB/+MUtw/6P5efvHxziSjxsX3+y/uRkU+PR5TCXZXzJziB7/dM1hmf/JQQ5v3z6+JmZ4+uzNxxiUg48/AclXkz4wsv4/d1/bmamz78kZWS5ONn/KzC9+sLygEOU9/PPn99+cnMzCDKJfGP+9fsfP8O3dxy84n/ev/vN9en7Pzb2nxwi/16/+MbBxPLhPxv7e0NeDQ7uN9+51l68oPWdh+Mvo7SwxqfvXx79Z/rz7d9bjl/SxvzMDAJflb8Y8Uq/e3Drnug3hpeiv2S/33ryROo/0w8W7iPnb3Oxf2HhYfwmxMnK+J2TmZFBkE/uHd/Tpzf+8/5m/c7868UPxn9MbMz/fn/7xcrE/vXNj38/JBn/f//J8FtcS5hTQvDHgW8/vr5mkWH/94WZhfmEwEfuTx/esb1Qvv5OmkOEW5KF8fc//g+f7r5lZBT4fu+tADfbW6E/31mY3196zSD398e1F38Y2E0khe6++36R543QtR8CIgLi8iLq6hJSfHzcokI//v768ujXt2+fGRgY/4GWEnH//vP1/w+ehceO8D3/8+XL6z8fv/wHNSaYhTlYhBl+snOIvmfg4Pz83EhJQkhL69SBDWzcDL8//md7/fmFqerHM3fecbAwCbHxvxX9rPBV6M2bLwI/GJ4xMQvyPXn/4sWXn59//pH4z/ZI7JvsHyG+n9Ic779e5/777P4nYznuXzKKj64+Erx17ywXlz+rOqOkwP8/DP9YWZi+/Qft+Wbg+MPK8P/Ht/+snEz/GN7zsnL/Yfj/4zcTL5eWtgL7l7cLDt3z+82qqaHwlU+A8/9vZkmxX2///Pr2iINHnPnvfxYmztcfn4qIqNga2f/9+WvvkTtCn19/+Mr+9P5fSRN+7q+8wtosTJe43jH9/PLyLwPXG04WbgY2RsYfLC/eP/3y4KPPH/mHsh9/vPkuzvZRSFTr29NTCtKsp/+8svwp+v//F/lvYjzS/BJ33zzm//H7G7eR+O83TLxnX9zhY+D9ycD0iP2JL7/eJf3Hny6wcgmwSQiKfvz+8js71+93TM+4PjDzCHKJ/+RgEGZhYxBhlxcXF/329SebMOeLF6zGwvxG6mbvWP4yvHv24oTYP/5nH29fZZJR5Hx//w2HIs+vH2ISgh3qet9ZXv58xs/OyvP147cvLMxf/r1l+Cv29/tT4Z9/P31l//uH+fPvnyxsjH//MH768vEv50/2/++ZGP/zMol+/fr1B+NfdlYWHpZ//7/9EbTWleYQ/3v7ds2lrdK/P31j5/nIwPiR9fsvFnahd39fcH2WfavIy/Kbi+PvNyFRfq5/THqCHDt/v9B8zvGCRUFW6Najly8+PxJ5xPGG6+8v7l9cDOK/WN68+8HE9OC/kLwYJ4sc87/P30S4mAQY/z5n/PPyD8cPhmdvvnMzyXHYfuT4LP769buvzz+8//SZ6e9vJi4Bho8///xkZPrNcPsj64vn31mes3zhuvpJgu3LY4bH4ozCfD94fn/89uDDjzMvvogwif39zHhD/SPjawFuSdkYFW1FFQVB4f+GDIxfWPmZv7C52trxisgKCPP8/fz36dNXX758/gNae8z4j5dB6B/jz58M+86dYntx89W7N3++sX76/vMvByMvFyuHFAe7jOR9ns//Wf+JCAnd+PjhyIvD3O8/MPxkY2Hk+GvI9e/kJ8GfbP8k/nD8ZmD+8ejPj39X3v188vrHL1HBTwxf/zzjtZWxUZcQ+viUzYVTnomB4diTm5/kWH6zMugrSP9jEHv++c7d/68e8/6WZ2A/ef8Z48uf/5g//mdn+Mn7j+0/Oxc7J/Of/8yCHGyMDFwM/yXevf3/4wcDFysDA2hZmKa+SpC70aYLN66cvvDz/cdfv/5xc/PwCLDwMfD9/vGf+dWH/39+fP/E/O7VR15+EU8zc+9Iz+eqzKJsnHzMYhznPvy58v0zF6+WlbyYjCQv67/fP37/+MP2++8XJobfbJzsvy4zHrn25O/HlxoyMtJMam+YHqpwav16etuOVfXdj+e/mX8x8Em+/v2Onf8fx2fhr19fv5UW5GcWYmPhfP/uw+8/rFLf+f+LMeSYWfJaMchxMH5hY1PkV3jz87sAJwuj/H+Wb0/4/4nJyMlL8/DwcfDxcrFIy/3/+ZNJXvLnl5dfb3+4ff/vu9lvnn2+//z/P2ZmaSUWjn+M7AoCTF9//fv34827F6/3fnz2+cuH388fvXvz/u/rl7f/fxf8++U+I4Pgly8/mVh+sLMzc/z59vML69cvn3lBmx85Pn3+8vHbv79//nz7+57hFwvr729MohLMZroCrGJfPn2eeu00J9eHX2+FmT/8+cX67t9/ZqGXTP///tRhFucTfsrJ+19CSob/z/8vL17//c79nekz30/V+ywvT5969uk5B/e1t9f/sH3+/J2RTZxD+g+PqAL3VylW/t8qv1g09RQ5JXj5eXhYzTmULUX5lLj+CrHwiIuIurLzS3K+k2XmZmD5wP6f5R43wz/mP5xvfzOzMPJwMf0X+cv5kffbmwd3T36++Oz1/VtfuX79f/GVkZ3ly/cfX7+zcXP/fMPwge3rj4+MVz/d4/5oKq/6Ufz3g68vmVlEZP5pisoJqWhpSUrxyYiJfPn369nrl38+/mb785uDmfMnNzsHD8fHv8yrtpx+/vjFi/fML9+/+Pbmx282FhZmVjFuTg0ent8c323UVPQlmT5K8r369unew2c/mPhZfvPKGHLzP2B4JPLiF+97Tha2Z58+f+F+z/mf+ZPgw+9v/r9+9Fb0w7+Xgl8+/L0qyqYoZs7E+o3r+RshDzEFGUYJ5T+i/GysHN8+Sf8VkdLmE/3CwvzjM9sPhidvX799fI/59Vu2/395/jB9+/jiz0+G/w8+Pbn9YPHDS8uv3wCd2v33D9OfP7/////OKaAgLxEX5LHz2sv7l+5wf3z788/f3wwMbFJibJz/v0mIs/79w/b649MHjx69eMbELWYuraZqJv2M+aca06+HTxi+3Prx+/HTVwwMwhoMMlL8bGJ8/398Z/onyMDMzszwjfnDr8cf3tza/fHLo5ffuX7yv2T4wfpZSFb/5/9XkrIWP/8J335yipmFxVJcSljxx3dmhn/vvj77/5blHwsXKxf7Cd9f2AABAABJREFUB657Lz79ffn96utLIaxmxgbKomK8F57e5/r5ikOKlfsR43ceXq6XrG84n/MJCDNy//vN+eP/uz/sDKA535uvnu09deXLuWeK919/+f7ny/dfrGzfmX+wsLMyMfz7+/fPf3Zhbv7fov9/Mv359ePv3z/M/79wMkh+ff+SnZGHkeEHIyMrB+N/dnY+bp533My//zPz8vJxcrNzcfIL/vv17eenbzxsgjwcH598Zv4mBDp76O+Tx3Nv7r3F9ujv77/MrN9+SDJzMnAw/WVgEP8j9EtUhO/vfyn131+ZBVnFmAS/CojL8P9gYxHk//P+Nd9/cXaufwqSv3m45MXlv8q4ysoJiP7hY5ZmElSw4NRWl//Czfj64d8vH5lZBH5zP5XkE5bgMxHnlGP7L8Apx8/7XpCX4ccndo4//66z/Gd5zyjNJiKixq7NwqTwgoX1qxjrP+a/7GwM397/Y2W89uaZvpDSXaGbX1l5Gf6/5RJjkVQSf/n57p+XYkwcnzy51T5/fr+V75XhD56rb7+yMvGFiFtJyPPyiAp/+/nj69d/TH+Z//z/zMsu/pkTdOrW7zf/9m+59vzpMxHWn99ffPrH8Ok3mwgrKx8vz28OFgEmHm5bGcWPn259+c/w698bKZafDG/53n34ziZ004jT7TbXl1c/OHjF+Zn+fGNkecXyU/7rtw8in1S+sj3i+sXBICH468O7k59fMAhLvZX6K8jJ+U7gxa3vf37+fanNK3Pu4RN2tl+SH4UsOcUZ5ZhmXb8Qxav46fbjCd9ecb45xuTMb/Bc8dfztxc/szG++fiL5YfQH2b2/58+/+aK1VdgEuJn/PKH8R/Df2E+EfavgUHmi7ftlmVw5OJ+zyzA85PhL58IK9N7xs+fvjL8+cP39cvrG3+ZDT+JsyqkK3tedLgxY8/+P+9+8bH/Y/sq++EP41dJJh0VsbePn7zj52H4+OWPwk/mZ0JM/Lwcn9+9+//j8LOndh+/vhflZuJj5vv9jYORg+npQ77/35XZNQTFFf79vKvHJvT6Lf+nb3dstW2//uL/8/DZL87PDz+y8p1+fZ+T+cGV645h4jqffj6X5v/1WpThxc+HP/4J/WJ8y/WK9T7bM72vCgwczJ+ZvjGzsrOyfHj2VpSH8+fH70/e3mT48UVaQ+rlnReMjByMf74x8Aj8e/rjjeh/yx9s37gFv/y7w8nCxfz/KxOH8Lcvv/78Y/r1h4vhz1d2Vqaff38xMrxjYpT5zfyQjVPs65fv/xmZWVjev/3+V5KPmZ2B4QcjH4uJitKfv8ve37h+5fQL5s8SnEqKrP9uav8Wfsn2jvnf92d/OHiZfgl8ufeDQ+rv63+8Ep/+ffnwh+Pz2w9//7Nwv2f9xP3yH8c/ESbGd/ff3hNm9ZLTkhNXfCj60eg/137mV+oCUgxMTE/+v/137QePJDfTD+b3v9/xvpb7+O6bII/YH4lfrz8zSPPy8/7/dfL3M3YuPhULrecvX/1m+CDJJ/vsz2+mPz8ZP/A+/iPw8tc3HuYfPxhY/zIz/xV7I/7l6U8mLnYW8b88fEqPGT7K24gEKahwsDHcE3pu/Y2D6RMLv4CQt5mdsrqkmLAE4/f/Hz///vnh078/f9k5RX8zfWdjZ2Fk+vXy2bvHXx/8ePXjxr3HH3if/P7Nzcn9WUpRgE9cmJn7j5Q477OfF67+Z7nK8OTzb8b7AgzfWD6x8TBzaxi+ePHyOS+PBNs3eW45AWZpJiG55yxPftzl/i3y5xcv57/ff5/xPhfjZNX4Jfpc6v2P90yMX55LsP59/P+j+Ls/154+Zf/y/8uLz4L8rH9ffWF6/iGaR+Hej1frHnwUe8zF8uAnw8pX57ffvPbgm8DXr7K8zFrCQlx8XBwCKg+P3+89f/fPmzcsPMygUvg7AxuHqJiIcISP95IL5z5ev/v3599/v/+9/8kmwsP8X0DiI+tPVj5GGc5/P99Kvfj0nZdNwEhDXlqLVVZTWFxc+N+nl1+/fOI49f3af3YGYTYhSfa/im//vWNn5Hr7i/0TF6MQ56/fL29+uPbg79fP9z9/ePSD5d/397++MjJ955NmYuG+feXadwlR1j9vuRj+fZBkF//D8lP2npyIuLAgJ/vnPw8fvfx0+NOL9/f2XX31R5DvDwevuSQHJ88PQRbmn8zfRXh5WP8x/Ln36gcXyz9mDjbQQab/WCW4/rAzMnG/u/Ltxz8RHpZPH0UVhT59+Mcsxvvh9advf///5P/GxcHK+fcf70/h3z+5Gdn/cLJzMjP8YmZg/Pnr938mHnYOLsa/DKz////8+Z31Nz/7v88ff71hZGD4z8AnzMv36+evVx8ZfykKyTH8+Pjj1467576+4+bjlRFhFRTnEDLkV+T7Lyj6i0uV5w/zF65HL1/8+czyhlPgD+OHz99ff3vO8JqF/RfnR25RNjY5/j8/WZh/fHnByi/16v/tJ28P/7z+i/HF27/Cin+/PWL6z/7l66v3b36K//vx/Of3jx852f4zsn3jEmJklWL+84/99zmmzze/3hNVZLVwZ9LjZWR4zakhyMTF9O7pe74foiwMPz6z/Rf+9/3LP7YfrN95GV7xfmT79FNEiPM76H42rt+fnj59pSVqqP6V++WfuzdF/8i84f7PwsXw75eTrK66khzb/3/fObm+P3v65cfvn7++cjPy/GH6w/b3x893v1iYeTffPfLx0sPvbIyM/5i4P8gw8LIriLJYySt9Yf/w7e0PYSGlj7+/fP72i4mFT+rvdx5e+Uc3n9/TeKfymevlp+c8zxk/Kf5l/fT1/ucXkgLScmKsNz+8/MbJJPqbnUvw29N7gpwS/2XVBR7dePGDR/L7P6aff97r8Goz/nzzkPOd4k9Ggb//9nN9envp9duvrxnZOP4+/icpwmChLXmTR/jusz+cbK/+sMqwc/37Jc/+4/5vZgFWhpfM/xnevbjJ/VxHTPzTey4B2d+/f3z59YWJhU2Kh8E7QGPV8dshCuKKnDwf2LjfsfwQYf7/T0SK6zvLH4bPn69feiv+iZ3NgFNWvNgtfIbs4cc3f3Cd/sHw/Qv3b+F/r378l2bnE+X/9VDm86tvf/7yCP7h+Cn4iEFMVuLBl3u/n0n85JLVlrj+9smf/68UtAx5nt55/eEbC6vI8xuPlAUNZBmuPbkn+EzlscAzsU8/X/7hlODkYvjB94j1N7PIPwnRN0wHvl7//IP31tcPiprmPx9e/vCN8+s/NiEbWenb75hffP2hziP4k+/X0+f/+QUZ/v2WFtGyUWK5/Y3l07+3rIz/hdh/fX74h5+X9dvv94wsEm94WJmZ3v368uPNP0Ger4IsjJ+YGX//Z/7H8v/7XxbOH7+/s3H8ZWBkZvj9m4mVkZuNg+2HFCvHv6+/GEW4/7/9/53RyEz49Ydb/79Mv75T7rcUi8wTTVbNu7+fn33H+pf1reh/NgYWDl4xYSlW5n/fpP4/ffP99z/ODwyX/35h+ff1w7OXPwU1+IU+fvr+RfIz94vvkkyCTwWYhZ+/fv//yxc2AUnBn29/iimosnKf+/mGmYuLleHf978s/wT+snFy/fjH8UuRhfkhM/O1D29//nm/+2u9hbRjgkL8DVbTb383sx3n+Sn68cn3X1+/MEoZG/z9ysz6k4mB5dd/jj9M/7jYWFjYpf8wvhL5JfbCXkLrjbCAPQ/v2z9vLv36zPeHhYOb9aMwm+1PSxM3BSF+gU/fvv34+fv9m09cvxh+Mf3+84+VlZXhzfcftx89v//w1NMb31/df/qLhY2B4ccfNmFZhq/qxmoKmhK/fjBIfP2+n/X77/9P5UTFOb/zfGX+yPrxz92v3159/28nqvDs46vL1578+sDHr/RdTFmI8fXTL2zKv57e+M7L+/8tg7gA9+P3H/l+//omJajOw/Xs808OTjYm1p8c4pK//v4T+MzIx/fp6gfG5xcfM3D/Y7nHzsDF/u/jTxaJLz/4JP6++8PJ9IOFRYqf4y+D2n+uN6LMDFy/vz34I83F9pSVkY3lmwBfspUuj8QPTjaFP/9AR5QwM/3j4mS5f/H2sl0nfHRk5XW0/4mxcP7lYPzH+Ofdl2ffH7J+5/jGwPDr5yd5OVlJKZ43v/9s+3r2x4Inm2VuSFxiFGCR/sP4hlFcgo+f8/b1Wz9ucPFx/eAW5PjLxPKP9cfHx19/swiz6r90E7dlFOR/yHtd8jErB4OIqqLop69sz35f+fWS9+07JjVe1kNfbnI9/c3OI8Mrwav24/ExUW7+2//5pVjvPHz19usXATFhTX5+VgmpQ8Kvy5iExPkUDr37Kvn9F2h9x8OnnzhFhVm+/vjMwC8rbWQqcevty08XnjMxsLP9+8IkIvH3zfsvP76zGYrY8XH+/PaT8/3XX2ysPz5/Z2f9/+UP28+v3zm4WTkY/jOzgG4F4uLhe/f1FyfDT1ZO3u9fPv/6/o2FT/Lf14efNbSUvrOf+Pdl+uGtzN8fcv2X5JDh/vCbg/HPJzE+sd/fPjMycjK++vdLlNH2t9Db7/+//vv2W+DXmw//Xn95ZqtscuXqbZavH59x/BT8JMn09fk3XUFRXlFxFv7n126xm0tq88k+YPr88cPn79+efP4j9uXvFe6PUj+fsHDp/v2vyqryWewNx0/O90x3Tj+Wfv/l/oOfLxh+88aKiDMzf73BwsDwn4XtB+Pzjz/esTDKqFkw/fz2lYGBS1HY2Enw2uE/X/7f4nvJ8/0P2y/mX+YpZoa/Of+yMZ5+8Vjq439eEdWv/N9cpDS1FAwYxRm/ff/59tO3X1/+/P7yhZGZiYWJlZGT5f/vb48uP9h67tqH5y/+v3v2goXnz7cvvIIivNz/1IQEfigL835/YSBn8vX79z1f7sh8Y+PkF/j/9/d9rm+yT3/f/vhTTpRHQODLo+tML7++/PWHU11HU5rr8/P3rK9/3Pn+l/8f36/vz5k/f3nKwswnysvLLMHA8Po3t5jk5/eveKR4pV8w3Fb4zc3AJ3yL6fzLb8IfHzKKs717zsPM9P8rIwPzm5+/pX8zfPnFzCX6j+UvCz8j/y85dg4mLpF//xgYGJn+//vJ9+fb3T/MShycH0PMrCTkBP4xMTP+Bd1Jy8HD+efL29vHriy59jpeg1Pa3pqVhePfn99MP0DzmD++/OL79/sXF+ND1i+6zGJsooIM/Pyst58cYL90fuvV+7ff/xdj4mIRFv3y+aMe37MDL/9+/M8q+VeQW5D13f93X358+83BxP5OUphLRVVHWvDfDxGJT08fqioZsTAw//jw+Mnzz/f+/1R8+fki++uv71nlf/FzGYoqfWd99vW5LLfEi19vbz5kEWT+9P3bh6d/+By9tawU/ptLa1y6+uzYNya+Lyz//31i+PNTQEjq1xcWRvGfL+78vGT+2u69wp+zT/hVJFlYfj7/winP+fP2i98qSv8txcW/fPvLysLCyPrm6zsWZja2l++/sv15y8kjAtrv+/8BC7MSG/NXDk6Or7///fvzlplBkOnvh78/37xUs+X6wc7w9WPJiZ3cP97wSwp9/veB75cEC9svtre/f8hwyH2TFOL9+fTFX2UJvndfvvAIcL9i+yPyjPHG08eSBopPztz6I8X1/S7rvzevmFj5f0l/UGPl4f0pcVnjrcxbXglxAeE//79zMZ96/+jRtSdCquJvH75lu/Xj98dvrPySv42+sjOLff/ymkdcVISJ+ePrO88OfPv7nf03xx82nu+Mv8V+/GHl+vWPQwp0FQPTH+YPP5nY2TiFJGV/qsgIuYRryPIocnMJ/Pj7Q0CC35aXi5Vd4sKzx/JskiJKUl8/8vJoCCiqKTIIc3z7/fPr67dPv3/+9/IVBycfAxvTf4YfrL//fmH99ejFh29v3//5wvGRQ4iN9RsLKyenxE9xUNj90hcW1BFUufvyzcUftwQE+T6wfX395oc4IzPrr9+X33978/n3F2Y2Dlapn5K8/wV51BWEON9/fffs618xll8cnwX+8Qr+4tf6+5WdR4rx2V9O1r/qwnxM34XfXv/E8YNDmllYQV1F6I/wx+evL364+ff9k+fsDJ8+/v/O8eOrHCPD748MXD+Yv/xg+cfD+PE9w+efjB8/vX378s+/j1+//Pj5gevvd27GD+/YVYTY/zJ8ese0eMcJ1h/f2JhYmDnY2dhYfn759o9dRN9EK85UefvtD9+ePGb4+ouBhYVVSFBYWFiUn+e3kOjf3ywM99kfvPv16fP7P78+fhcTNFC1zXQx95LV+PSBheHx6w///kp+UlTQ4xCWFGP+wPyV4S8HAyOzCCM7w09OBu7PH4SPP7556/yHd/ev8vzkfvbs3tOvHz4z/BDmk/j08N0XLhaOf/w/37K+Ynvz7MHVL5LCnLxcH3++4f/6R0VdmJFdSICPj/Xn91MHrom9/f/gAePZP2zcL79xc7LwcAnx87B//svw9+cbpi8MXIyfLI+yf7/5+Z+Q8L9f33/9YBFm+vWTm5PtP5MwA++XX/++M7z8xfD9zzduJpYfLEwM/BxMjMzijCzcLMzf+XhkeTlB+x9/fP/L/Ovr/38izL8YWJjE34jb8v/n//3jb8+9bX+YPqoJKzBwMv3gZPr04/Oz739/MAl++/OP6+s3Ri6uP6/+PH/+gukXx0vGP6yvf/7hY2MSYHt88vXb/y95rjNwi3/l5Pj67//Hr0+YP0jxnOG6LfOS693zb0fWXtm45src3bvvbX34/ws3563X/K/+M/xi+fD+z7tXH9hO/WN+9oLtmZQy/y8DCeFPzzh4eYQ5Bb4w//7H+Ers38eXbF/e/Of7/uflz3//nzP9+8vDyPqPk/nru6/8Z798u//m+TfGP795/4ryCEpwSLx5ce8V/xemf2855HkYBaRdrOSDpOx4BLi+/v/x9dPfb39ZhX+zcXJx/2T8xcHK8e3P9wcPn7248f7mzYdf3/x4//Xlj3/veJiEhPV/a8sZGKsoaMlI/P70b8P7I2+43zH8kWb4//MTI+M/QZZr/1+o/xQT+PGb+80vxt8cjJzsKrx/xJVYeUWEXvF8/sDzl/nVGxM5i6+8r7hFhd7I87G8+Mco+Z/hPxvjo3+cSkwcf99w87D942Z6xvxR8tvft+9//3rK/Jv929/Pf95++8z88zvDg+cMzP8YWNn/sQgzM37+x8LHwA4aIvj27+P75+/+/vrEyvLt649XPziFv3//zfD7P/8/hs+/GA8/eMj2/QsLJ/fP///+//v77+fnL1x8aoaafg566x7c/H3jPPunrwxMXJ85fv7hZ2cW/Pbh82cu1p9ifz79/MH77+EvVlYGzm8if+WE7awNpHlZ/zCBFrl+eXSTW1JWS5RdSJLz9w+mPwKMvN85Rfj+/xcT4uH5wPL678OfP59cYbzz7u23d7952N6/efn71p8LrOx/P3z5IcMtwMjHwPeXm/mD6NfLd6S/c337yX/8K/vt29e+cH5l4eIUYOP884l74ckrpfv2Xzx/XYib5dvLV7+//Pz4m4Xx71sGQTZ2fkF2RhZmDkZGiV8MP74xsjH/Z/31i4H11fvffxn/SbD+52Bn5eNk///1+x+WnyzM3P8ZXwgK8Any/Pv/5xsn02seWVUWIdD1Hb/+fP77n5Wb5fOf/1+uC3zg5+X78On1jfuXhZ9/V+IT/cD5g/n/H5avTN9Y/vL9/vWe7ZbYa55PCkzP3n37o/Tm2Xfmi+xPv954/ffbHxbGP995/r7jfvD1quQzhj8fbzz5Liv86/sn9s/sgo/fiTLzf3/8gf0Tw7sXb158+c/FwMguxGQuzsPDxMrDIMrKziMswS4kwsgr+Iv3M4e3AzsrO8O2J/cY/zIrsnEwCHCx8Yn843jJxCX4jx10euLn32///PjHKGFixfD+HTOLADPPJ0ZWvl9//gty8kjIfOf+JfiG/6uPms4PfuY/t14wmxvqc6nISMjwiTB+/8X46v1bho8MLIy/vv7+/Y+bme0P699/7878fflp+/sL9268fvXh/5fPP/8zsHIwKMpyc6qIyrGJCzL8F2TlPnHvzkMDdqM3kh9YbwjIqLLe+/RDSe7Om5vcH1nE+fhY/7C9+PVRiY/1Pvt/ftafbK9FPn//KiH698G770aCGteeXHry5QffWzZm0//3b/4R+ffxLw8Tt7Ss0g+Wa4I/WF9+4uPhefPg7Zs7335+ZvrD/+v3698s3Bw//7KxMLAz//vCxMHAyMHG+O0XAwPrn5+/fgn+YvjKw8H4hVdIg0ngL/8frr8SDKw87D/v/+Tj5Pzw7fsvRnZ7HTlXa90/vExMvzh//fjCwMb6n/Ev+9+vp/fe3PL4SoGxKau+CMs/QQkeofffPv148/zV1/dcP7i+MX1m/ccroqbIzfrlL4c42/uXT5493v7gzNNtfzl030gxCDNJi79h/Pn84SO2T4y8PwW+8D76/ZydmYOLU4yb4dXv93/f/2L+wfCbn19dQJOZ4xnDi+/skvy/mH4yvXx3j5Xv6+uXrGw/PjAq8DL/EmJ6+eQ9H5OwiBDjg7//GT+9URBXu6vxtV5Qj42Ta8e9F//+MTL++cv485uirC6HMDPD/+/3GH6L//j7lJFB8Rc3oxD73at3uRmYf3D8V1eU0JLg4fj1iOGvAMNvrt+/Xv9hl2T5/4Pp39sf3xl/MAtLiAmxS3D8Yvz3+8WjD89YOFk+/fzN+V5BWoCT5fM7hrKrqzVe/3jP+U+ITeTG7yfqf+R+ffnznuPjXy42JvZ/HL+/sHNLCH3lEBfk4//x+cPHnz//MP7l5/zBwPT72fvnXz/8+v6LneMLw3/p/z//ff7zkvWXIC/Hpze8nP9Pf/nNzPb5/zspU255eQnBp3+ff+Z48evTlyc//kt84vzBzsvO/Zf5+z8hLj7597/vydx58FLkxe+3/9j+cDzk/S/z9Q8X+4+3LBpMvBICXz8y/rr2iYVTlYH/Cu9fRkFuNsH3v74Lsf7jZ2cPUNN/xcRz7t11np+8N5995pFUsec2UFHmZWfj+vf955uvH/78ZGL49eMbJxMbO7cQK+ubrw++fWQT+Mp1/PrFX19eM//8Cxrq+vZLVELRXI372defwuwM71gZT79+8FvmD9eTfz9Fn6oIyH9jY5UQUf7HyCTGq/GD6TG3ACsPj4zaY8EXPxg0f/74LsjBx/3tzc97//7IfOFlu/vt7tN/TJ/fvftnIuHAJ/WO9eXbDzySMmLsd1++tJC3eMf2S57/5J0XTy9xsTB9+an49+9TFgahLz//sjAxf/vB9IMTtDeGneUbEyPL/9+g0z4Z/v74wfSf79dvzm8fnrEyi/4X//njHR8jw6fffHw/P/5m5xJm//9835X7QoxcRnbq/zn+sv7n+fv/x7+/f39wMVu5GTCc4Fty/2Iim+Yfee73zF//cv9k/S3Oz8L9h/kNL48026cfX/+95/3MwszxgYGHV1BbIp3Vocxn1d/DQl85Pn1l+PKdR1CTU+rdr0+/vjBLMIp8F+L88undw/dvlRk4ODlYQBsmPn59dprhqzAzM/PXf2LPtSW0z91+JMkv+IXj4//v7FzCf14zsbC8+vDrz/ffTGyf/nAIcP7k+ieiYyxlryulyyHynovFkVf887NH52984HFXYn76h4OV+z/rf7mPHPzfX4BuYf3wmOPTT7EPn/79/8EsyWylqMbJxPXms8D/fywMv9/9+MN++/dFWQYlHlY+dk4GfgERFv5Pn35zcLMzsEiIMX589//Tu6eiJryM3M8f3j//84nI529/WJiZ/zF8Zvkp9I2f4ceHn0J//jH9NOWVv//p5gdmTs7PX3/++P+S9ecDdkZDcYk3LN9fXHvz5/dPXkFudX75N88+MfIKs75ie8v4TPA300vR3xxv2QVecj3884KJ7YucvxI7Fyfv879Xvv37//79x2ffJbi+inBIP/v3k/Uj2yer/0Fy6kd+vP7GyaTxnesR03uW729ZGSX/8HD++/uEWYrfQF+Ml5fr7J3P/MZCLBL/eJ4KvJNn/sTCxczyk/mHAIcsKx+DsDDfw4ffP/0+x/mQmUv2kwyfthovIzv7h8/f/337/O/jn38/PjAwcbD8/MfAzfT5w+vtH+69PvX11/37T9+/Z/7F8l36F+f7X2ISzGK8/89+fSTJIPzy76t7Vz681mLmevKXW1ngzftPn//wirG8/CrC9Z2Zhffbr9dS8n/u3f8g+pbh+5/HYl9Zfn3jvsp2l/+DMJ/hq4+3eAQkn71+wM3KJSEo+OXpz2cffsuK/7rzllX4/qfPWoxs736cf3aL4aXgs9MffzMx////78/rL39Z/7L8lWT88eqXLAvLU/7fwp/ZP0sygmr1hyxsoox/Gf4KfeZ8wf6X/9+XPx/ZQNdW/+YXZWJ5wc7B/O+L4CvOdzyMnH+4/vPuPvOQW5xb01D6N+jO7r+MTEws37m+M/6xMFfi2PS05ciphp8/vmppMf/4zfSXgYuV+begKMO/v//FRFlffnjD9o+Ni0WQj4/1r8hnZZZqjsSGT4seH/n2l4GR/RXDHRk+vi+fGYXZOTi5P715+5ORjekt03cuDjE1SY4rz78y/nj/54XwX2l2Nvnv/F8/vXz39iMLn/A3LmE+hXs8X1hfsjH//ckuzsgo8JuJ4cf/n0ZcAs8VueQkJZUZ5B78/f71O6sEx3dBA3k5PoYP/PIvb177/uIGw58fYv9+/+Dm/vXys4AQJ9uPH5ysHM+/i9vLiHH8Z/rw6jUzu+DXD684uVlZvnw24pH7/5f528/vf//+Z+P4zMwlyPfpF+Nf5u+Mv39//fxIxIhDgJfn34/qK6u5mfkEPzG/EuIV4PokxMz06Nevt7/+/PjDwfXn+8sfD3l5Jd58ePWLV4Tl7/2ft3l+8AveE374+xe/vKQUB/vfG3/eanziFFX/deLpTwHWf6+fMwjL8sn943n/7TP71//cClyiMlIa3Hz8XzguCTLK3v7zWfGdJpPYTfYPbwwYLP+Ln/xwj+Ev9wvm90y/eYW+X/3FKveH7Rkj3x/Wd7xf37/h4JGRtGZ7zv7/EQunoQSj8DsOpi9/efglJFllhX4zsAjwCf4UZuAQ4Pj7/ectrp9PWFkeiAq66BhGypuzsnL//vn719dP799/+83wm4mZi5nxz2+G738/f/n4i+Hu0Z+vztx69+bRX1Z+hv9vhH4I8UpwcwkK/hb7Kaek+ZPp562r396oMxr8FGFV5mJ49vLHH+6fHxlZuUXvPb37+zsj8/8/It+//OGW+vLg492fT6V/Mf07/eEW7+P/f/gf37nJ9E2I99c/CRHRf9+/fRFRZGD49Pzbr+ffGb/yfnsi/5uZR+Tru188Mjq3H/38++039783jOwSTO/5Wdg5mRgYmP6ysz9mY2HiYnrF9JvtNcPPV3/4WJl///rN/JfvsRQ7FzMrAyPzpx///3/6/OLHyxePvvJ9/c/4keuz0E+u9/++sP79eZeF/f/8G9ffXHzIwP6VkYOD8T/o8q1/f5n/cPCZepr682oueHqP8+X7f0z//3CyMrJycrLysHKwCXGw/ufiYP3NzPjl3/tPH9n+/Gb4zcMtxJppZ/TZVJ73D++/zx9+P3/3XY2Djfc3k9iPX7xMv79zmguLM4v/Z+D4KiElySfMysWn+on7h5KKqCwTz5uPP7j+sn++y/Tq3x8ePkZ2Jl5mLslvIp8ZuH9LcTAr8vP8UPrsoaWhzCfH8P/T719srN+YfnBysvznYlWQkhXhVDDU4uQVZnrP/ObLO4Zv7P95uP59/vvh89+HTH80dIXEFITefbz75+//rx9fg45k/8fMzCXw/ScHI8c3Zkbmf//ZX774/fPd1x9Mn39++/Tjzqengqq8/Owcv77NeXH+x8/nvDyiHyX/SzP+Y2EREGUU4mbkZ5XkFvnH/ovp/9s/v1++Zfr3FXQg2ks+hidCX99yXvvw9+erq++Zvn/iYPn568qv89+/nrv9gfHW47dP3vyV+sfHycb7l/vH718vpZ7LivNzKYud+ffhy4MP306+u8Ly+OdThu9CXyQk5QR+s/ziZtPmVNER5Hj+/c/3N89ZnnC9//uSkZnz3xO+X+wfWfg5pdUYtAUF7b/J6j75/UyQ6ybbayZPU3FBNQZ5fonvzHy8rGy+aqrybMy/RLgNFIy6nSKsTDU05MTlJYW+fPzw+tOPTz/+8nBw/2dlZmT8w8jI+OLd2y2vb7++euv32xuff376+VOGiek9Ay+vvASjgAjDz09sQp/+/nr6+T7Lr0fM33n/sv379+P7fwZpDfl/bLxv2K8w/eNgEWRlff7pBzPrx8d/nz978f0vk7Dg35/Pvv6SF+T5xfCb48vn338+iH759u0pl5ywsqDit78vv7OJivz4LPb1H+t/VvaPf1R+sDDIcJr/4pNS4mZk//eTke87w0NGLkaGf//+cnxg5mf+y87z7+eX/9y8TJ9lvrF/4maQ/8728T/vjz9C37/9e/Lv+xdOVqG/b98yMP1g/sL84QHbDw6WP19ecwoI/eL9z8kj/Z/hK9PtV8uOPPj2+isr27//7MyMv34z/fr7++u3r7w8Dr463P9kjr59IfDoJc/Pfz+Zv//5Dbrg+PPPr2xs/5mY///7xfyN6fH/739Z2f785RMUFzBrt/MOcbblNJZlFPj37zsDz8ev735yaSqJswv9fC3IacCjzPXuzxuen+wsXL8YXrP9kRAU/C/LKvHh13fmv28+/n4vdI/99d8HrPJ8fNyson9lfjOx84lx8StJmfEacP/5//bXx2/v/rD++Mrz6xMTMzPj738fGYQ//ub7z8Era6T/T1rkNyPvl7/vWZj//2Jke/KNh1dBVUqE4/eX/39+/f/2/S/D//8/fn//+f034z/Quuhfn0Hbjf79fPPv6+PXL6+/P//87q03z0SURHlY/v7+2XjqwPNrh43l7L5+eyXGLfmB85vU31833r5jFvghyfCTSfSPJIu8mJAYB89PPqHPXB+4+Vk4uMREOd+I3z38/d2r12evXrt27y3T3ze/Xrx+/frPS6Y/P37++vvt+4NHH94+vPPrLy8L728jfaUf/xlFP3x+8Vnwy583ii//ff3NdOnD61e3bz979/bpyx9vuECx9OkXE+uvzx/+/mf4+ObHe9Zf3AwM//9wWP2yFBTj+MvymeUdryTrvz+/P7B9Ztr+/56ctJSYDNMvIUY2BX5VHjlRXa2/3/4++HHpjRSru6QOtzD/zy9f3n5j+Pj2EdtfBmZGhr+c//8zMXz9+2Hv8Us31t3ae/Hu65fvGZn+fRV49Yvzv4GKrpSovDyPuqWKAIcyx4v33/jv/eVn//2d4feNX094fvA/e/zjm+AHHSYjxo+veQWUuLl+/WD7Ji7EeFfwBuPXd28+fGeSFdFg4dZXsmR+8JdflFuAlVFBXI39ITO3NJfyX0ZZTrYvSqxsUrz/v/B94mK9xcMkziu65sreX/fYFcREhfhFuVg4WJn/MPBwsP9h/vaDg43x80/JL79/vf7x9QbrV/HfjM9Zv/0FHb/x4zcTozwzy//vjL8YmTiZmNkZ/vz6+eXVx38vPipy/3j7nO3nvz/c/398/8LJxv78xZ1Np558+P6Zjf37f06+/8yM7Mwsf38zfuZkz7DUuvfi3fk7j3+/evnvB+M/ht/MjIw/////9Z/1lzAr589vf57wvPvy+/sXpv8/vrD/4fnM/VBZUclb3IxBloXjE8NLNs4f/9g4PnNy/fv77u37s2+f33r78tvzj7+ZmTk5fvHI/eBhkxTjAJ/tx8smxMn+8dffvwyinD/4f3/99/LrS6mf4n8VeLSVJJWkhNj//v/zm/0rK9MfVt4/P/+yf/v24S/z779vP315z/Dv1x8RLk1zMy553V+v3rG++f6GlUNNXtFUiOvrl69vP7/89YuPiZmFGVQ7cTKxcv75+Y4FdDUYByvrbyYWUJXFxSD0+R/DT1FRTtbvP758rnuyluXtN/lPIuysXOYyev8+PRfglHrB9E+cg/U7K/vXn9wf//9j/vHl/Z/vnzkevf/CxyL6k/M3K9ed7+8evvzy5fWb989ePv955frT15//veL7JPTtF784828edo6nTP/eMb0V/czF9VTpu9jO//f1uf9JfhX7//7bf4bv/4XE2Dg/MjLx/1P4J8HH80OA6a8A8+1/P7g//2Jk5f3568c3BqY/HF85GZlFLbiEBTU+Cv699vHrxT9cv3/8FvzF8/cLJ1OCtk2ghhG/oKGunoQFnwgnI+un/+wc739YCJmpcoqKMHN9/fjv2/cv/z7/4PzJ8uPH18/f34L2BDFx3n5zmfk93/8fd949efrnF8OP3394/kjx/+J88OnUQ8b/wlyf+Rl+f/vw97/Q5++Cf7hlxDgesLCzygr/+iCnJKrw8Z+gENeD/495fjKcZHhw9+LDu/cfS74X+8TGycjD8fvBo7sM7378v/dTgfHfu1/sD3nYOVi/ffx8/e/db0z//vzn4xQS+vDsl4IymzG/DM+jL/uun7/96t+929e+/fj3QfTdn58/2P6z///29Ss7aBnQ12+M7I+4mDmFGHklfv57/+c7yy9eUeZfbxl+8XznvPL7L+9fVmY2RuY/rD9/fPn368ubf0+Zf1778+/z168svL9fvWXg5Pj7568AJ+/tM5ennrvw8+NfBpa3LOw8v379ZP78m+EP0ydp/jQ9jYMif86evc345DnH/5//2L9yMnGwM7Jw/OVg42fl+Pv/x4cPP76+YHn178fvt0wsCv9+/VUSE0hS82LjZ2L7zsHx6MUNgQ8cfLw/2f8zfvzF91fy35/fv/n/qgop6rCLfv7/+vyT1394WAR5BZhZeH9yvP795edP1nfPGG9z8kn8FGWwE1FXERX6yfH/rzQ3G9Mvod9/WFgZvnFyvf/7/+evbzyMolz/mL7//8XwifGnwC9FPRlOFqnb/1hk1eVM1ZlY+H5+Zxfi4RBn/PePk4uBg+Xvf1Z2dg4uhv///jMzsDAx/f7169+/f/+Y2H6+Z/yiryAnLvif4duUx0f5nrDrs/76pSLJ+Ifx/I/rOgLa//+913jPKykowPmD6dufr9zf2b9z/1T4zyL9XlJZTvrp10e/fjI+ev/t+9/vnG9/M3Cz/Pz689vTd0xfGdmfsn+Q/838gYX52zshHg4JAQYuPllGecGPun94mfm/X35/6yz3Q45H/76xfWb7+cmcIdBOxVZT57fEP01eDrZ3H8U+s75/+p7nFzs3CyMHH48gA7ekMoegIp/UV87LfD+Zuf6afv5x9N837j8/2B9/Y7rx4v7HV4xC/OymLNK/eEU3fbl48/cTOTV5IXU1IX6OHx/+vP7+8c2XT////f7GxAy6CPzX3wMf7r//8OHj0y+P7z/98uXb068/GL7/5hfgFeZ/LC8h9uuLBC/fc7Z/Aqf42Lgl+bl5/6vJKf3+9+ctwxsRRk42CY7vPz5xC8v++f/9h4DM9bN7eF4KvONm5JfmEP8u9Ev4Mxej8KOfP3l/Mry7/u3zHxYOYYHvPD+eP3zy/9f/39+Y+MTFpaVkGK9/kVeTVTIUf6/EwSD/X0tcWFVYhldc5N3n10xPmL9z/PvJyvOPkZH1K+cXdiYOdt7f/D+Zv7Ow/v7F+o//588vTEyff73595fj7/834r8/f2T4/fvrn7e/P79iYGFlYmL5+fbH/zcvvjD++f/+7T82Zoa/LP95fv7mEGdl+fLl9O+tD6/yfP7FwMbw9/9/JqZ/LMzsv38x/JGULlK0OiDzafGuix9v3fn17w8DA+NfLoaff76+ZfjOx8LG+ucP8/OvH//8+P+TkfH729/czN/FmERZ+VxMdJlZGL9++cB6+6+gJLM2lyQzBy+XOLeqiCzrpz//WD9d+sR69urLf4zf+QVY/nP/4BNmFf8vwcomLsws5KhrHG2grukpLsz87xMz+18WXn4mHoafv74w/P/7958Y37/nouz3f/75+e8XE8M/BkZGtl8//zKwMfDJiBiqqklxynLzvHrzg+n3D85/P379+sXA8u3nN8YvoN12fxl+fmBj5//xg+3Lzzds7DxczH9efmd5qyij/k/ww88vtU9O/PvwSoztj5iioCob47ev7/g+SXxj/m32X/Kv0H92NnYNEWFpJg7++6zsbHyPvrO95Pyu+J9F+Cv7+yM//tz5zPj6z19OZuaPzP/+MjOIcEpxMrPrsQt8+fX1+Y93rIKPP/56K8nM+ffnP2UWDjY+/n1Pzjz4Cxqh4WWX91Fh1GDgfPv/xte3X/h5/nGKP/j+5uNfBiZm1j+fmB6wvuHh5v7J9J9RhoWBW4ifVfy/8H/djyyKfNInhZgMRKVYP33/8YeJyVHcnfHzz88vHjJ//PGTk0mXV9NRQUdMXklUiP3H718fP377/+mLwD/OXyxMDOysrG/es3779f3b32c3Hxy6dPXTz5c/PnEwMzMw/ZXSVeSVkdH8J8Jioyyhx6Z/5uWbj2/efb72+8cfoX/soFPLuNgkeL///sLOx/aBiZv555vP//79eMssDDoqmU+U/9W9H39kPih9YX/2+sUXJu6fTF9eM37k/8rKz/NZTEzmAyubkBSDmbCx2G9eDpYP0hLcPMycin84WDnYVYQkPv/6+Vfgt5ioIBsfB+v/f2ycXH8ZPvz/zsfy9T/LN+Y/vK+Zv3P8YfjEwPKOiYGBnZ2X4fv7v2z/GFh+sjH//MP54zszy3deFtZfMgx/3jKwcDBwfP/+n+H3b1YG1j//fv/5+vcL+2+uf8yPmNjZOf88vbj93aFbLxhZn3Cxc//mYP/N9Jv169/f3Fx/JMUK1Y1Z1XjP3nwp+OgDIzM78z8mFiZmBma+/1zsXLws/8QkGf7+/vOHkf87O6iN/BtUCEp/5bO11RZQU/jAxMr8/tcPYZY/vC//vX/9+Pf3zwKcXBxif96/Y/31i/07kzCzooqQJivHbzZBfm7W3xdu33l399mv7z9N/6ky83D9+ffvzx8W5p/fWVnZPn18//7fvxc/BM34RGxVpFmYOf4w8vD9+vv7FwPH54/ff/1iU1PRsHXm/P38o7D8m2+CfOw/2RhZWRgYGP7/YmDlZPjL+uv3529//nKw/uJiF/r/7fnvP78ZFJV4OPhe/Pxb+Xwr340XP5mFnvx8ffrPv9u/v79l/fHmz7tbb1/v5rnzju3Pm3f3mDmYv/CwMsv+efnzORc/638+xq+fPt37+f7zm+fMDN9Z/gv85Pv2n42PnfEvy3fO15x//l/4y/yR6wf7z99/mbmVvvL//fKXm4339T+BpyzXX/zn/vzDQEVcUZntP9t3NhYhfVHZ/7z/v/38avJagusaA8ttrif3HjJ/4+b88JuD+Rs3D9uvL/9efX3Bee3X44/XWD9yP/jzQeXnP5n3v3+/+sP8i52Jn4NBTkVaXU5KWFVLillATUFbTkpRRICX8TvHm88fvnz7xvTnz2cmph9/3gp8+7Gd/fWn/38MvvJuu3GS6d6P35yM/7iYOQT/yop9+iMi8+ovk7Ia02vBh+ff3PjDySL27cdHvnfiwqJfWH4qsAi/4H71mfG7xJ9fb9ne3H39QISH+w/bVy1eOQ5Oto9M397//vn27/87TN95v//8yfNCWFDwy3tJFr6nbCxC796843/3/j07AxPD51ff351+eolFgOfLvzcf//259erd0pe3Xtx58fHqr3+PP35j+PeO9RPr079MX9gYRL5+42di/s3869VvJm72f5/Zf4sw/mP8/vfPf0ZG0f8MPN8+f//2l4NDXUUziF9ISOM728N/nP////zx//e/f/+/vX/97e/rj79ZfzOzMvz48Zflw19GZr6/LL9YGH5tPXz57VMOZsYfTIzMv35/YWRl/vH53a9fjCyCUvHWOhfVmRbtOv7p3Lm/378xMHOz/2H+zvrnH8dvPg5mFiZ2hr/fPzCz/WT/Kczwj5GD848wn+QvBl0JTS95bkYZnuf/XjExMPOw8on8/S7/h+OXwD8udqZ/LL//cbO++viMi4Hx5c8fL589es344d/ff+effT9269Gzzy+Zv77hZWD6+/fXy1ff379/9ZVbUvDHz/+MDH94uDhEJBg4WNiYf/5gE/3B9PfbX4E/Xz7+Z/j9no3pm7ShDMM7LlbWl985f/79ys4GchvD35////389Okby5+/7NxCbHz/XvCov5Ix52P8zf7u7dz7OzgfPzfmF2T+8Jn51x/WryyvPv969+Ut2z+Gb2zvjT9pfPj57/Pfv+8/P1cTEOAWEeRg4vzH9dfirdD1r+//nGL5wyjIxMv9l+E705f//7k+/2b49fvzv3s3X9x8e+fuqzc/OL+LCbxT0FKQNNT5wfWJ6bnAiwtf/v74+eff//eSTE+YOW8/e8nHyMYgzPlTgO/S88vXHt5/yfT/k/oHKSaRb6wvBe8yvOLnYOf8LsIj8Ocv080vbznfCn4TYTb7wvP678c9R+6cu/3my7dfTLf/f/jw4Q8HP6+QIL+4opyYmIggC/OP3/8e/3j79ft3Dpbfv1i5f3378u/3/xfM378c+7Dl1vkth078ufPyzU9BpufvOIXYdHklefSlv/x/ocv1Xfij5uNvzM+f/ebi+sDMzfT1HRP7z6d//vxjYeYX+M/6l5OH+etvRhY5NT7FX5+/KDKqf+VmZ2QVNvvF85vn578PrELffr768IXnvMSjV/e+sz1i51Dh52Z/yvjyrxjzq68Mj5/cfc3wV+m39JPXzL9+fHpy6yPr/Tf8h39+u/v7H9v3l0wf/777z/iP9Y8U81+WvyyPf7B+5vwp+oGLVfTf73+MUj//vxX4LvSJiZHjjyjLv+9MLAzcLJwMzsZWKcZJonwiTD85/3/lYeNn+sHy+x8jO+vPt19+8TJ++P+Lkfk3859fhr8//+Vl+8HNxfmL4+OfKYcOfHn9joXtPzsb/18mNt7vf/99/fznFzMDJ2eOmus7afFll658f/L2+/eX/7hYediE/zKLff/77zvzX/Zff//8/fn3/Z+vX79xMvLxMrP+EWPjExOSk1W04lexl1FSkxJiF2BmFeJklvjP8vmnAMs/Tg6WN5xMwozfn3z4yPadg4VdkPPbWxkWYSF+/hdvnu06dvfsjffff79h/fDzHzPbZ3ZmUV5GBl6u/wzf71+8ff/uvW+/PvxjYhHm/crCyin8+x8zKwcDA6vwT+afbKx/ODn5GZkYf35k+PeP7b/4T87/LKw837//ev1V+Ount5+/vOZhF2ISEpJk+Pfo353jzy+9PvOQ5Zv41bdfeIR+i3DKgvamvWaTE9Lg/PJL/YcIKwPjj5+/vjPw/nny+x7DB4WPrCocgl++PLr8/NXdXT/Y/3D9Z3z35+0XJnaOfxy8zF///WZmYPn/hfkHB+u7jyz//gsISMoog5YTc71klLvH/+bd2c8Mn9mZWf9KvPvw+R/T5zci7KKvBR4/Y3v3+vlnpivcr159YJRilv/BIqorxPWP881/Jo4P/4RlFMRZfwrx8L7++4Xp958XLz+suH7v0inGB0/ev/v57c/v/4yrd6z///EdA6PgP54vskLyLEKMjL9ZPn/8BYqX/9/+ff/F/Jf778cnH7m5vn/4tWfb9sev/n/kecnynvXnXwbWn78F+VjVVORefv9rrCYjxM495/kp/j9vGV7Kc/I9YX0l/o7vpwLb71+qCoLf3v/9o8jy9bG8kspP5i93P7z8zfWd6cNPISaOf+KSr17eUWYRe/39N9OvX3c/fH76/q3AH96ffN8lJTh5+Dn//xbm+/WN5SeTpIQ0BzsH+/sfBznf6rAKnT93/SXjH6733/8xq//9c/b7b87fb/7/Zvv599sfRjb+n/w/2Z+z/Gf9zcrE8of5L9Mnll/CP5jesf7h+c7IzPmX7Q3jE45fXOJKOpLiAhxX7r748foRxw92Zjam/+xsf7+zM/IwMv1hZWb4LCguzszxg5VZ4C8D51+WX3zMPD8//f7+75uynGqQn4qQoNyXH////fvE9puV+e/3X5ysLCysnO8+L71y4vXVV5GWpmx6KuzffvxkZ2L98Yfh7/effxjY/7L9YmBi4/j/nvm+8C/lf1/fvmL9wfeDl4GV+fP3DwJcvM9ef2b78OTBt78v/75m/y/++POTd59/cPxmkBYRvsjwVuEu409Bnn+f3/38yyGmLvjmzmMOOTGJ/1yiCuqaauysP7l+/+XiEWVj+P6T/Q/L77+///H+YWcW+8P47e/773+5GBj+/eViZGFk5v737+NXJh6BN8/5f79785+Hh/EXNxvDXwbmdx+/Pnz/W4TxHSsX/19tI4aX9x7/fbfh/U2zP/w337z8+ZXz7zeWPyrfODn4pb8K3Px6XIZf8flHZkFWhl+cP6V+Cnxh/CEjIHzp3ccvvA/MWXSv3bh3+/KPn++eMXOy//7LxvLvO+s/9p+/WBk5GX8zvWf5LfSb4Re7oLCW0DcubbmP/7/z3GUFrVp9wHr/8Uth1v/fBP8psPHdd/4r+IGHTZhVilnsyYtnz8//+/fmqyDXr+9mQjGyap8/fFr/8Tn73R86Qpw/WX4xfhF5+vPz2//vGX+ATib/dZ2L5ddLRia2//K/mV5xskhwsP/5xfeKgZmfmZudl/3Plz9fPn//8f8PI8c/hn9/Of8wvPv67Ssj7567137d/3zt6TeOz9/Zf///wvlc8qc6O+8rBja5px+eG5pY3X53iu2zJOMbhv9ff/1me//79X9Bxg8MP3mkFfgFROT/vmHnEv/385var/dvPrEzs/1lUmFXesr36BunyKfrT9SU1M+9u/qXg/mPILfIg7+/pWW/Xv0qIccnKyHI8PEPB7PQvb/3lRUs2P//uff1triAjuTbLz/Y3rz99PcTy5vvb7j5OR59YxD8/uMvI9Ofv2wsf77xsn75xPSLj/XPs7/Cwgw//rP/4fwu9I75Fcd/tn+/Of9wfPj9/7skE+8vlm+f75x+8YiZgeEv83/Qgm5mpj+sv9kYfom8FXyj+Jv987f/vEzv/vNJsjL/Z/jz+90/BqE/3z/+5vjB8Uv8/r1bC8+yZ5j+ZWMV//OX+++/b39Z2Jn+s//5/vMbG5eXtvLW25/2nrrqJsn7k1fgP8NvJiaOP6xMTD/e/2DlFvrx/gsTP89/lVe8P0U/MfAz839l/sLyj5mFm5f1F5OwrMT7P88/f2D+8JJfXPG/HhvvC0bRB69evfj9S/4zI7OcgNCvj38UpSX/c/x4/f2jMA/b078f/n/4zvDCiEuYTV3u3z8G9g+fvzEwvP/3jZ2LWZRD4Ne3rz/+MjF9+/7py3sRRt7vghz/GX7yfGVgZv3yUYCX5dUfAebfv359/cTIwfD/Iwc7jw4f8wsmub8SskzP33ZcPyPG9lniN/srxl/v+CW5f/9hF3zxjVVI/cO/uyxPpASMX/98JcTD/onhD89/8Q88XwWYOU48/P6H74Eou+zvB/+f3P/389Mb1v8MTOzif5mfMn3i/yz0mu0Z/y/mn6xfBH7/+8bDwc6n/NxCy/HVG8ZfLA/fyDIxf/z8jfUThxzPl9cMrF+YXxnxKn9ifcr+U/IXw63nD/9dYP3O9pL1D/Mb0b8CT/5c/f/ytySr1AXWH7++/mXk+fjh+4MnT5j+MHwW/cfx9s+/97+4WJi+C/9nfs/A+IPv37dfTB9//f3OK8DNySwG2m/6/8Ofr3/+/uH+/fPXx7/Mj96+vPt4/+Wr9548eHnu3pPzt//9f/3l90fGX/8l/+nJqzDIKSpI6XPIsfO8eXKO+a/yva+PONh+sP6VYHj4+uGNDzc+ffrA/uX7d0G2Z2/+CAt/+vDnw683f7k5/vD85/7w//9/zrcv3wr/4TQRlHjy/5vxZzEdcSWd/yyKRkoyT14w8X7/9eIrDxc7008mbgEOHhGxH0/e//z2XYJN4c6vu/8/Pj7588+nNyycT7h+sfz/8PPLrzfv//xm+PX509/fX9j+MP9nYWZm/PGfSZDzFw8L4z8GZpY/Hzj+s7P+YWTge8nEwMT1l+vZ/5//mXm+c7FzMTMLMbFysf3nYmT8/4WNkZn7D8Nnxt88n/9wMHD/ffv7z9uvH/78+cnwj5Gb8dfXnz/+cf5i+s/1g4+N/8GZt+te3mT6x/CP4zszEzsjExPDz+8MTCxMTL8Z5GSCnUzeMgrcenZd/Psvpu/f/7Owc7OysrGIMnx/ApqvYmARZPgn/pPzOyfXr/dfvn7+wfbtP8OHb68F/326//DHP94Ld8+zMj97effDlz9/hf6xKYiIi/Nxfvr2VVdaUVRSXlNc6d+vzyIS0sz//v1lFPrK8Ps906Mr/H//vX3N+PvLN062z68+svxhYPnP8vs/C78IDzsf9x92TlEe6b/cvIyMLOz/WT9yMrP8ZmZhYHgrKvFKSp6Vnf/zp1+M/38zMvz/zSfApiH07e/v+rvbBf/+Z+DjffuD8RPbH46vP9kZ/37l45Fj4bvCx8j56d+vH9/YWIVeM7/+xcZtwSjI/ffv2y/3hdkYefkEfn75fvjJpS9PPjAL8PzhkGD49pHxG9NvoZ/cr4QZef+wvmH/w/KH9f9vCR0RdQXdu78+XWR9/u+H8Pe3H/6/EmR+/4/xGdfX37+/Sv3lev7yKf9PmQ+cd87+/PX0DYvYV1YeJnZGBs5Xv1huvzty+O6ds09fvPrw6hPbiXMX7359/+XXE7avDP9ffv707gcTu8BXue9M3/kZWX/9+87EwPOXccOu1VzsAqLC7H8ZOJ+9//7/+2tWxv9PbzxZfOUZi+gTm9eCRz+z87G8uvXv3d+Tz34LcbH+5xBU/yf0ju2/orSliDA/G/vHn+/uvv55j/sl7x/uNy/fcDGxvrrFxPbnKb+w5o9/n7XMNPg431y985+J8zMPr5Qs3+efHH8Z3nO/42XjY2ET/vKJ5TfXV4Z3AoIKrMz/Xv9//vGHkCILw9aTZ5hYBZlMmISf/f8p+lfhk/AnMQ7ub++/sTHxvOf7/v/FgZuvGO98Y2UUZuT5/YP5OdNHyb8/fjOwMTOJvGL4JMr2//d/Vu4/nz7/kP8j/l7k598P3xjZGH59/veL+ScTIxMDAxsD73+eb/8Yfv75xs7+68+vv6zMDAysvN/YmOR/sL7l/Pvvxx8e7n8/fnOAdmb++ScsLijAxM3H+vflT2Gef2+/sHHy/f33l+8312vefwGOugYKoixM/P//Mf379Z2JjesfC+Off995/jCz/WWZvmnzN02WFDm9fzxCDP/ZuP7/+8XI+P8/2+9vbxhYv7MyCHD8/PL8DyfDl48iXH+f834X/CD08uOXzVePsj7l5pVg+MLMzPz07S9JTkVelvvXP/wR+C/CyPeK8buSsOyL/0+Yf/H84eX8e+/xPyYGVnapH4K/PKQ05CR47wt+Z3vIxMHDxSXKy88uwsf/9dNH9m9fPnIxMvzk+s33V/Q3w6c/X//94+H7x/6Z6Svrnz8/mf+wCP54zfbj3fPf3L80GXg+M+07/PD0m2v/lDk0OWWePvvyg/8tMzPbS45Pii8F2Pm5GBm+M7ALfvrz9zfrb8X//1n//n0iyCvw8e0PJsHX7B/VnzNfvPHjybPbHO/5fwv+Yvj7+//LlwwSmr/ZH7M8lmAQ+vX/7RdWQTF+DiZpSwbQFOPV/7w/vz79CTpt/P+nNy9eibCyfeL68/O3MQOrooD0L/4n998xv/3DocAs/Y/rHuP7P8f/v2H7xvWdmUOeQ+Yd+6W/7znfczNw/P7J9JuJm4WB4duPN6wcrP//fP3/S+g78wdGZhH+359//uP6ziLEKc7C/vvrz39ff31k/M3I+ePHj7cfVx+98/zdW+mnP28y/frK9vzTK+a/L15/ZWLh+Pufnf+XFqsUg54IIzfH97ePf6pKv//78+37lyzcgjx/P39jZf39/4fYByFdQRVJAY4Dt96/+X373c3PX7m5Od5xfBd69PE15zv+z4L/hTne/nrL+UBBzPr9t7v8/8Su8H3gevb1Lf8rfsbPzz4wsfHxMwmymr4SeybxiuOnwN9/vzle/v/Hwf6V45ciM8PRh8xsz5l+izL8ug86juIvBxvTn++gPcJfvzFy87ExMvz8wczGwcnM9ovrA9PX/7/+8vxlf/3nCxMbOyfTr4/f2Xk5f7H8Yfr0n/EbMzPX/3+sP5g4/nJqKDE+ePv9FwMnk/Cvbz9ZWP7/Fef4/f73b9Dto+yfv//k5Pz0V0z8/+cPrJwCv39+ZWAT+P37C+8noXWbH4r4CSoo/WVg4mTkYmb98ffn7+/sXNx/mRm+sfyOMlA/cv7Rgnfn043NPzP+/8EmzMP6/8u3z/8Y/gl8ZfzEzviT5Q/n33+CfHyfWP5zMfK/fXb/5U8WZlEG1e+/Lj39w8n+/zsnixLb/8tfvzJwMTE8+PeG/+vfv4xPfzz8wSaizPbjA+tvfmnJrw+ZuWX+/njGc4jxrvFXVRUNqdccb36/+8ry5ctXqX+/fnH+/vPu369vfziFGT4zvme+feT7e4PPsnLMX34xCP5l5fjH8o6FSfoz+19BdjYeVm6eT//uvv297fd9la/fuD6LfGB+ycQp/O7DeyE+VYHvv38xcrEwfXv35RM3lwQX49M/v37wMyv9v/VK8j/DI0V2MY5Pos/fXnon+Orlffb3fP/+vmd8LcDE/fk/nxTL/3c/P/1n/PP7+/9PHLzc0vrMGgxc3EJSQq9Zjkq9uHX5OeNbrq//3jOx/2dkYP0t8uafMB8DpxD/w79fhJmZXzF/k/78i/E3+x8Wlh+in79eZGOSFpDj/sfw5RrrV+a3/75xvmFkEOX8//PPT45fDF+42dm+cv9i/PuTgYORkYnlF983xnf//zP+ZmJg+Pn9N/OnHz9/fvv+9durey8erDl18fObT0pMPH8YGB58vvPp9Y/PX99+F/7Oys/EyftfTEpBkU+A9z+jwv+f3KwyDAxsgqzy7JyszK/ePGXm/PGDQ/+7irwE27VXX669fPaPUejihzecYqKK4gKsHC8YvnBwyrFLsSp++nqdX4lFgJGX8csHbgaB78zCqj/E+Fj/ynxU1he2/ccg9OvDN47vf+7yM/z4J8hy9wMTm8wN/l+gkfjPQiff3Xxw7d8v7l//H7MwcrP8/fH9HxMTwx/G/0yM/9l/snxn/cT6kVmQ49evx//+CfznYmb49f3PZy4mHgZG5p/Mf9iYmVh+8n5h+vrr/38mZlbmv9/+/GMVVjNSKdRQFlWSZWX49PPrJ06O37///Pz08scv9resXzj//fn3+cd3JkbG/y8/M37k+f3+zX9WdsZPH/6JsDP8fMvx7cX0Y6c/v7jHx8zOxMLylfkHEyvHj8/v/jMy//36j1mDz81UWfzB39lHLwp8+PaP6fe7r5/+/v7DxMr9np//L+Mfxl+sDAxMn9i/MvxjZWX6/fnj17NnLojeZfnAyCAm85+J49dP9t+fnv1i/czH9+0XI/+v3+zsnOpC/Mz/xLl+PHnD8ubmlXfvmN4w3/7FKvCP7fWPH2wn71/99PmjiKg4t6jgL36BP39//Xz/g/H1Jw4Wgb9/P5z6fXvBxie3zj7Yeuj63fuffn39/fPHF0YG4d8/3zDziXwSlfvK9+3UtYe73hzl5/nxXlb4J8f/B/9+cP35JCGuqvT1qyw3FwMDD+s/TkY24Vd/zmjz6H17/2vvlXNHHr49f//F220v7p9/9+jDz5eXHv15+esfwy9GdoE/jC//MPJ/+/f3I/MH1rd8/zh/8fxnlpdh4eJgPS/84tHzX9de3P5znpHjuyT/L2YOZnEOJpE/or8Yf/F8+8rKz877i/PL50svf/59I/CGQfC99B+2//+/f/rDzc7E8o3zy+e/n3n/fPjKzMXBxsnK+PfLF86vf758ZPrG9u3fV6Zv/5n+szJ9Z2FlZvn77SvoqPWffExfWP/8ZfrNxcLDyvDn9I9HG87cvPv4KSvbr6/8n77z//nzlfH3638//39n+8gvI8ZjKCTP+P/Nb2YeMSE5fnkBbmEhzu+MrLfe/fwqyM4hyMTw5zcnw3WWdxzqYj////70TZKF9QUvq9Q37o8fOBn//RT48/f57+/8vNx/lMW02T7+4uERefrqyXtuhh//H3H9/8b9ge+D0M9n785yMrAw/fr++f+v/2wfvv7/9UuRg4Xrme5vDsF//AJcf66//8j06zXDs1+/Jb79Z/j7i5mb5zPbH77/DKzM//4y/vrzheUNL/PHrwyMDKycH5hf/vn3n4/5P9v/n2z/GP5+/8vAIsTG/OT3vy///4PuCmX4wcOoqsYboKz3XVrGwlheRl6Q4eeP71+//f3/mxl0HQojAwsb65+///69f/7mD8NHpt+cPxk4WBg/v/vDwfuW+9l/HmEWNmbWx98XPH329+PD/39+cLDxM/z+w/Kf9+/nN4xMbAz/VP6pqYd7Wf299e7I+Tu8v/8x/mf7z8Xz/89vrg9/WL9//sfC85f5/z8mPiaeLzyM/KxCQqwsLJ8+/v3G8pfzP6+AMJ/UP4HfDP+Yfv38wcYtJKvlpvzXTFpQQEKC9ceXfwKs7L8lnt4//4eb79X7u8ISKuJf3zAx/Dl368nr2485uBhZeYVYv35jYvvBIsjHw/Tt9rNvuw9d/HzjCu/tr+++/92y79iuCzf5v71lYGVm4RZl+Pdd6NPr009v7Xl68NnLV3yv/v//wsN44631G0E5AW4Bhv83+P/wsXAwC3xg+PORkYNB4BPb89v3f1/n0XjFo87JrMvyW5efgf3e95c7//x+/5H7H/cvyU9//3/9z834//t71s//ud/JMvz585uPSUZK0FRNXkJVTOCJ0INvN54/Y/z16z3oEF0elg/yLzh5mFh+/2bgZ+Xh5uBh+sj/VeDDzy8M7Bx8QiysgqwMNz6+5/v97w/3r988z978vMd/lfErx68vP3+//vuH9TPzX4a/v34wM3z+zwpe7cb5jfUb87e/XKz/OP98/PGfW4yJn4VXUoCLi+3/l0/fzx548ubiZ7b3Qh/fMXz6+Onb5V8vvn/7+e/5jw//ubgE1WTkFHTlDIy0+AylhBl/sP5kYxRg//3wx3fWtwwsn2UlJIW+/5b+z/qJ7cfL20/eC3Nxib7/YSphI8kq9J/p39vfXKyc/5jlv/58wMQk/IXzz/efX79xMf/nF/rP9PX6z3uf/3y+xv/u+5e/D159ZhRgE5RTl2MTFf7CKnzvB9dzzm8f/rz98kyeXfjEifv/Hoj//vWTkYOD9T07w78/bCKiXxnYmN5/Yfzz+x+rMAMHPyM/x/efnxm4WH7/Z/7D/P+b0OM/vz98/fGe7bcw899ff978ZWQWYBf8+u/jv3+CfDqeCj6auvc5/tx/eVdKWsZFXl5ImusPKwvT+28M738zMYn8Z/jxl4uR4avwv08vXv15ycn4/fd/ht+cDCyM33juCv5m+cjC/IXv17enh/9M2Hb1/9cfoFNYOL/+ZfvLxiz47+f3399v/fr964sEX06w446Xj64cu8v088vf9z///P354f/P/4LizL9+Mf77xvjjBxODyLff30V5OeU0VDiE/3BxiD969+X+nQ/vWb4ysrAK/v/6SfqPE/cTZRldTrbfbBpif7mY5flY/3H/5eFXZHr6keHFD07+j2z8oiIsjL+//9x75dIvhr9MDJ8YRETYOTlYBEV///108OZjrnt/+Lk5fnFy87K/+sXM/fLl5/+cXIyc/9jZmRh+/T5+6vLKy1eYf339xyPwk4eJl+/fCyHOE/zfb3z78+XRDSEOYeb/rPK/BK4yP1VkFeNjFb92/4EcExMXKzfD/z9snIzfGZmffPr+5+9f1m/cX9n/s/8VYfj/lZlJ/D/LPwZW5t/fP/6V/SPA/UtNiucnt9SbWy/ZJEQFfnAzcf7++4NDhIP9KycD933Bz2wf2eUERTiYmZUZWL8LP/n/lpdFiJOb5YPkn58ffzJoMFv/l+WW4ef9951DhJP7Jft/5h8MDD9+sX7j+M/x99//P4zsvzlZmf9yM3zlYfnA9VeMmZH5K/dnzj+SjAwfHjH9+vv5+7dv9z98Wnnk9Jc771i4Wb4zP/719+PvXz8/fn3E9OfXn/+sPML/xYTZn3P8Yhflkf7Mw/D81zumX09fXfvynU3ZSVFJ0she1EDsDYPoX44vQpwc37kecf+Q5P79SV3M4On/s79/vbnH9PHHp/9KQgp8v3gkVD9/f8rCx/hbhPvtu7dffvz59PyDHq/Gy9f/pIRlmN+//fX9/4Ofb9mZ/vxg/P6K9ddb5q8fxH/cufb990vRU59uvXz9ke3/Cybmn+zfmH/w/Wb/x/jnxQdGxvcM7ML/GL+y/f71m/EH54/ff7l4//xgAF8a85/1Ke9PTk4GBhYmRtY/v74z8nD+Zf/y7etvBmF5T0NZV371L7LC/z79f/6F8emTR7ySYh6mpjzcQv/4fjNxMjD8+/qHkfk37ys2DoY/7Fz/P/348OE3w48/TH84/jIwMHLw/f336wPrz5/8PHw/Xjx++nDdxVu8LP85mERZmVh+c/7/z8LMyab0798PJgbub4LscQbu264ffHrtOSfLF6Z/LB/5QDPG/7nZ/7Gx/+fg+PvrJwPzlx/cLHqi/Fpaar/e3fn6/Sv7HyaG99/fMrJ8//8vjF/5ubTCA1YW4W+c8n8ZlLnkpJTEPAzVGQU5fghxMHFxP7/3k5tf+B875/v3P78/fLNu980zn8+zMbFycfD9ZfjKxs3HxPbv/8f/n5mYPzL++sT6+/9/9nfvPjx/84eNg+sn+xv2p0/u//8izsr8lo9J6DfLP0FOtd+McjKsMkw8vxl/f5eUYvr99cGHH1x8P6RZda9/P/3uDasqmwzbH6bXbPdZ2fg//f13/s/nH984OHi+MHD9Y/z76/ef7wx/xZi+/vj3/z/DP8avkn/4pdk1NLQeywtIcvznFBOS/PGR+w83kyQPD8+3a3xv/3D8YJb8/onrJ88Xnk9ivxm+/3gk+vzva45/7P+Z/n0V/qzE+usjD5M4Bx+ToTCfobGGJO9veQFhGSXRf/w8nJwCTL8EmPgFOBkYGNkE2b5/+S/4g4n97z/m34x8v74z/eH4LMLAycL069e39/ff7Dh04MnVu4zMn////P1J/OfvrwwfH338zyLw4z8TN8sfeR1hZqH/+r/+nLh4ZsWDk59/v+WWFJLmsRbl435z996z5x8v33vw6zODHJOAFDOHsDQf55sfbz/+fHfr9dH33/9d+fiVl5mBn136y1cFUfV3T17//C/G+uoTI9NfXnZGMdF/v5n+vHv+mlGC4dvLT4yif6RVtfgeM7FJcH798+3vu2/8H3m+PfjDoMTCyP37/rX/bP8ZQJPyIIcxcH/g+szIxMT19t9/wd88X/+IgQ65Yf7y/TPDGzbO38zfWP6JM/z48YORl5Ply6d/P77/ZvnMyiH678evP58ZOXgklJW5RJQYn/35c+/2g/+g6ze4/n/muiHw+dPvr3rWsuxcwt+Z+X/+eM/6h4HlpeDfz184/vz6w/Diw7fnv/i+/vr866fwh+9M//69fcP7g+ff359sPMxcH5j3n7lz5djdP7/eMzAy/v75k+0/59f/H/4xs/z78ZeJW0heiz0mMmLt6UsPzlxgYvwr9OffR5b/f/8/YP/DwPz3x8c3F76+/8709we3rDgfu9Cnl794fzAwq7D+/cXMy8pioKYkLMiv+OM/KMBf//j79o2gmBAr8/eXgnwaApwcb9meP3n74c3TT5/usDAxMX1+9Z+P//Wl2+vO3Pj7/+Ub1v+fWe///vf/Hzs7AwvDt//vWP4zsL/7w8r4/c2vH68Z/3P//ffjyY8zj+8zfL3Dw8Iuzij+5ysjJ/fv1yIsTz8z/P7w5DPbl1+fGP/8+vvp14ej316xsPxj+6HE8e4X998fv/hZBRkl/jL9fPzqy5cn71hZ2f7+5vr//zvDf8b/zJ///HvJ/O//nx/cLMwcQlI8ljwymhqKv998efThI9env79Zxd9/+8bznPHzTwaRD9wCv8X/Mn8R+cX349ePDy8+cH0RknzFxcPB+V/40dfXv14+evtblFP2Hy+L8KffXyU/MD5nkBXTkJFn/fnqz+e//xh5v35/x/Tsz1f5v4y/3v0WEWH88ekfG/efz7+43vP9YWT8I3Wf5dN/pk9vP2w8fePK0ReMX3iZv377zP7r25OvX3/9/Mfy4/ff39Jcf6QlpThfMCrySt569PH6LeZbF38/vXzv5re7LAxfv9y6vO7Fk/UH1hy/dPny7Ssvnv0XfMXK+JHFWEpfWJGPnfe36Jefv/9+/f2XlYP93avfv868vv+T5zfzn3fCwlqcXwTYf/xm/i/ExcT0QfyPwK9/jOxc33/9/87+SUSBQeIbC9sXkbffft388+4fw8/Pv9+y8LxjF/z64+e/r5/+Mf99y8Dy6R8PExMDw/9/DGwsf1ne/eJ8LfP//xdGJgF2Fqn/X1iYmN79fv6bk4nj9+//jOyioF3VP5gY/7778/sLp4ygs76+r7M9y0/W9y9ZOV8wfGf5+vPji1/fP4l8YFOVVrRUVvOwMubm4P7DxMjw/fNfzv8MDCx/fn7+zyDF/IHj4/1foHvKXoqw/HrNyMzx8ecXhr+//vAw/Ob/K/r15+xT9z+/fs74/w8LH/tf5t/sf1jZfjAw/Pn149crdlYRQak/Pia6u2/9eHr9HvO3v79YWBg4xDmY3v99+fb0+383b7xgZeRkePrwHwvDV9AVDNy/brz9Iy/qoCLO9ZeZkeGfoICoJAcvDx8763/+v6ycvz/+5vz8h5ODRU1SXFpI9NuXfww//r97/+f7rw+c4pxCfL+Fz/HOuHmF8f1nwT+Cf//94WD7/ouZiffH1x+M3/8wsHz894ePgUuU6fe7F49PPbqz/vLVlzxCv3gY3jL+//jnOv8X4XcsP7kFmJkl5X99+MX87+UP5n+izMxy//he/njH++EX34cnn799+/3zkYAQ393nX56/Y2D/xviX7d3vH79Zf3L8/cn5/yMLw2+eb6x/GVl/CIiwaYsJsKixnL5wnfWHwN0nrx4/e//h/5t//7mfv333nY+Zk5P7g/InNh4pdi6Bd39fC38T/8P66ucz1l/MX3jfSjJIiAh8/fSV85Pkn39M4lqPOG98fyb8iuX+tz/fH33k+c3/iuHzf0ahv/85fjO///nrA/v/Vx+Z/vD+knvL9Y/1x5+vDOzfWR8q/eL/x3LtxuvrV2+xfPn3TeTdrzv/vv1/+esn8///LxhZfnCycrHJCrP9+q2uIP3i8atbzD8YWb5xfv936OJ7drGvEtKCv9m+Cpzi+MUrxP2F5c2/L6wfP3DxsXJ/+iOkz6P0VeLX9x+3lF9//iAg942B/ZfMPd5fIh8fS/2V+fv7y0eWOz/Zmd5/4WADr2ZSZNNnYfmj/e7rJ2Hdx29ePHv6/LO0FJPqT5XPYvdv3fjOxyHDLi/P/o/l35fzLP/+8n5g+MHwl52H6+fvPyyM/9hY//P9/PvyD8Ov30z8HP8/vWT4LfSHi/PPN1ZuHrYvv9+z//7N+Ff4N4Mg07cvX/9JMmt/i9RSU9I2PHf5jjAPH/e/X8wSPCysv35Ji/76yfzzPycDJycjwx9jA407zM/PH5X+8+zjv0/f/jAysrAK//396y/TL4ZvjK8k/gkz8H7/w8TBycTxh/sn81umb7ygi8f/MHB++zlp3ZkCVyZRfc0vLF9ZGVh//vvGw8DN8OvfJ9DNysKaxixcfHzrb53VufPW3F7w61veZ39YN+7d+vwJKx+X8Itft+xEdV4+f/LnJzML+w8RGb0wVc7/rEK3Od5++/2eg4WFlfH7Lyahvx+fCPPws/9j/8TKycbAqqgjJv+R/+T3249uM/7+d4uNiY/59eufzAyMjF+e7fs98dbZ5iDZn6xSf3n/M//7/5mJ58+vTwy/5Fi/MHxR+XjwysXbMq+ZnzHwKHH9AJ3E9PsvE8M9Zt7vz79IKQsovPr7QVnw/dMv/OJSPD/ePRcU4WJ4Jc8iJM4q8u3/L1YBduaPDJ8ffLn//Q3bH04WZobffzjZ+F//fMf2m/8L20/B/8xf/jOxsHOKiun8UdbQZGL8I/Dzw7c3V9mYFL5/B40AM7C85udifsH65Z2IMO/XtwwfBD79/f6X6QMDN//Pd//e/f/MIfaH84PQV8Z3r9i//HorcZH33+/Hl3k+/mNh+KD+Ru3Cryd/frFx/OX5x/OB8wvLV6Y/zMwcHLJcX3784P7OynqH5Rv/N3YePoaXH38J/uH8JMhy8PBpht+in3nv8rxmefX/HfM/1v9Mf7ll+BjlBRhfsovwc2uwsX3/L3X9/1FdDuGP/z9e+vvi3VdO1v3M1zRuicj8NbLW+/+Rj4Wd/+nnZy++f/r3n/fF5xcsv1+9fPeO7xefzB9OQR4eJem/H1n+CLAyyvzQZPj2+7LEO5l3LGzMT/jFhS7+e8jzj0v0/9eLv+78Y/2i99v4y99f30X4mF5/lxZlvMr98wc7P9fb76953v+59+3l6x/MjLyMf9/+ZmLl4Pjx/RMrG+OP38z8f568YxBj4/z58/PHf8zMPP//f2H+xsHJIvj52zdWBl4WDo5//14xfOL6w8rGKvipOiDy57+31/4/YOL7fvftTyVVyVfPXgiwSnL8fc35n+P9ux+PhX7/u8P0TuG8o4zZe+mDL3//Yf366TfjR5Zv3P85PjP+F2ZgY/716u93xgdcEgo/QSX3D2YusX/ffv3+/JVdTILt+7NPn3hmbb2SJSvEw83/7z/7PxamH9++/fn/h+0jw28uDiZ2MTktgQg+lhVnjv/Zdu84I9O3x38Y/v5hY/j879f/s+d42RRf8DIx/uD6JviVw0iV44+krOTv96++cXz/8OcPJwenoNi3d984JWRZv71mEWfnfviUhYvv89c//Kz/9H4pHGW4xc7E9/4rA8t7FgbFd8w/BKWZ+e7dvH7uCY++xF+B91w3GRj5/jH8/fv7z7+vvyV/MT9huPzivoqY6M+/Qlx/H7+SZpVglf7C8E7xl+ifT4+ef/guysb/5eYL1heP33Ir/GH4p8XFdfUPh+LvPz9Zv7D///73K+Ojj19u/XnN+134F9svRlYO5t8M/38I/OdgZP/09x8/A+M/Hg5WHgU9Nh4pTuZHn088fPnr138uBrWX7A85uJgYn/36LfP3vYCYAP8LNtbvzP9l7r+9y/njH+tfFYavT3/x8bGIfGNjZv8i9pv7JysXtwTbk7+v/t/4fI9H6LvAP/lPr55+/v2F4zfbM65PAj///fj5m4VZ8O+/nwz/3/78x/Hx129+tt9cf1h+cP3480uKg/HDh5+gVaG/vv9m+vLv47/n/z8w/QX1a4VEeaQMuVSNlHicBH+8+vLtzZ8jJ9a9OvPl+vePanIKRjriLBwsf199On3l89e37wQ5uDlEfirJSenKyAgz8bN//ybDy37nAcPb+28f8f79rS8lyyN+hvXL39d/eVm/fVNl/cDwS/Wu4G++D994Jdl+/bb5p6DLJv3980MxblH+byrHv+7gZhZSEOIW+MX68fkX1svfWL98fs/y/c+x9+8//GEUYPrH/unfH0ZWLr7/738zc7P+YmRh+vmLkUmU6z3z56+fONj/MYuw/WfkYuD59e3HOzYWzv+M737++vrrLd8vhi//RYVLAr3/c/7/yyX849Srby/eMn/gef72EbsA53/eT2/fsbxk/s8j/PXfxb9s2szsL7h/fP5urqosasHOwMTP8E7oD+uv3wI/mf/9/M/2neUP4yfWN29fvmLgYmAV+MP84++vf38Y/wt9Y/ny+xcr15/PX1++WHDrLMPLD/+Zf/3/8fbv/7+M/xh/ge5BY2RkYmQTeqkhJOxrZLH+/pvvF36xvH3H+Ivj17d/zD/Yv7+/fub2tRvvP7B/FzZUl5fkFf3w9duLd38EGf+y8HB//fn1/e9PnP/+fmFl/Pz9kwSbNDsPn8C/Lwp8/28zMP5l+Gmiq8rKxM747s3HPx9/3+Vm/fHr99fvvJ//z158dPehk6zPf3P9//D9LwvzW4GvPO++v/7++iMDG99XLSaRdxLPPojxa7FxSTBw8f3h1Xr30oHfRpCd7+TvRw//feHgZpMQ4lPn5Odj5vv++df37/wfRX59+P/z5dd/D59+ZHnL/PfvTwaGX38ZWf79fMrwj/2P4PdfHCIM3/7/l/+jay8tqsD5+7/QT9CSZAm2D6x8vx/pfpeUfy/4S56R5TM/G8Mfbk4hJmbhH49/MfyRYP79k4v16//PIv94hIR4GeU5Rdi5/vPKKAgJCLMKMj16xPHzPfeTr4/fvfj+5ifb70/P2H/x/+D78Z/pBwMbI2gW+jfLt5+fmL+Adgp/EnrB/pb1Dzsj82uu77IfWd7yMX1k4H/76c/Pt09/vfrDLMnNwc4uys78X0TsvcBveW7eN3LM2z6/fvWE6/fvp6+u/zj88LaWuByrrAiHCPurL6+P3XizZf9+AW7t509u/ODkEpCU+8n35yPrC+GvPxlYBFT+cmqcfXqK8fHfZ79+SQibshiI/2cQ+v+HX52B+f1foZ+st369ffn669s/j5/wcrB+eM/I9U75sYkw969f7/69Efr74pvgA5ZHv/6wfr/15yvjH65v/3i+iHEx8jCy/GViZf7LxcT849d/tl9M7KJs7L///P3NziL17f+X/+/+Mfzl+P3zDyuvzN9P7xh+CbJ+Zfzzn0nAQS3FQfs/J8OTD9/ev//OwsPPJPpfXJVP8I8Yw9s/3z+//c/5l/MTL88/YQ1bKfGfPP/+Mr778UlCXDxKxVVFQ/qfFgPDGwam58J/2L/++fWV6d+vn+/4//5g/P/+x79vvG/F77B+YvjH9oXlN/NPzg//mXkYODgf7n299fj1X38/cXAK/WNnYubgZefi+///EcOXO88evll14cypXZeV5YX/snz8BVoKzsDCzfuV8TMLg8zrf1wfv/+yVpVi4xP6yfWLlYnjCSvPx3//5bh/CfGy/n/x9RcLJ/vnO7/ZRV5+/PyDgfOXiDDj109aDP+f/vz15usjDkbWnzL/WL4zPvv7+On3N6+/vmX49ZHrPfuac8+P/Ljxh1Pk/8tXv5l+s9z9x/T6x5e/Dzm/il3+/5SNkUGdR0aAj+/+kzsCrKzHRZiPfDujyi9u+VFURYjzk5DQ01fPP/7//vHdXVZ2rqvfH7z7+urte7YXz1/9/P0DdHISE/s/5u8sv37/YOVm+P7l/0cG9s/vfhizign8EP7BoMomqvTpJ7eIOIv4bzaB3++lGd8x/LvH++n3C45fSn9+ij7l/if8n/v9v/8/JNh//BcUYPn76yfTeybGR8KyOj8Zvot94fv/7Oe7E/dfveT4/fXnj6cvPwh9e//09/vvr/+x8v39/oOBmZX1j9QfsY8MjNw/Jd8yC0mzfOdg4P/K9OM/EwMzIxvjD8anXHeUfrN+YWL+dO/ftzvfOSQ5//+S42UU1mL7Is3498cvnitvPzH9FTGRkJJl/cHNyMqg8Ofn/WdPuQ89fFRmoWplosrMLvHpDsfF668WrV7/4OWPf+9f//7y4jsX+y9NaRFh7n/SnHc+f74q/pvrxm+OpywqIgJPGH/efH+PS4zt5rfnTL8Z+Ll/fv/D/uHHT7Y/rMzfWbg5xf59+c707/fb+6++ibALf/nK+uYO50OJb1+/M//69ZXxEysDz0eRp5/+vOPmEv374SsDIxsTCwsLE/ufL/d/sQkwCgqwc/9m+s/3n/E7I9Mv5j9fGL+8+MfK/+fXmw+c/KImPLnGdgLizB9/cr759Ijz7YfPzF//fxf6/+sXuxj3bwmWX1/EeZVENAyFv/5lfXTt/ocfX6RYJKSkZJjYOJ/xv7bRlpFhV/op8Zn50x+Gz+wsv/h//frFwcX+99+nT18//fj/jfe5NHh04/Pf35+Yvoozcn5n5PzP9fvfydNvdry4+oPnGzsL2y/GDz//fvr5leP41eudM7cf3PbgysdX33/w8fKw/WMT/fPiKevvz7++/fgq+EWajT1EX1XHRlZb4Muvt8++vPgK6vP+Y/7JyCbJx/OVW4zp128BbhluQdFfb18z/P7MxcT6n1uAg/2b+G+2V3xCwkL/hX9LszJ8YGES+f3m798f/35xMAhri5VY22eq6IpKgbY9/X/14pXE99f/3nF8YXz9583br2xazFKf/n14+vbRD0nOT/8/GLPKi/LyML9+dUeZ79sb9k+M34Q/cX768/f5P+Y/fP+kfrAy/2F+yvv5+afn7ILiX79+Yfn++T8704/f3OysEj/YXzP/5/rHz6sgziRqLvtHkvPOr99PfnJf2nr768PbP77/5nkh9pP3L+u33x8Z3zB8Zvvzm//Xrw8iHJI8psKsLD/YGAW/fmD+w8oqIKLy6enj36wiN38+vXvg7sW3H5/fffX33ysmzu/Mt8R+MoJOMvwu/J75DzPzD7ZffHeZPwoy/f7J/Fz4z6s3fyX/MrzgZPvFx8DO9vczA+cfsX9yz1j/cDN9+s396TsLy8+f4vJsampykkpy7MJcn758YeASZ/j48xfTcyNPdV8j2R8S//985/777vWr978fCv00VBPXVP/wn5OT9cvX54+/n7z19N7b9//EfsuKirP8+M6uIGLKKakp+Iv1v5QQM+N3Qw7eD7/F2bml+RQY2WTl/wj+Ff/54Svzvx8MHO/fvvrBxv2b4eHbh7++/pPQFnqnyPn/+x8WJS4BARm2fz8ZfzMws3BwMvB///2E/y2HhBwbz68//zhZOFgZGdmYmdhAEwq/WR+xvPv69t9Ttv8CDJw8jKzcDKyM/zgF2L4z/GMXMpTnTzTT+ich8POvxGehl3zfGe9/YRNiZRESFPj+8zPTxw9/bv5h4vvC9uH36xcPv734/ouP7e+/T7/Zuf/8+/Ll+yeJF3wMTO/N/VWE/gr9F2T9/+PX318fGBh/Mnx9///7rx9/Pvz/8oaJ9fdP5r//+bgZf//7/u/rn2//f7F8+v/ry/9vz3evvLf+7S0BTiaO96+PnH3Zt3z31i1PeT8JcbD95gBNzTB8Fv7HLPiBgUPg609e5m/MAkYc0WGO7IIi3/+wfmMX/PuLm4GN+f/bJ5++sTz//fPB21+8CjLf//8UZPj39vORPwKSIrwcjL/+cf////MXp5QQq/n3P/LySsIKQiq6CpxfPzHy/OL6xfVBkTXTw0zbSuWBLvsThr/8kvz8kkICAiy8Spx/hLg4v7D+kPx77vt11t+fnzBxGX0Ul/jJy/f792tGDnYBoY+v7zxlfM/67uN3jn98DPwCbz/xv2H8wc335Pi3b29es7NI/Pj+j4OP5wcPE+NnJmbWL3/+fvr7i/MXG5u4/BcvbSfH71ryn/k/3n7/8c672/++/X4qwcLI+f/3j1+/P/4XEeVXFBTk/ibDKCsgJMr78j0/O7+FhgGP9h85ETGOPzy/37z4902QmeG/yH2hzz8Y2b9x/vnzmZ1T9DsXCxvrb6Y/Xxl//ON+wv9P+tP/bz/+8HCxvGX5z8rAJPb9n+Bflk+/mBlZ/wkx/f/y54/YawbO/4wfmX4LMjF9/vGMgYVVWohRmFfqPQsjz7Of/OKsCkLy2v8YFfhl+L7LvX/73iHSUkNWkpGbj+nbu09vvq9cdnrDm4f+muaKmoKfhdl+f37z+NGPPyzf/jD85OFgleaUfPnlDa/kPzVVLSMe7k8qbHIMv39x/L/N9lHkPdstlpeiwgpfvr55/fX9n9dfBQSlmBj/vLl+7utDYdHfIne/vuH+yCr6ifPXqU8PHz3/ycnEL8jIwP3//7+fzHz8zH8FebiYxKTYeLk5v3///PPT3/9//zNw/Of9wvFRgIXzu+i/378ZXrL+ZfzO/Fn4z8cff8WEtKTlgm21/vKI3r365NnLdyyf2D59/snA9IJLQujX5z9cfOzsXHyfxH/J80lxfv35/D3DP57Xf55+5/jM/fbns+ePXnx49+ns4xtPvokzXnlvH6Anys34n4mb4Q8PAwPTL9E/rIzsXP+ZP3L++vGKgfkbK8vHfz/+fmdnZvvH+OPPf7a/jD952Ti537w5u/Hq9Ps7KxcdXbd55bcnn5lFvjKJiv5jZvzFyPfl2Su+P6Is3JK/uX4wMn78xc4SLKLNzfiHQYLl4607z9/+//+L/fv/34xcnCLCTCyMwu9+/2F/8eILz5t7f8QEf0qx/vjCyMn7n/HXL04uIWFRVmEGXh5BVgEGe2X53/z/pSQlWP7//8bwmeE7mxD7t19C/07f/iD+6jEbn4iQrQSPiZS4koyClgi3OQ//J05pDn6tPwq//zE9F/rw7t+nY78fcX1iePj6Ietf0f+/HkmIaL8Xenb7w49bnM8/sn2+ceXW9w+/fvz895/9E9N/pj9Mr379Yv73j/EXAwPD9z//mZiFNN9riakyfX979fXzY7xPWb99Z+Rk5eT5JsrLzMDx58O/dww/hThkGfkl/6vK6rOwv//w58Pb3yxGbKLc/3lkRTU55P7zcIvzsLMrcf8S/PHx9++f7P95OJmY2Ll5GF+zcf9h+cv3n+En9y+2f39ZvzD8lGTiZWR5w80g++0X+3f2Z1ysv3gY2Fn//P/6l/sHAxcT03NuRp4v/74IMP34w8TLISjB+4dVnP+RwIenr5+8+MbIyMLPz/VZQspA5MVj6x9qt95+7b13/L3+d1dzcVZhSYbfvzne8Nzb9PwO2yendL3aTMf/Ggpfv7/6c+ML72++/V+eP3l9V5xDnJ+d/z2rwF8pJS0VORlhZVYmTuWfvzn+fjP7Ivjx+QsRdpmvf798E2D+/P3drxcfeWU13zE+/8v85j8Pp7oo37vn7z59+/OBlVuG87u2tjaP1H9GKR7uHwLf2T+9+fnrL5PYX6YvTMzCTCzf2X8zMnAy//jLxvGThefvj39Kv9n4f/7/9P37/6diMpoa1rz+tlqfhfmO/Hvw++vzn79evnr0mFtMjOEH68dHn/99//37MwMjJ4cUK8u951////79/9fLjy+ZPvL++viJ4R3HVxk+gW9fmL5wMjB+fvyRiYeVW9DTSINPnO8f1z9GZk7G91z/Gdn+fRdgevj9y5/vn989+cX4neWrwN9fn/4zsnO8Bx1H8JrruyAjH+PTDzd6z/9/9IGPVYiL8x/TJ6a/jN9ZmH58f3/lE8/3n19+/Hv7g42TlYGV6ycD45aD597dfsj0lYFFUpb1x0tRHjbWj2/ZBUVZ/37ilhFk+/eLk4dDjV/3J8/HF59YuX49+/z3Heu//yz/fzMysnD8YfstzMT/6fcHhk9KTNL8YkLKoNJCiOknH+NPdsaPf/l+sfD9F+QV+vPu82exN8xvuH78/fSR4THLl0d/nzP+uyv6zeI3g+h/0XesbFrMsszC315wcnP/E2IWUn7P84WHiY9V8DfDb85n+z/+vPft39cf7P/Zfv3nY+J+/ZuLj4Xt478/DKA1YWz8QmIC/nrWXPKCZ18+/vGK+++Ol1/efmT790X0P9ODN78+cH37rviNVZSBi5+F7/N/tndfWNl4DL6Jvv3PdOP2/W9s7xjuvX7H8opL4regECe/jJ4Qr+gbVlbG/4/+c/5m5P3ELsDKyfyF4yfDPzZehu9cnH9Ff//6xvjtHzMj6+/PPxi/CXwT/fCH/eu/twwM7H8YX/xh+PaFiY/v1/NfHLx/GZk+M3EKfFVylOT581viHcsPfsE3r54yXv+hy6LF8O3t3a9895/d+8fBoPBc6AvDj3dGopZ6fL9Z/rxnfMv6heXw+RdKv3+a2Ahm5xkJK8jeefny7dNfrGwfhaS133N8ffzl5avj9z+wPZN69P/rc47rv28z/uVmFRJ/yvjwh+jftx/+K/7jYXvA8PLLF055qXd/f4v+43nHxiH5gfX5mQ8PXz37+Z9LjZeDTUXjtfDXcEMbG3Gx/1xMLJyMnK+ZGXi+CQmz//v1npmB8ycTA8NfBsY/n7k4ZJl4RDk//P/6jecvww9hCZ2CUPksa9dLYjy/br81/S7y7wsHEy8b+x+eP385RXn5/7AyMHD8ZRVg/fP1zx8BAYb3Hz4ICHOLiAuIMH9/+4+d5bfob+Znov+//f8k+1PoHfPPH//fi/1meCctoqDJL8zN/ePjDyYG1j+fnzKzMTMwMTB8/v9R6MOfr5y/WD8z8TEx/eP4zsHPwMjI+u/XO6aPnF/+MPDycYixs7Bz/WFg+Mcn8Pv9zze/3//7zPX7CePnr58Y/zAzf+NjYmNh+P/z8Y1/a85df3/1sgg7z2stxm/8EpI8bP8+fGJn5GP69fvPv/+8zP++/fks9ObzTxHOhx+Z/n9hEODhe/Lx/LsXH3+ycvG8+cMoIMn17YOsACsD2y92PgVpgff/WX685/74+4/gf+5/7ySYnz199e3GnztXPkvc5f7JzfWT7w8f9z/x3yxvPn3dzfL04d97gqxszz/cE/nLpcHC+F7qqQqnEPvvP79YGP9d+XX3y7d/T76w/OT8DbquXZiF69OPL8xs77n+/2T6Jwc6S5JF+JOgjtTffz+E+bhfvn1/+9WXLwzvGZnF/n1591SAkUHxPRczF4uIpIwoN8Of/7+4lJ5zvhL8x3Tl0zeWr7+fvft64tmXz0yMfJ9EBBVlpHmFvzG/+fr0I8c/BjYuQU4WKXZBHilOgV8aHH/+MnL++c0i/Ovzj3dMLH9+fvjCxPKb6Sc3yz8G5k9srO/+/+VlZeIUY2BgYGXl+Pfn+19ONqb/vxm+8jBJ22n9ecbNKMMhIyEn/YNXgJWfR+7vnxfv3ovzvv116xLPSzlmKQ8Rfh5+rpc/vz+yYLVyVGXnZuXgZfrx+nX9gdvnb39RFuNJL7N6Iyjw4skD1/dKymySsmz8PH+Z2bhY391//47vP5P0Y0l2rZ/P/z/5/5jly3/2V9xcTH9fMDP95fvF9u4vx7e3/9mZX/94/ObT2+8PXzx79fnzP6Yff158Zfz159O3H3+ZuX98lZJUZZZn4f/Bwy+k9ov9hTGnJLMy+5cPTOxffrCyM/CzS/xkffz71/c/H7gYGb8IycvGB0qLKGqxcvxVFmV99vH3r4/MckbyapwSourcsixMrP8//uJn4OUU/vzn78N7z79/+cTM//fTo4fMHLz8zJ/FxMQev/709tef39f/cHIxvvvOwC4rIs7I//jLp7cPvpmqiKmpyfPzC/35w/dXkPnX798MTCz/RT+wPhH4//3lvxcfv77/953xGTPnn78sbMxMv/6xMfxnYPzJ9O8Hw6//bD//MTH8ffXsy6c3fz4xgE74Ai3p/PXjy9fPPz8zs7CLaHCz//l5//brpUcfXnl9SvGb+svHJ99xibx+/va9INf3x6+FWJi/8vBycIuxiQuL/mZklRO+/OD902evhP9KsnH8/v/x6y8OwTePDvz7KyzAw6EkraxlLSrGL6nCws/wl49DlClVy55NXPLvZy4heSEhHoav8l/Z2Vi4fwl852Vj4RJh+PrSg0f9y7s/3/7+esHFcfHR5x8fvuu85njJ8Ow/A+OPF68e3XvNfIKd5T/zH+73nN8+/2f8+v8XMzsXx/d/nxh+C/17xc7Hx6JhJCGrwPSVnZ/17S+JF+L/fj5i/S/85++P/ywMIrKcYiKC/zW5+IT//hRmZmT4r/jr6192kbefPn/4+1RARJj722O+/79lf/9nUxcX+//+DwMDz2eO11w/Od685VBi/cfx7/837h9/P7F/FuIQY2Xk+Mf8npON+y8nAzuTDNf/7///s7H/Y37LwMPzW/YX498P/xl+Mv1l/cv4k+HvFx4uwR/fGRgZOZk+f//xSfjHfy6hv2xvWHgYJITYBL7w/WL6uuPRMVkFZTZ+ASYmxrtiPxg//xH+ycP494+WuYhTiMkPQV7eH0ycp15uWvVg2qufmuwilvr2Xz9KHv386tSdLW9+f+QUEHzF9pP9H8u3L38ZP/5+9+HGS+43D3++/8LE+vDHk49sDC8/PmPhZvzNy8X0k5GD5Y+YtIYOg+a9P/8//HnL//e3AI8qC9sHphf//n59d/Lbj8uvb2iycf/m+PvzwyNxNgXQkDOrDIcixzdukX/f3//4zcL69vf3b99+cnwXVBQpirZTV7L6/v3f178cxr8EP5mw/Pv1+x/br58s/wT+8z/89P7Zbzb2R1/e/HvA9P0fK/dftl8c3H+5RdSE/r/7/Y5PUPD3d2buH7+f/WD98/rHbxYOnu+89379/vb1w9MvIkJsv7iE9cwUpFX52ETe//3N/+f3a7bfzKBRM6b/H38x/Gfm+/vtzc/PPL9ePvzL/vU7AwPrX8a//5gYvvxn5Pr9/8e3f//Yv/xj+vb/zZ+fzH///WJnZ2T4zfD1/0+Wf6ze/kZxPo6CZlJMDMLv3v1aveH8w6s3eHgE/7Ay8guw/X39mZ2P6wXD25/vPzP9+sn+8TuvpIQqK7cwt+DDd29//WXjY/vNwMbEyviXicuY/dfL30L8yjyv+D78ZGBj+P/n1e/fTP/f/33PdU9DUYxLhZOf/Q2DNP+vh3xfBb9bqUqbfv/3+vsHXT6Vx+8eMbML3/vxWvWd4F/W7x9+sP/ilvoqwPr+86fvJ9gYvjH9Y37F9Iedg03yOx8rKzvL77/fGBhYGJi+MzAzsAgxqimKaPHLqwuKvbr35ty3T3zsDCJsbN8Yfv34+ekVF8erL38+87DL8AhI/+AW/MYu/erfL0lu0S9fv/7hYWfnkBRj+aoiLykkyCosKcHB+/Ub411GjitPDr54yviPnY+LifsL16Nfvxl+8TIzc4GO5PrJ85uBhZvpO+9n5vegVTkcf1lYfjGz8DK+/vHvLzPrH3GGrz/Z/7D//P/xDxfb798M/9l/MTH/YGL6yfD61dfPf74w8HP85vmnrKjBJ/nvFzeHA7OaEoekAxuP8N9fLz8w6DJJcb587slgwvqHx4CVX0ru/+8/v79///Xq2r3Piy8tP3P3+IUD9989unP1zl9uUfGfDH/effnLxvP6/QdeUR4VMT0hfplXH15psGv85ebj42D48fydNKMI/w+RX4z/P376/e3BL44/n34wvmP49IOZmfH/N6k3v26qC8i9Y///+T3D+7e/NDh5XzOIafIyyQiofHn99rbsP2M1hSI3PSlLqd9c3P+Zvv1m5PzOwqYcJFfp48rBzvbnL+P/Lx94/rGzCHLG8ihKKEkxPv/B+PrXZzYudsbPXKz8EmJSEsIqf7/+ePbx+b8P79l1xMQ/M/FwsX198uHBmzff/nBxsPx88VlIgPEPOwPzD36+n7+//JHl5RHmZfv8l+XTT30FFXlhbW4OZua/nF8ZGNlZef//YeBk/sbIw/WH4T/jv7//OXn/vRFk+sf49+fPX8zMDCyMv799/fnp67fP3359/sHI8ZuR6TsDg+TfPy++sv3nFeQwcdeW1pTjZvuV5unBI8T988eTr3e/rzx24eO7z5JcTEwyrJx/fn9+/52ZQ/LLm4+f2Rg+MXJz/P/HLiSkIPGHT0ziKSv/p/88v0V/MHFxCbJ8EpRSZfnPwMYsw8n7S0CEkfO3wP6bZy4fvcrw9J0evyiLINtXNsm//CxMYr/lOGRZZH6f5fwr9e7vQ86/Aixc33//YnojxATef/ZK4OvPfy9VXrJ+fvLx5w9W1n+fOX5z/hf9/uffD4bvv76zf2f6xfHv/R+mn4L/Jf6K6vPqKknwcXE+uf725+v/D2/9uv3o6QdhRpa/P/nk+bl4/vMoiLAJ/TRiE37FyvPh27vvzBL/br34+0tAQPGfyC+ub28/cLOLvmT/IsAtKPOb4e+nHxx/P8lwG/x/+fIbJxMzJxsbD6MiDxs/JwcDOyPPHxYxBl5W1l//eb5ysXKzfGXh+vz716/3/77//iPGxv2C+xf7258cf3+xM/5j5Od4w/JX6D3fL3EmVlYWqbc8cmacHM9+/ZTgVvv4kZ+L5caPV38Y2Fi+S3Jwstxj/mT8W+o+x48rN77zif+/wPb2xrNbPBxc9qbyp75z3Hj47NcXltdXPt17vYfz+Q8OJiaGBzz3GV7xGAmI8f6yEON78pPx3t9n7L8E3998yq4ox/nxizSH6F+RHx++M/zj5WLn/P38zI9P/xiY/30X4RV9zP6X9yfDD1bOH4IfGf5xXfz5nYOT4dffH3z/WIQERdkZ3t37zvnr7+tX/7hVFWU1pPmFmaXCONkWXn32/vmfn0ps5Zam2tp6v//8/cHKzPTtMws3H+Ovz78YWBg4ubRZ2Rf+fSDznp3937dvn5mY+L98Yebke/X+8dNPTz7ySyt+EvrE+EmMleP1/y8/fjF+/flPmJ33J7ugBMvLbwy/vn0TZmL5yMMh+YuX7cfP/8K8P9+8/cbCo6P1/wsT6/vrDKAJ9Sf8/zg//GVk+P/vz39GTkbGpwyfRf7+/viH/Q0LoxDD15e/mST+ff33/wf7L5aH/5l5Gd5y/+FiYP747Bu7BI/MX58AZ5kfnD9+MjD+kOQU/hcTY7F89dePtz6/f/pu/qmLpSx87FKc/5VF2T7+/vPpPb+M9Nf/v1l/vPsnIvvk6RtmIWHJz78/f/32hkWY5+6TH5yffv97z/ud+c0rBgFuTgaeX5rS6p9eX7h//M13tlfS33ikla2iNW0fMN++/uM7g6CYlaDyhZeHlX6J/BJiYrj39suPL8/5GL6zPRblFPn5m5OLm+f5v1/fT738+ekr9z/mL0y8jDwf/v9k4vr++w8PL+ObP6DjKNn+MLKyCin/teGQ2vPvPv97np+cX9l+cbH8e/tfnO/b388K6hLPpT6Is0uzcf2W+C947uUN6b/SguLcb77+/MbH+f3PH+YvX+SMpH6++fTm+QspLp6bzKf0WYy5pN99ecJw/cuL1wxsyn8YWEW5/t9W/sXH8uX9n2e/f/L//f+f7cdvho8MX7l+MzH/Zf/4m0+M8z3LbwFG1ne/f/Mz/P/HwPkbtFqJ+TfzL0FG9udc3zjeM35iZnr87v63Dz+F2RhNJAXE+E2+fHsrxa/7U0hMkp//+f+vOt+EmL784Xv3TVqe2VJAU/ULaxaXqeEbrgeM9+3dpSxsrb9IvmH7+oHr3m8eHh4mYRXQ3v93DPdPP3z46/8HLq5/P379ffvj9uP7HBoCSpwC/xjYfjB8uffzJxcv79+PL9he//3B+Y3p0UsRJrbnrO+4P/xkYWP7+/MHM+N3Hh5pRSEhIwFuOU7Z25Iv7r368ZOFi/Efw3MpZgc3C0suWUF21e8/fvKKyTKw8rGLSHb4uWhoa3xk+v+Nk+3/z3+MHDzMv3////H9HysvMwPbL7Y33oKKv5R5/71lEBPh52Fm+/L9+6c3X54+efL7z8+XTz59ZP719sb3G88e//3xk4dXiInhHbeq3BvBX//evOEQBM0c8PEJCkkL8nEKPX787OGXb38Fv/NwyJuK6QroMrMysP3hYP3D/p0NdII1O9efv5zvRX9/fMfM+PrfZ/Y/f9j/cQj8YXjC+JWB6ed/BmYFtt8M/5j5/39h/c3MyiHDkxMeoC4kxirLwvOR8f7X93+//ZNTVg2IcOPhZfn/X/jtpefzjt59c/OV4J/fDAzM/5jZvj+5x8Dwg4FX6PWDJ5xcnP8//P35h1GIi1fo76cLb/98enKHQ0blN4cg+7+v3/58kmCXE+T/byQqyijy/zUfr9BvUYFvf9nF38p+khLiZVPnZPr8+/nbV4K/vv3epnDzFC/LBR4Gs2/MQtwyn4V42fj+qLHw/rzw5/vN1/8/c3z9+ZaF/xPna/b/Pxl//GX49w50TCbIJdwsXIrMusIcl2S+s30X/PaR+dtjPgFdbk1bA3EZYRFWiUdcX9mFhP8p/vnF8E30D/dXNh42pi8vv/8X/8vw5duLf+///AOtu+N9xcJvKCmiJKPDxSf/7dt/lr+CysLc/z/94mL58e7Pz8/XXzB9YX/47Qkjyw9JJnZeJu7/LIxsDGycXNxMXxjYf/HzfmT8IsfA8vnb31+/Wb79ZfjN8I2LAXT+BBs748/PP7l+Mf4EjWmw/NWUZGL5Ls2u9eXm288K3789f8X9l1fm9/8vfB+Z7jw5yyH6/ud73r88/wUYvv/7/5b7692/rz7IftFjVj3H9s9SjYn1l/dZppM/Xv758PsL259nbGxsTD+ZX/A9+3LhP+N/TsnfTH/YP/OBZv5ZBO69Pcjz4OsHTtGXnAzqP9n51Tk/3BP4JvaZ873Qx58iMqL/Rb++f/vxj6QA179fwmL/xP8yPP73S1RaXuDHXzm2/1fufDfRVfFSFPnxk4vjH8PPn++Z+GTYH96X1BJ0EFXllxf/zMzG8v7LP9ZvzGyirL+//Gfn+vn1y/8vXxg5eRh+somzsxhx/T34/LUMA/P/Xx9EZMSv3n/0m4mN/f2n25L/ZT+9///349evv3/LsDN8+iXPpvH6/jUGeREedk4+BuZXH/i5FX+8vfv4izAz809W9t+/Pj7/+JWdi03kpwe75v7Pv54+Os/wQ/g36y+2P5+//vnGzsnPIqjMwPSS/ef/T1+/c/z68otFhPHXh98cb1h+iTL8/cv48+0fDk5ePg53O1sOIe7XLN8ZHzF8FXut8Enw759/jxleSHJL+LmqLjv6huMl44MbN5Z8+prPx8Igx/v5JauIvPyfD59/CzCy83J9/8Xw//9PRl7BL79/s///ryQg/IWBQ+TD78+sX/9w8P/7/uL9N/ZXYg9F5eQTWEUYRcXZuXj+szLde/GHmfGN1j+Of4x8T748EHz8444J/yLdEk0DjbTD0+7cfCv+hfm3yH9xBm6Wj5+/f2IA3QP/iZWRheffZ5GvXA8YfjL/ZPnBxcDz5e93dnYRcXUWITVBIVb+b0/+aIpy71Z8KneHjen5s4dff7AJ3TIwtjj3l0nw/Qt5Po23bBxsv/n4mFhZ+H9zv2d9+umRgJ6hxnu2X8yKf9+9F/v+j0NG++aDA99YhF69evLz7V8mecZvgv9577K+1P3y9Tn3T4bnPz4yCXL///3z9yduoX8/PzP95v/w+SuD0G/QYMB3Br67X75ys3OyCv36/5X5Jy/7l4/fhXl////F9kHs79d3f1l52X58YNLn4VXgVPrF8v89F9edB3eF+U2O/b3IzMv37+cXKXlJvo8v+P/x/vr6/g8jw7Ufz55/+sbGJKb7Wej596+P3r7Y+vakhBaTiYORiAIrKzPv/x9ffnx895/jD/N9vq/Pvlw9deUbJ4c6v9Qz3g9X3r08y/j0z2/+f68ZHsvc//CbifvpHyYWtn98H1j/Mwlxy7z/9F6IiUNdXp3rO8vndyw/3ry7yczCy8b5/d09LT7pA5+f3BH6JMzB+5+Z6/9/9p9szBy83OxM/ySl5BPMDOQEuT7/ZWD9AdqE/J+V58f7dx9/fPvz/CGjkCQDE9OvX59//eH4zMkkxslrqS/89P3/L9yMP3/9lBYT+cv07jcrm8iv/5zPWf8KsrAy8Qs9/8omJPyU7eVfCRn+x6/5RSX+8nKJS3KpskqyMDH8YWJmZv/DZiwi9FXwCcczZi4FPkV+fRUBAQU+5l+/GFg4fv79zM/A+UX0wd8PL3/8+fTjPQsD29cfX1kYP374BzrVhf/f51c//vz8wyMkqi0Y7mDOr8LzlYmZ4ecXYR52hb+if5j/Pnnzi+U153e+JwqWBnZ6WizczOwfmZ8/fzP18NHPHz6rinIzC3H9/Pbz59v/DFys/AxfBXi4WP////GblZlXTFr8i6iU9pPHb/88eSkuJizMK/GV8afEN1kBKWkORYV/An9e/3r8+MmzK0/usLFysXxge/vt1Yk3b78J/f/3k0WAgUWU/2vIU/53DD8Efv3m/cly89PvfZ9e/3jwnJmF/S/7x/9M7Mz/7v//xc0s8oPxlyDj+9//2AQ51ETFDPl+8zIdZfgo8PP/ex4m8+sS3MLCT57KPHv//j+H8XUOZtm/Xz/+kz+z5cX/Dx8/8f8T4vggwMMiwyYgKiGq8EOAnYX75/tv33kYvvNw/GJ8+Zntq8CPdx+/sn/+yvz90V/J/yxMSgLSLxT4Ob8rs8uqsDB9Z2H/wCP8keMN61eWXyy/QVdr/AbtAedhZv/Mz8jF8OM3w+9/7D9+/fj4i+sv06d/PB+YmTn+/v/Hz8T4h5GXh4Wd5S/fz1933n78JvhG5rfAA77rDn+0WT794+fX5WD8/k6Z8/WPJ8z/2PjeMX7mYTPnlvj15+ctsZ86X6XY3//+wKr14s9LQzbx3w46LPvuf3z+68N/bobvHxiYBFi//Pj57df5/0/fcYgKsfLe//vrKfM7A041DbGXu68z/vnz463iB0VGQRE14Vef374SviMsrcH1mVGM69Pnr5xf/vzi+MqtJs9z6/1HcQ6G55+/fZVk82KQec/IyP7hB8P3vzyiP7i+iX1h+/2Gme0fBzezIAvXh08MfNxMTCKMX74zcDFxsYl9ZvzEBbpM9sNfFj5Wln///nGy/vwsyynzWZnh2q3n70X52BiZ2P/z/GVh/fj8z2O+j394WQSFOX794fzz9vW/L5yc8t+V1HU//P7w4TPD94+vHvCIs3GJMP97Lyoi+efx91dCv5nfM7MJfwAtwORm1ReTOffi3Y+PbxlYWd/zMfC8l/zJ8IbhDds/5nes38V//f3wh4WR4f8Hri+yX77++ietpCDAFW1v80b2D/8HHhbmnwL/xV9//cr/g0VAkp3xKdv377/5eTk4uSUdHNjfCxmc23iX99evBxe/rjV6FMHKJMogz6Ui/uUf449XP7/8Z2AWZGF4/I2Z4+3Pb9JM/JoSH998Fhd69+AFz4e7P37z8Ev95fnK+vTfd2WG5xzCZqwMb66wPZC9/Pr5v78sCkIs71k+Xf4gzvmdmfdp6dZHOkJCZ7895WP8IKrg8urpo69/7v85yP/9509mRl52ode//jD++szK/Ofr37ccDL9//5TmElMQ1NRmePeflUOIQfkLx6NzrKx3n3xmE/p06ym/GLv+L6knIg8EP/y//575+X6G/7/u//mvIapyT02W+9O/n4zMD1QETP5//3af9flTpu+CPz//YxB68ea9gog02wv2P4KvGN7/FJTglWTmf8X5lP/lN9CBoz8fM7AIvmX5KcHM/IeZ9dffv/8//vvGys7CyMH2jfHn/6/MX7i+C7AxfGdiYP3BKs72+9N/Dg7+79///v/1i1H8J9sngR+/fzHJMIl9+PdeWkpS7rsMLwc797tfN5hevOV6++v704dMj+R+sfxn+CDOICQj/p+Zlf3Jr8f8vAqsPzh2sT1SEpXTkZD/zPzjHs8thX/f+J3FJaU1GH58+f2fAXSVCSsTJwPLxycfbu68/+Ted45H76UZZbU/Mzx6yPvhi/gTvvf/fv5kYON4zfmaUfC7/G91fgaej88eXPj+l5+LiY3hP5uc0LePXz79YTr5+stFRp4ASQMZCXEuXk7GD185RLnY/0m/+fnm14MXPz+8//+Dgfn3z9+sHG/ePWfg4f3/9RU7Iwvjt3e8PHLsf779+csOukaD4Tfzr5+f/zP+ZfynJ8wgJaj46enL24ef/XjH8Pfjw5/fPn//8VOdge8Vx1sxVYlPPzilhTg4vjG8fMbAxSjO9v83B5eY0Mf/X9hu//4p9vnvzz+8DKLsbCzf/r79+vbauc8SUjzyorzqioIswtx/v31heM/54+tLVl5ehr8cPwW+//784T8DEzPDn38fGb98f8/IKMCp8tHFwpxFnVHmp8gThm+sb37+/PxfUISTiYnhNdOPXxx/2VkZ39/nfvf9228hIW81MyUz9q+c3ILfGW9teD770MX3nz///PGMk5WLie0ng4DItzs//nOxsDLIMjD8/v3i2S9+Afm/375Ky1x4/I+H6Y/AT94jX7mnb9364iODANc7AUamNz//CPJJyDAKPLz77jcTA+s/JpZPbN8ZhY2kpJy5PZR55Nm4tN8+uvnpz/ev1zl//fnM+vcXJ/PfL2+5/r/iYOECnYn99yfnH7afgsps8gq/3vBziLNyuD3XUP7Cz/eT4f37V9xv30mx/2JiZ3rjzWbyTerFJ77Xe76xfnvDy6L85eXnZ+c/Hbn8nfHdTyEhrWNfj9/7dO3Z8y8inz8I/eJnFWf894NDiFP52vdf/B++fZP+8pXjz4sf3xh/sb5m+PTn3b8vP9nfcLxj+P3z46vfzEwsX/j+/Gf8w8XA8JPtJ8Nv9l8sDBxC/1j+sDAwfv3Hysz0npn5L8sv1l+s/L9+/fjD/p33+//PnD9+sPwVlPj/g+nd75+PhZ/o/JfhE5V+/uP1x3evfolw8/8SePLzkamY9vefL8U41Xl4Pr14/eHZz098975pqYiysnA++PpKhpFDjEntKdMNFyHlF57/nu749OvO+18snxk/s/zhYv738/OfX+xPrr7iMeT4/+z9qi8fHn5kClbgNVR3v/7t3jPG91wHfnIKiz9l+8T96ek/VQVhZpYPZ+5zsrLfevVQXFiV8funX4pMjhpcIgy8X5g4/jEzsnCzcv76+Z/h219Grn+fnzDxiLIzfPrHxP2f+Sfrd1E2hs9/xZV/fnrP8I/xP89/hv/sjALcLN+//v/zj5WT5edv1j9ff/4V5rbWZn7ylfPm5xuf2b6yCrHyv/0m9Z3nB8vnvx//vzj3TpCPXcaS+875X4KSrAzfPnMzM75hY+D7+VeeW//Nz0+s7z/yCws9/fvrJzsDyx8xIc4PL599kFCSN/r39Jcg06OfjK/ef2L7+eXvXy5WDu7/P8UY2D4z/+H8+f8z02+eH+wsGlrCkX7eLByc/15++sXCpPaL6eEPFlWxf/+/MDEK8LC//c74/RujLA8bqND//onxEzcHf7C/xfrvd+78/8b95u3LD/9m/z2V7KwhIfqK7ddvVk4GVknO799Z2Bh+MXx9xy6jzPTz8ythXtnvXN9Ff7979ur8uTun317j/Md//toTVu4vq798YXvG/Pj/mwcsnJzcTAy/PzKzcP5Q/C4somzLaqTM8VibRXjb71MfGJlvv3n29aEYI/dvNubfP39+Z2VgZ+D5/O+nwF+m9/9+vBUSETbSl2Rg5bn75NKtJ1xfRVn+3Hn//uevZz+4X/G8UhTkZzOQ5Pvw5eS7F5+O//n9i5uN7w/Tt9eM/H8+izD8Oc+x99MHR72/Agz8Iuz8fwRe/f7B+ofzH8NrJh7+z7cePH7z4Y2kpITBl38P3n59x/OF/+G/P9ICP94zvGb4pvJP/Pevn/dAt0x8FPjD/JmB4RczqOPPyPqT7T/Pr+8//7J/YPzCyMj0j/GfOIvQuz+vuH5KPOHkEP3B8JmVVfTb32cs176fMOBVufv/l94j0RfSv5S+/GP5+0xWSp3j+d9bEs9URI2//7gtxCv5h+Uz0+9/GkL6H35/eSMq/OrjQx5+jn9f/n9/9/WUxGu+X//vvX/K8YE31ENjx76Hr67dZfr/h4nnL/tvNiZmvi8cz39dF+Ph/aHGyVMZ6/yDmUGS5evZv+I/Lrz6zfKe+d3z32wM//7+FPv48xXPewFxXlFmoZ/vXjz5/UHVztrk2/2vr5k/Sr6Qf874Xkpempvtz5fP/9hBe/f/iYj9Z/z57+d/Bn4W5k/f+YS5///78e/LD3ZONpavP//9Y/zJzsLy8xMbt9jPf1+Yf3xnYmD5x8r27dvXfwJCYVoqJyT+L9OTe3mHoXTWljccHxQ/sQj9ZWfmFVCV52L6zP2P8f/v35+5eXi+8v1gecz4/ddPTgm2n4+eMHCL/fn8/Mnd38ygnQfM39n5pQV4Pn1m+CbLbyEpI/Dr98kbP38w/Pv/8ecfhm///nEx/fryn42T4SfvXykJVd5f4d7ujAKsH758//qBgZfzO9f/vwp87C9e/xRlZ/73i+HNv98SArz/3/779uPjH2YW9vcsXLJcvOzCATZy81m2fz3PwMH8+uU9jlnMpzOt1HmU1H5+/cD8+ycjExs3G8s3Cdnvn7/y/n4vIiDxnf2b7Pf/PZcvvb77lpOTW1BQ6udHsVUvLmv/l7v958XVf+xMT7/+/vNZgFtVnVfoH+P7L9zfap5udPkteJrpqxArx9d7f3/dFGRieMMGWvfPyiTM/vP7G46vwn8/f/zJ8V9CXlhWm/sN21/ex3//fhEReM/74sPLn09//RD6qWAiyyr054/4P+kfr269ZHhx6C/rz98crD9+c/3/8v8f+3sO1vd/mBg+/Xwr+OrnZz5lGaY/f0S/8jH95vr15x0Hvwz3+/evnz/+yfX2y1eJ76xv/n1kefP6o5Io3yfef6K83IJv2P+y/n7x/AsD8x+mH38//fvPyMzC/P8f+yeW3///sTC9Z2HgYvor9IfzE/Nv/m/izzjesP0XeMX0UvyXxAeuV6w/vjxn5ORhkuY0fPrs2buXt/7zCoozMN1hfaDJbfDt9b+jnDdUf6j8+/hUiF3g99fvH/99e8Dw+8jbk0zMLPzC/7V59P//+aokyiGlqCD7guktK9Pdl0xnJN5JfGd0dVGSkhH5ycr+75MgIyvj93+vud4LMLz79/Uzp4qouBTn12dcT47dfcj19e+/u68EpcS/CzH/4BQUZZb5Lcr+6+mfv2x8fz88VtfT0lZSUBLikvgrsv3O6RUrL6+99lDi7/e/LEzf+IW//2JgYP/7j02A9dNrJgFBpi9fGJmZPn94+JeTnxV0diHfXxYOdgYG7g9v2ZhY/v3+/vXdb0ambz/YmBj+/uFgF2X/ycYiJdtr7ammZfhdn1dGXoSL5Ts/K5uAtJCmjsCTzz/v3L0jJs344uGvxx+/sD5h/i3AwMDD94/ph6iAlKCkgAATz39WAabvP14ws/788e4N2z+mN5++PGf68eexkLC4lAw7JyP3HwYupu//2D78+8MtwPj7K8sfZvUQmWA7Sz4V1j/PGQQZOYXY2b79+Pb+89+fTIxf//988uv731+/BBjZ2Fn+/fz7m0tMQICHi42H+8/Xd68Y+CS1xQN0NdlluBj+iTMxP31099P6/bfefnzz7/+/l9Jf/nNxv/7++/v7nyw/vv9l5/vLxP3s5pkZO/e8uPtdlI9XilfuBe8bbb43ngJWArzSxhxqDF/+sX7//uM/34Efj99zMajJyvn80TQTk7XRCAhiUX30/eON+x///PnJ+OvTf94Pf9iFfr9lYXvH+YPvO+N/Ngk+DiVrGTUdZc3/Ii9ePxViE+f48+rD+58sbAwSAiyC2swCRgzccuyvH/5/ue0l+79vf/9+//vnD/Ob/6w/RH/8Y/v7i5mR9zPT6+dnn9////gFKysL5y9udj4RdhG5t88uM4n9ffrv7d9b/D9ePXj2/i/rt39s3O/fvX3/+97/b2/fvuP88ZX3q4i23G+Rt5+lvzP8ZGT89//vX6afbO9ZuDl/crL8Zf358883FhbGP4w/eD79/s30jfOrAAPHO5anzN8ZGX/zyykYKzN9+/HlOtMbKVbl3+yfGBgYZH4pMbx5xynCo/NZ5M+TF/+5WZ6+es4hySPPZfLt1S0zfst/rD8EfvC+Z3nH/uP/m68/BZnYeCV+mHJLczJ/YnvCtJHj3f+Pzx2CTOU5JH6+f/Ljxx92RvZ/zAyM//4wvn655syVyvNXNp18sPjSzW1b978R+8Pw4p0ot4CYIvdX4Q8/2T68Yfp37c69J9+4ZUT5JGSVj/98sPHM4z+3v5h9//T08dv799+CVvB9+cXM8ZXhxz/uHx9+8Yr8+vPnFwfjHx5uDkaB709ef/7w7cuPT/+Z///48/snF+eff39+/fvLwc38n5GL+z/b7+/fOH58//f36y/Gf1/+/bzy8jcLA2dZXKC6vsEjJiYRFv6/tx+Lc7J8ey/49uErPl6eXx+e/ZfiF3375cfbP/+/f3v95w8H46+f/9h+fH/LzsnEx/CFWU6S5wvTy68fGf+/+cwm+4Xxn4oij6yuBAu/+H/+v39YvrL/EfzNLiirJWukKvnDhP/7d+6f3//++vAKdF4NN7OAKDfzz9+K/LwsX1kYOH+LcHAwMDB++/qX+c37338ZfrD8f8n7jefN/+t3Xqrqqnk66PPLyf5jZeH8x3Lr+a8Vm899evBe6JPQl893/n37zirC8pHj96c/399c2Lv74JeL1z+w/fj89+uvV7+f/X3JzsAt/OT/G+7Xv4VlFBkEfvz8/+MHM8M/9tfPv3/6/Z7hK8M/h8/iKn+//3/y9PXlv8xf/oCu0xHg+/uF8Q/7pz8Sz39z/WB6959TgUdYkVtSlkeGW/Ll1Q9CTPw/br29/ebf7zfv/gux8zLzMf/nkn3K+//Ji2unGRg/MzDxMDHx/P4p+ffvP9ZfzHcZuJj/cHz884OJmfk/10PJ64+//vrw9+HvR++/3n7z6/X7f5/uXfry5e+7P3/5Pol91fzO+IGFleM/9w9uVi4mpndf/rG/+/P7IzvT3e/8P8RZXnH+/PsXdILV/18sHIJ/v3zn+sH+6xczO8OfP1/+cf1l+Ppb9u9/5l/sPxn+Mf/j/PebUUbc+r8SLw/LB5Z3FhxaXz6952AUZPrH9o+D8dmfV+9/vDMX1Xz8/saPO4yscqw/n/x6+X2fsZzz+R/XJN79//Hrp6aE9nPOd8w//+1jeqXGJvzj7RtGtp9/WFhkPvw/LvjS8bu0kD7zt0saXz49+8r0meM/OzOL4B+ePwzv/j88dYeNl0Hgk+A/bga2pyx/5Bm/sn77/eD9bzFOnnsfuX4Kff7z/st3hoPPHvi//fX5183vP35K8QlJirK8/fZzy+27UQzfuSXluVk4vvz79luAm/37v5/vPvBwsn/78JH1/182EaGfT7+x//7x5zcz45/vvzgluD+9+Mf+/w8jKwPTp/9sXFysf//9+c/AyQy6aO7Jqz+i4lIMnI9/fvv18RPzl3//2d98lpX/8e6HuAYzy2eZb/++cjBwv3r2W0JBQOY72/sfDPLSQp8YP3z7w/6T/aUAt8Fv7p+cT7795eRl5RX8/+Mn//NPDIxM/IoabFcu/VRge3qH99f/L0z/vnIL8f5nYnz/85fxX9GvzP8YJBm+fmH495sBdIIb4/9Pv34w/mQU4WP+85sLVNazMLFwMLIICrL8/vGPiVXgAcdDpj/ykjy////XtJD5+kNg54nrzE8//GYUfnHvzZqXd1PEWEUU9JnZ/n14fov3B8+vD58OHH16580PITkWe2PTo0cefn38+J/IHwZGJqHnP3+IfttyfvmHzzysj1glhJm+KYrwMPy+8+XpDcZnbwUEWb7u+neL4fd9lt//PrKyijJ//P6HlZ/l21/mB2wMopxcvD9l1MV5Rf9fP31j37177EJsHLysYow8krwff/NK8fF9eS3M4sTMcfPOgwvP3zO+Z2Th+PHrAwMDEx/LM85/op8ZXvIy8nxm/cL1jfMHG4Po5y/P35z7clyMVYT/L+uPb2L/BJmZ+W8ysv/9ISDI95XrF99bXua/7x/8F2KS+sD4kekP69t/78Tfc3/nv/fxOZcAN9MThv9/33wTZeN6zf7vO8d/hoe/GZS5/3B8E3/K/JLjN/t/1l+fuZjZv3zm+Svw69dPDnON37IMCs/k2Jg0mQU5/3Iz8gvd53j1gvPb7S9XxNlULX4ofv/wSpBNiF/wK+8frld873+y/v75/y3TZ7Yv/75/F2Z5++vH9X+v2ZmY9P+w/+T///D3r9fMP3h+8L9n+cX86O0h5nsiSrw25lIC0ux/meVBhwr9/sn6m5WN7QfD588/v3J8Z/vJysjPzPb55f9XH5/+/f+KneXrz2ePOT8yPJL/9f/760evd19dfeey6V9NATZ+MQleJg1RGWFZuf9vVz69/ObFm5+MXDx/f3MxCvzm4WFmZ/vNycHCxfKfl/v313es/Px/GDh+c7B9/wc68+kXE/uf/ywsXDy/vrIwMbH+Z+f4x8r47wcDy88ff9j4GP/85v/69uun1+fvfuf4y/D733/G5795Ob/w/Wb4wfLn929WIXZeWWHG3085Gf5852b6++LVa5GvDFwMDFq6psJ8vN/ffvjFysom8vPPt38s7CyfuX7wSUnwMbHzqCoayIqKcEj+5//J+o+Z+SfXl3//z2+//eX77y+Pf/AzcDC84RaX4WFn/MfO+Pvvn39PPv9kYv/Lw8789M3nD58+87Nx/mX5+/UzC/Ovv7+4mKQ5/z979P7P1/8Pf/1ysFYz1zP4L87HxviekZH1ydcnndsPf7l87ef31yIS8p+fv122+9jVh1+4lbiycsJ9XL1DnXT+/vn15wPLx2cPv/z7cGDLoxcX/nx/+OLt+x/v3vwTesbO+vLPFzZ2djZ+FcmPqf99Pt7/zfbtJwMb91emzwysXH85vzD8+fSL4xufAKu42l8mjm9vvrA+e/KdgYFB8devzx/ePH/z5OH/b4yMnzhMtLgUBa9cv3LzIgvDRX7Wv1/+/vjKwMTAwvDzH/tb1vfs/wVY/n/+wMzDwvKD7QfbX65vTNxM/54cf8vx5A+3oOwXge9i6toKXCyC7Mw/ud9zM8rJyPH9ZZL8do/x+b+/v38y/GP99/vVv0+/f7J9Zfn87uVfln8cXGIM3wX+8nz68ekTI5vo/6+vfzL/4PzK8V+E/d83Zha2j985+f+xvvn/mVlJipeVmefBn49fLzxm+vvu54vf93n//lX7p/Ln5WOl//L//r69//HOc653/P+5uX4x8XNKcf/hucPP9PEnswwL4zXRb+yvhS7/fCjEIfyW7dsf/n+Sz/8qcTIzsApJ8nB8Zv3Byq7J8PrFE67/DOp/DGxNpHm+/vvH84fxA+PP378ZeFm/CLG9/vvlGcNn1i+88vxcPxV+c/75wPrhxxPW/1/f/L799fYP3iea7J95BRgePjl25y6/uMx9wU9Xnr/TEGM1lVfm4+Dd8ODOu8cv/3Nz/eNg+P/xy79/f1kYGP5wcH3/8J6ZieX3zx//f/xmYGbk+Pz6j4AUKxcHGy87849XXEKC37+9+/uD4RczK+M/0H33LBwMrH8YvjIIagryaGtKPOL5/vcjMwvHd9av/9/9Yeb885tDlI2NnYWbhYdTgPX5719fGX58evPq8Zsvv7lZP735yvXn9e3bHI8f3/zzmo1DBLSyV4SX/8f9r4/v33n7jIlPUdRIj09C3ICBl/X/349Mr35+f/Bh9u7j/AJszCyfvrP/52T+//LDV2Zupj/MDMoivC8+M7x481FFW5z9P+tfVhbWv2zsLL8YOH79/vuLlYNNWpLvPduvn3e5H/N8dHWwcLe3/iLGxMrwhZeHjZmBdfnZMz8f/jqz48y0o+efPfrzW1MzycFOgEfpgcAHQxN9GxtzZu7/D198enj918O3Lxk/cMl/lebnYPjF+u7j9y/sMsL/3t9XEhK0Pivz9PEjht9s7CyfGUT//mP+BRqE+cny8x03i7KwjPRzDmXN3/yc6l+Y9Ng0eBgZePm5eH5I/Pj5SZxZ46POb+F330Tf81+9/Of187s8/7///8PDIC3CxcT6k+Eb4w+mz9zvmL6zMbD9+/bvIwP7X4ZfjKBjnZj/f3v99czr7y+fPvnJwPL84z12CW4jSSlONvHvIh9vX3/M9/kHK+eHv584v3z99ont+0dWBubHf77yf/v7ho2Bk5+R5Rvrd5Z/f3jY2Fj//GBiYGNhYH//5xcD4xeGP////fnD9f/dCxYGDgVZdWl2pjdsnP9esLEz8zLdY38uzi/zWOAH+68/kpzy//8x/mH8LcYnLfVD5J+E9H2OT09+3/j597P9F4WX326c5/jF/VHwJusrXgZG6e+fxT4yMDDw3/l38xX3b18edUl+Xs3/LP9/fmJnlZX5wfz+x/u/bA+ZFGQE+P99/8//n4GJhZnxD8s/Vkbwutin/778fu/wj0/JWMtWXZ+D/wPzz+9fvwoKhhvOyczclO77UUeahZlBR4WVh0v48+9fQurSf8RYzSW1+P7+W3Xl+qd7Lxj/vubm52YT4/785vWfr/95ubj//mD8+uM/IwsDJyv7X0Hu128+MTD/+fXm5R8mrt9/vjOwcf5m+c/26d0/dsGfv/8xfPr0C7Rn6v9PIQEXZV45PpXHf1j4+Hg+srBxcn5gYeb+8/r977//br15y8zEwPmf6fOzj8Iy3AL8XK9e3HnN9PH1m7/vP/x4/O4jK/s39q/cfz7/evz1x3fev58+vvr7/sWbKy8YWf+pavPycgr9/f37C+dXzo+MX54+P3Lo2t+vf4T5Xzxn+8bJxPL3K7OMOPfzV7/Y/zNKSLB/e/GVl52Vk5vhJ8MfRjbmH6//8rBzv/vw9+vbn4JMDNJMjMKgmWV+OwM1UUP17zz8ZrJiHrp83wS55u44s+ni7R8ffjJKiSVnampo67959+7diy/3pf5nxnm35EYd/cBy/NxTti/febg4BQT+GWqJcwuzcbIy8b7gEOZQuHf5RsvZ0xO2H/z0/+sfKc7/jz6yMb//80v216f//Hw/ZTQZvxjIvv//5sef348Y/n1gef2e6fuT5yy8vz7zi0q9U3qs9F/xttTnC7eef3r1keMP+y+O/0xMb1k+g646YPkr/k+ITVtM7ic398+vnIz/eRl+/GP4/vkbK9PPn/+4Wf+wMTAyygp8ffv0+xf+S/+Pf2H8zcj27cWbj//eM7xk/vFDgPfXn7+Mv55xvGVk+/HjM9sPttcsLP////z/7tcPxv+CH34yfmbhY2T495ORU+7ff8b//4X+f2VhFP7N9J39Jxs/rxyfrBz/Z3Fh3v+/fwh//cb+hUmIT5KJk1Xth9TTL7cZeeTYBYU/ff/y/9cfDgGRuw8PavxWVnonwsbJxinOq8SjasmqbPiPS+c/y2eun+ysIvf5/rF8/yQqovLjJee/X7+Pf33w7j+3MDPDb44/gvz8jL95XvIyxKgqKOuYcch++/+DgYHhLxvD/y/cH9h/MH/+xvfi9N/7P95+//XVlJ9XhV/uKwcfixhnlIU6k7TiARXpLHeL35KSzGwsL959E+NhYr33nEtO6tnru2L/3n//8Gz33Sff3zK+//Tg99v/f3k52P/9AO0S/fqGT5Tn94dv3z7+YGbgkpQX+vXt7z8etr+//v/58Zfj/z8GFu6/HOyMn5+ycvP8Z+P4y/ab/RcTy+8/f8Ql/IxVeEV+X7/x4f3bFz/esf//95dfVpyRiVFZWPjdj9eiAgI8EiLyrKJs/PysH3l+3vt3/cmTP//eg1ZNf/31W5BbToWP8fHr71/ffeMQ+PX5/zehTwIiSgoy/MriP0V4BH7/YmZg+vnnw+fzt+/tu/2Am1FJ4sd/Dm7Wd28/vRX8IScvyPjz3zdGJk5eFgZh7p/vvj289/EnDwsv19/PH/5yszOzy/KwMLP9YOb49+X7hc/PfrJ+y9GxlzUR4VeR+Kz6PVxZS1Dyiyonq7a4eFCQq4io2K//vz+z/2J88l+ERZBNRsHYTjeo1OH/P06mfxx/hN4J8P9nlJMW5/r+T1ro3rPH/x/+fsXGwPaTSZxblI2bkekF0x8lTh5WTSa+7wwsPKJq7Caqap/Z2AR/sLM8Y3j54tGb50ysr1iefnjK8JdJWJstSclcV4Df/K64oBaXno/wP0EuRtavDGw8DIy/vwqw/mNjUhUX1lI2VJKRYRD/wfzj1z8WJgYOhv9///399+0nL58CKzPXI5Zr/36wf3rlwmbBKSvEKyfGw/CTnY2B/edPpq+Mv/89//GX/zfzn3+/2f58+8nAyvVD8hvzzz+gdfav2dl/y/3+zsjEwsPw6/5/pr+Mfz78k/jE+lToh9AvMU1BVX7xT/+///nMyPrtC8vPnxyf2ZnYPv/59OHz4bfHeCU0mX4++/vjJ+9/tv9sf16+viHJI/eJ9/cd5kfCX8TPPzn17y/zA9bH73hYhCXE1JkEz/5+wvb1E8cvQab/LP+Ff3/jYJRnZFDm4OJmFzDg5H/87KkiC5v4D9F1wjeFxD/IiMlzCTD/+MLwleU793eVn8zfWBnefHvPePL5s597Hjx59foUC6tFhUV/WdK2xx8FORgcWcT5P/KIiX1/95Gb+y/jk1tvjr748uzlww/y7P+5JLS4BB48fbr8zWneP7yc3Ey8HMLfWH+y/vj+5jcbEz8Hu6Ik++dXLH++/PjKwvzlG+Ovn0z//7Iy/v/H8Jvh0/vf/5l+cQn+Z/oDGsz8+Zfx1xdGRvZvP75+4eJwU5HlNeZm/cX549uXP19fPb/16dPXn49fP2BmFv3767+kCPdHAdb3Tz/8//OZheHrdybeP/8/sj0T/sL89/8fhv//mIQ1lb9ysfP+YeJk/8Txi+Xl8+9v7nwVUpEXk/rFyvX7z092Zsa///9w3Dz+atfx80ysAsyCzP81mAXfcH/58lpcSvD/H/afbz/9+PLz49//stxf3r748U+Qk4HtNzcXF9uXz18+MvCJcr77/FX5LfvnH1wf/rL42DjbOds7ayQKm6r5aTt8teT+yM8jLcjG8YH3zrM3fDzsZupq/F84n/7585qTLU7PTFlZ/vPffz/f/b/O/v/V17svWdmZHjwX/MZ49s3TO7s/c/5jZhf6zfqd+R8LA+sLvm9/XnH+ZBRRZlQVlbrO+M/8G5Mun/o3lo//fvxg4HrPJ8PBJyYsZMLJIyx6mvH+g1efLnz9ayQmqsItycT4l/krBzMz+7+PP5kZ+PgMGUSYeK69+6ArLejgZPidmevfxw9//zP++8XIzMPy4d0PBnnRm8L3FATFfrExvfrHysctaCDDxycs9vzb/9/f+P4//snA/efPV8bPv/9z/OX+xfH5z6d37M+4GJhZGPkZ/kp++8/18Bfz+/8M/36yfOP4pvCPkeXvi5+/+H8qiWjocwm+4//8+/t75t8/fjCw/hD4/V+Qmenf/7/fnz9X45BmYGV/+uXp/6dPGbhF//1gkhQw/P+P4enXu7ICKp84/3GzcAqx8Eq8/Mbzi/P3J6Zf3wSlvv+R+MHJLMr/8uNNY0HxU3/eMP1nPPPpEQ8T39cfwo/4nn/8x3mP/TvPl89CnKzSsvIs8ix8YixMPzh/s31nBZ1D/Ild7AvDS+anT5k3PGbo8oud4pNr5GUawC7x7M7tQw93bP9wT+kHqyjDt/+Mv9895+X/9/PLjY+GX6UNhLmEjGVUBFk+v/x09OHjXz9//H1+l09YmpGHX0hKmP3LB9Zvfxh5BN8y/vrx+SWzmAALnzQDw7//XNyMTOysHMy/WP7+/v6D8/dv9r//fzL8Y/j7j+nnd6ZvrD9//5cUZLGSUuaQ4eD/w/aFg4f560sOVh4WZiGOH59+szK/efSV7euff1z/mQU5hOT5+dh+c/xh+/Tz0cNnP5VZWZ79Zn7P8539xc+3LEyMPLJ/vwiw8L/4+pX5z08OSXFxE1GJ/+Jif/8xM35+9eP176sPb9y495jh6TeGh0w/uP9x8ogxs7H9/fD9GzsXy8/vfxkY/3NyyvKwPbv9RVKC6cuf/5/FWL58+MrE+e8/AyMTL/fnZ3+ZGd4+F3jFycDA8Y+Rif+NnYtmlK6DHM+3Y9fPPH/wikuJW4lNnoWDkYGV7eevzz+fvDnx+t7Tv8/ZPzMxfGF5+/rr87M/GW7+evGP79XPb5zfmAX4/zN//fDhNf9vxg+M35n//fn27xsbO/cfBW3JN9zv///4rMyoycb2l/01E4uAtIE4r5gCk4yRqBAXxxs2Fu6L399++csm+unX8xcbrz9h/P/j/99/f35/+c7JLyr3Rfk79ytRJl6Gr08lX+oyKpl7Kvzmkfz36zcz8x+GdxwM7G/f/XvCxvhf+h/zNxaGJ/+fXnlz8d9PUOHx6yvDf967TP/Z/jCI/GZ9zSTy8eP3dyz/xP8wff7Pzf6H49f/z9yczzkZPwiy/hNj/PWB64/0J7UHDH///mUVEdDmVRNh/CLJzvzqD8MX7t+iP7kYJVhes/z/xsLEwMDDISbIK8Z/5+GGP2KiNzlec3Py8Pxiffnn9t/X30RZhNi4RX5yfwVtBn/7UZBD9PK3Sy/+PHvD/vPNn29XeH5/fHiDkU/106M3v38y/nj8x5FRlVHslxT3Lz5Wpdf3rji/k/zOK3DnB8fHFw8k/wpzK0gw/+f+/frRD7af7H+kf/7995/p9/efv94//f7//28Gbqa/rOwcL59t2nXk7LkPil/+8kjJPebk53j7W1yGR4KPR1FZkkOK/7coy6fXt/iEpV1/iT/6+Obs/ye/2EQZv3/8+fv737//GL/9Ad29ISjCzsTHyc7w99uvHx++cXCzM/z98/Pvj/8MrNx/GTl5eP6x8f5l5mLj5frxm+EnIzsb0x+OL9/fswvzcv6x1NT9KM4vxswnrynEwcrO8e8b99/vbP9/8YqzfWNkEObk4ZaX5P7w6/U7Jtb/n5m4eD/x/Pr6+ZswM+PnIw/YZYQEvn/l5GNl5vj69D6TCBc7u9gnPhF5RmUhFaEXDH8ZP3N//vfr7Z9P7DtPnrp47QEf968/jP+/fPn++9dnHj4WQW6GT1+Y/n798eUbGwMnMy8f+4ufrEy//4l+FZaQ4fnx5ifXn78Mf/4wCvznYhMyZVb8zMr07/9X0X8Kr1kZRcWV9RQ1n3x+v//saX1WcQ5erhe8DCy8LILcbDd3n6jumfb+4t0/3D9///rw8+7H9+8/vPn8882jO9////r7+x/Tl5/fmbh+M3748Yed6f+vf0K/GH59YxcX5xL6+Y9H+veVN+uOXTt+/LYYPweb1J8HjGL/hH9/F2P4+kjq57ML7/5I/5T8xfv79amXL5iu//nz5t+fPwzf//2RVZSQEGRjlpTg+Mz47uf7T9e/n2b8YMAh5+Ci80fo/99v/xl/feESYOHmFmb4z/Hn3z9xHnaGj68Yfv478ufFpw8fGdnf/f0o9pPpNdun74zMHIxPeZlFvjJ8/838j4eF4wfrWwE2xg+/2Bj/s4DuW/wnzcz85TvrZYXfvB+VZWTtRYzui/z+dPcdB5MAM/sv9s+M75hf8jIK/WH+yMTC9E+QW4r1K4+utLv4Lz52DsWnjx4/+f2Ij437jwA3E6fEk2dnZV6xSrDKnPl57aUwiwm/wR22JzzPXrOxSrM9+f2XnZnt1stz/37o/WH8yC289d/lB79+v3n3QvSN4HNlFi5ZQYk/AiyPPrz6/e2L7AcNXk5eQ0EmCU6uz5y//39gef+fkf0fB8uvf5/f53TOXHVq0ZkTF5ecuMD04Kvwx1+33387/uzGo5+3mAT4WeV+vRb5xyAt++b7tfeS3JrqpjKaYowszHps/59d/POU4/6XR9+E2FhZBAUYWNj/szOwfvvIw8706ycTExsTFx/7749f/vz49ZuN88f/////szIxM/3+/ePXV9D9sSz/v//++vnrt+9M//4z/wLd3ifNxmCjLvuO+eevz2Ks/KzCknxc0vIM///9+PSP8y/Lf0FWFYZf/xi4Pvz9/ZeL7++fH8LvP7/49+vU9wdMjNxMv37yCon/fv3qA+t3cXahl0LfGV+ycfL95mb7riagJmjCy/iTjeEPA9OHH38/fDl97cunu29F//O/4H/74TsDEyMnIxMzlzAHBxsrNx/7r19f//Nz8P/6xSTA8uTJ6/+/v3z78o9ZkOfxw9ef+N/z/v7B9esvEwtoRoPhn/i3j58Zf/5Xk+D20jD59uXXjWd3fr15LsHCzvDu/Y3Hl3tXruY4/pGXV+Tnj9//fsl++fH131c20K1eP7i5edgZ+P9/YeT+9Z3t7983TIwCDN/+/GRi5tcVZzfme/uR4dPN9//eicmys//59O0205ev7L+kmNk5vwkzfft459dd9i/inHqM8sL/r94V+3jkBxNou+wvRkl5JRUJTREOAT45BjZmBmF+/n8Mwj+Y/jz9ee7vJzM9NV8Tkz/8Ar9+/2f/KST4nUWOi+sl0/+PH3++52LlZhPk/vjuH++/v59YGf7/+v2f5w/TVyZW/t+/frK8Zv/H/4fh97e/v9j+Cr7584uBiY+Rkf03AwMT41vhvxwgu/mVpAyt5e4zf2B++IHtzy/m/7/+C7IyfuVh/vvxzz8Gzk+cTP/+/Hv85CI/r/iP71+ePb/4m/Eh84+/7EL8Xz5/efbxjsBfZkFGwUc8r99+YXso8P/d+2fMf/5bCzoJyHFL/OBllGPnZxb9JfxXkIfn28evhgIc8ozSltyyvGICn4SeG3KqPnhxj5GF/QHHJ9bXvL9Y/2vxi0mYcPOLif9mZWVi5GAAt6n/cTMxf3vD+PBVVcG02gl9An8+cvB9u8z1/Y3YP3EB2b+vX0gpyor/5pPkVX3w8vy359//Pf0pyMXN8Yv5M/eTf//FpT89O3j+5ReWX7/efWL5/f03699fv5h//v/z+cPvbzx/f3769+n7hw/fGf9zsnF//sjO8J+Rhfnnn9+fvj5l4mD48ek36HRnLhZWNg42xp9/v31j+sfx7dt3AV4OEX5BJu6//95+4eTi/fb2y+vvTP//f//y+9XrZ+/ec3JzCP/j5GNn+sL2+zvD269/nr9/K/X49z8h/t9/P71k+PX27y+uL+z/+L4Kf+L+x8b7Tfy/GIcaAx+biaAEi6QQA+M3UD/rG8+nH7d2n3r+5f1zhU+czP+ZmDkYWJl4Pnz8yM3DzMzC+PEtA/cvxs9fGN6/fP+b4f+vr+yiMrz3nr6VkOE1+MnDIC7xkuurEAsTIxc7M+h8GZaXNy7PefxM6M9PD3ONLet3zNq78fHlI9cuX2xt2sX+lpGbVeonA8tv9j/6ahy+uhY/ub9++/idg+E/0/+fLJ9ZmH58YmF+xvSF/z/nu798/MwSXNJSzHqveZSF2NUUtBS4Gfj52f78+WXMKOvzXfEr8wvu91JsT/4LcTLysop+Y7t+/euPlxeucP3h5vjN8FdQWIafV0rpP6eSCB+LCOMzFi6mTyJsPBJCokzMP1nefnr144eVmXGApjaDgAjHu5fvuPl/MDJ8e/nwF8d3DgbO/58/8LJIszOz/v/xmYGRh0Hy+59vPEwcv//+ZPgnwvXv5b9/UlyMH5j+fvj7Txi0gpSB4fd/Ng7GL9/e/xcXVPzqrWr29P6jP9++sDNKsAhzfWf+x/b0N4PAPw5+0e/ff/2U/cvE8PaToJTcxxe3fv7+psquJvWJ57/U70+vfv/6/Y3hm/DP/x+Y2TgFvvKKijMKfPspxab67e+X5y+uff/z663Qd0aWH4J8PGK/BHg/sz4R/nrz/5v3vH+evLnzj/evG6fdva8vv/x5zfGPQfwz2zuet19uMr6UfK/zh0VW9a+oBPtvZmZGdj6mT9//ffvILCzEyPBB8Bn736e/7vL8uC3IJfbxrwWzlAQjj66eriwri6Sy8Ln7R29++nv+6sftu+6+unGf5ycDJxM/0/un/DIyIh+/H3p9/+6H3/9+ff758S+fCA/zHyZ2bkaOX2y//v3j+s/GzMnx88+bz79Yf7P9+/bt+48Pb9jYJf58BV1mwcjL//8/51+GPz8Y2f6wsbN8+f6Xg5OZkcVGjENMlu/mi89fHjxl+vvxPw8LGxv3/0/c7Bx8v598/vXt59+3X3//ZfzH/peJiwN0NBmPAM+vbx+f/Pnz6Su7BO/vH8K6MsKCgsz///79euLrP96P35nZFUQkDM3FOMUF/v/m/8n0nP3r/ycfvi2/fub9lz/s3CxMbN8+f/0hwMvz9/MfdlYWHg5mTg6mT79/C7IwCnH/e/7x848PH1UEucQF+Fl5+Dl/fhBnkvj9n5ORgZeV69mfT0yv3v348/ITEw+bDPt/ZVaGG1ceLpm9YdacOcyP37NwcDIy/mUT/K/mZ5SSEhyT6G6b7/Jbke/Xh29/377/8ZHhLzfr778c/9gZGH+wMYq+41EVllCU5eb/Kf1e7NurS7/FGG4zvmeU5nzw6/YVZvZ/7//+5v34/wGPsISKvPTflx//P9vzgYOV/Qf46F4RXiFZUXZmPoU3f//8/f9JVOEfL7f8Fy6uF99fC0tIqMmpyPKyv2D/JqEpqiMv/k2Z/8ObM1++sWur6L9jZWB6/5qTg5eFg+cP639GfsY/n1+xv+JiYGH6yfKBi5eX8SUzO8d/xn+sfxk+c7HyMn74+5+Xk/UzC8OfDz8F+BW5mCxUlG/9+fJdhJX/LQfrn9d///P/k2P/zc7z5+e3/x8ZBHi4f/39x8QrKsv49ed3JtA2nXeSX9794fjNxszy5S8XvyIDy6+/v/48/PQAdOQdw2e+//xPb965+OzN5W+vXt39y/jvpQSf3KGXh96L8rFKgVZk/WHi4PjHwCTIyv2F6cP360K8UtwsXGzf32s7qksJCzD/4vvy6vW3e79v3f71/SeHhAzrj38//rDwMvz685/hwx8GQUYeDoY/nKwvmJkFfrIZSLN8esP4+9PPnzzPn986dfzWzccfvu5/+vX61+93nq89fP8H0wchcSV2BanH12/ysIgyf/t4+M3ZTy+/cMiI//v8BXR1379/TKx//7Oz//n3m5v1D+8PNhZO1l/fv318942Vh/fL+88/mf/8Z2Jl+PGTneHPf1a2n3+ZGP/++Pfvz59vPz/8/PqLhUuZm0fORuDq63+f37yR/vVXXFGSVfwv7+/PnzjePX/7/9u3b3/+fGFj/ifMLsKnxvXj9/e3jP+5OVn5OVl/vPovrsr27/P/n78FRCTf8/LzsLALcn37+Zj/regPER1VPjb5t39/8P/h/MX68+frE+8OnD53694jZsZvL9jfszB85RPnfsDwmfnv39fvvomz/P/NwcXwj/07159/vxk52HlZ/nxkZOfhYeNl42D5zfSL8c//d09unb906/C1p7ZCfG9efGVhYZGxMpKTFuHhkxbml+bk//XtP9c/pu9q9lq5lt7PJYXes3HGyTpbVJj/kZX8+u3f778fmd+9Y2DhZ/jx7Q87l4QEl4UoN8sdjtOPHy09fO3Dcy6OH4ySX/+rSAsKsIv+/vGGkYfj28NX/yX+8sl+fvP+w9ON7/6/Zvn3m/0Hyy9lAWY7J8XfsgyM3/+xPvzzk4mXkZ1FiJGB+T8Xq5iIgaCoDC/vP3ZexgtP7kj8VpL8YyWtyCyl/Yrl66v7t6U/c6oISj79/YX175dPLAwMv0SYuP6zsHEyMn5k+PyNgf3vD56HzNw8fz79/8/IDLr88O///99/fv/35w8Tm5AKo7ae5LtH337cfffrzpPP3MyfmX78+vWW4daHf3/+cf5n+PH/M9P/T/wfGZje8T779uMz7zfGjyyfH7998ZvrO9tDDgaWv7/+v3zL+ZiZk+e1CMsDBgYlZq5v3BxfeP9/ufvzz032n3+/SApI//z8XoZN7iXTO9EvP37zcL5ke/PzIePNtz+fvHt95c+XL49+/gVts5OV+8VpKcgpKPzj3VP2oxdefL3z/8efL8wf//OKs/3/9Ocf8z/GX9xszP+Z//xl/M/44ufHD4e+crz//I2L49F3hsfPHlx89/bdox+stzk/3v/24Of3nywML3+/Z3v7luc/Jy8vp7AUj4gQhwIj2/8nHzeffPj2yk0WER4mTmZWxv8/3rMw/vn659vfj0w/fv7nAA2x/WfhFeP+++sfw38GFj6+vz+/s/z6/JOJ5fevPwwM3759/sXw68sfNg7Ob/9//PzLxMRlycMtpyx15TfL69e/P3/48fzq20vfX399y8z5+cv/3z8Yf7L8/ysqxvBckkkKdF3nt9+MYr8+8f7REOH494/zg+hHMT6Otw/YvvCwv7355CMz9/9n/MKSjAJcYiaSvOysfP8+M/z99Z2Z6eO9S59PX7/38TWn9F8edgHeP7+ZFdlE/7Ax8CqxsfMLfH/27fabt1pSglJCjLyCzEw8in+///jOz/2PlY2R87PQ57dXHnHcf3lXgv87Ayv3C8ZfL1j+Cf5jsZOUfMvEJSPPoywr/oeXg1dJI97e5ysfy9fHn55xfvnwm6FExaF7Rtw7YTUWRnHm/xwMX3/+Z+ViNWNWMpAR+sJ7l+3x73dMYiwcbOIsfwQZuRQ4VdXkFaUk2WW+sSnLfdJg41LguHb04d7jb5g/cDH9//aL7Q0XnyCfjMjZy88ef3z5+dHvH38/fXn9+Mdzplefv/xi+KHHJsgrI8ki8pfpF+tfHnG5ByxMcirM/wW1eOW4P30VFZHn5mC7yfhJUV6RgfEP59M3fxh/M/7m+Pr159+v31iYRH4y/+dkFP/+8RMXIy8j998fPxj+swowfP30l4lf20mnxEHvuZDkc4G3DF85uX4IMvL8ZGAQ+P/nPxM773+Wj38YJZiZGD+x/PjFzsD07cE7Pj7JH1x/ub7zGwppqcnJ8Mrz8ipJCbBxmnEaMjIziv5R/P7jydt7TwX+/OBn+KrCzsnNzsX7mfHm90f/WZhFfgrbMIu9ZPvN9/u3yidmHsm/r+79vvXq66e3v/+x/ZCVUfrJ9+8i0x0+XqlPDN/uPHn24ZMAx98P/z99e/bhOffN/1x8X/6wc/x9/YKB4dc/Jq7v/96yPvv36e2rXXsfbn16hvn/c2lhbmslDf6/nx7cffZXVLRzVu7BtVlGSX6P/3N+EXn18ekNQRk95l/fOP/9FeGR/Sv6cffLR7+v3/70/esfdlYePhZ25r+cslK8HAK//jH9Y2L4+PHvny/v//7/yyrJ+f/TN4Y/P7+zs/369YX9z3cmJlYuXj5Gdvb/v/7+Y/z5n/H3K9ApQKLWMpx/9Tm/vfv6/NoFBj5Rjd+8nNx8Xxj//OJi+8b0+QMDw70/v/m+/xb4z/33DzPzJ1Gjf1JMkhKSP37+fyP94u1zTn1JkW+/2fk52Vm+MbD++Pf6A5uctLGqnoQ8BysP429mxn8/RJg5Hjy/923bgQMsP/+D9pcz/3rw7h3jb2aut+yvv3z+KP5NQ1Gcj4GbmZ2TiZnpL/NrDl4ONrY/zH9+c3/4ef7ps8s3XjIzfdM1VOYVFzMW5+f7zf6Lj5uDWUhD/fePvwJcEpzy9tK5gaZPRT7/+P/t3YsP4u95pQT5vrEKWMnq5be7MXAwMvxkYWL7wcHGrKok9ZWZ4f6vX2IvRLg/fWRX55HgFeH6/4/tH9vej3fu8/z79vnzu3cvWW/9PX/i9ZPz71nf/mX8/+03Oye/JL+spMyHN7/+Mn/lec74l/vDD2EuRgb2p08//mZnNZeWlNAV+f79/9+3bF/ff/4py8rB9E+Mgefvn1+KH/4q/Jf+9O8HOwcv5ytOlvfvlHl1+QSFWRi+/v39jY2Nm1mIm/EvH2jRJvsXVq6/oFNwvzEw//n659Xz/5JckoEy6YpmbJIGgdIC3B+k/n34+oX55+9vf/+wfv/7gw8U5HyirJ8//2b9zyzPx/zqN5OwmNK7V48f8739z/X//Jc7H1+/ZfnwienFh0/fGL9wc354dJ/55W8VXhlhRo4nr77dvvrnOs9Tho/vnzOxqDELv/7zjllU4Ofnv9+Zf319/ufXT7Gvj58JP///9s9nZpbvUv94zn56zvDgqg6Lymc2pn9/fn36yM7D9JT9N8+vD1++vfqsomPX2t7A3m36jfXr/zeM/9mZQVPLv378/sv37umTr+cYf7LJCPKJyn7+9k3InFvdtrMkytfSVNogoMfL75Aml9B95r+KYr+/fP3Ayvj1zx9hQU4DWeHfzD/Xf3n3+yMjz4/v/9g5GBlZGd+9/vfn358/f/6/fPOfi4OZieX7+09sf9kZ/vz+zcn99zfL75//vzEyffv08xvLn38srP+Zmf/8/f/jFyP35/+v///j5ebJk9P/bMX05iODNNuv98Is7Mw/mPQli/NCHHK8YxwdeVU57/1m/8j9l4uViZP1zTd+1i8vvj9l+f2f6TcDCxPvz7+P/7/g+c3JIfBHhEfk1QcWzvvfrv7/bCzCr6Ij+f3fz++/XjL9FGT+9/nO/bcXLt359vQzD99P2f8M/FLcHz58evT8qRzzf1G2b4wc3H+YWbgYmJlZRIUlhHmFOZmfPD13//Wbpx+tuVgszBx5OGRYWH+/4H7E8u/XnzcPOAX5tP7x/ZBkF/4ry6vKyyoqqvhJ/Pr133IyYrLS4py8LO8+/Hz27afBLw5Ovl+/GH7/YWVkdpKQuP6G/b/4l8tvHv24wSAj9e/J1/cfbkuxKz1i4/L4pSz55Ns3AaE3594+eP/4x4uHXD95mRgYmcTY2TnYpCQlWf5+/MjE+P8ly98v/1gZ2P8x//r648Vf3q/qkiICSvJ/GYTfv370+T8LI8N34b8sr5j5WZn/yBuJnnpw8yLfw2cPXt74cUdcXuQbN+Pjp1e+fv7PwMDGwPr7L8Pv35w/mH6+ZeD/wv5FkPEX959vrxmYBX68Y/qrIGDjZ52qbPycifvxx4+8wnz+OqL/eDl/8XzlfMvA80uYXfQPMwsz848P//78Z2bi/XXjKxsbO9P/Lz8YOFjlvygy/PzE9PnX8+9fGXklPv5jf/76OceXr6xcQj9ZPrF8+vtZ8j/zA56/bP9YXnC8e8n9+d6bk/c+/Drz98OD688Zn7NfZRJikv3O/fcrzx92AWaW1+yfHn27/fsRx5/P/JKat38//svKI8oszyfKxPrvx+/vvF9FpMV9bRfOLgnxDyy3i+d2s/z9/Sfji/f/P3H//sHF/e032zeWP3zfH517ufPV1R0S/5K7vU+vyHujqvPu+99/DP8FmcT0JHTYuHikhWUYhX6oCfBx8IiLCgr8f/7dkJdbjf3XhT8v/3/7wcn8n4WP+8dPxt8sn/99//DxP+ufj+/+cHLzcHJ+efftOzsX0/vPjDxsTH8Z2f7+Z2H5z/SP5dPH3////f3Dwc/B9vcv02+Oz39/MrD+YGXxFRNk4ZV8+omJ7w2LuJC4wHdRCa5fWS4WbnYCanyWz788E2MSk+b5L69l9fzD28+sbwT/sn4X+P7936uPz74K/9P8xvSDk1H8PyPLN5bv934/lRGQfM/OaigoIaEh/u/Xp1//2Bm/vGf4xX7w+q1rjx5xMYqxCHE8e/KJjYtBm11GUk5akBV0zDkjA8OXv784/n7++/vXp8evNr95y/f5t6qiGJ+sMjvDN57vH35y/BB5L8EuKcLKKPJfgJNFXd5VV/7e17f8x+9tuHj64q2bhoYiKmJivziZP7EyCP378ev5t97Vaz8/esPAz8pqxa7O8P/1D0GBhy/ZePkklOSZpRm4eX5//ipy6eu9fzffHz//5MK/p6/vvfnw/t3vD8KCHKLfub/+/fODgfu3rBznv9+s35hZWH/94FHjYuXh+fHox/8H3xh/C0oqKf15/vfJw5Pfvr5jB+0xfPX/J/O/e6/k+X7///3t+rvPz6Re/f/2nhW0spr1z8vvnJ/+XOF7/J/x7/9/jAy/WZk5/jLdZ//+nZHrHe+vrz9/CHxkYhH6+fUDiyJjXIxriKjyH2YmJs6/bG+/vPv7n0uQ30Jb6+8v0dcf3jP++sbwhYWdj/HnL+bvsj/YPjKwMzF/5WJiEuLkYWVn+f/rAxsfvySnqAK7wLuHj58J/+TmE9r/5dhfDkYm1s9M3KL/fvG843j5498Pnt//2WU//2Nl+HX++6ev/34w8Lz69fmbzFdejjdCv/5IMsmzy7CJ8LIy/vv54M6X/69+Pn/z46owM8/TF8JSgqxMX79/5nj3l50n0HdzVTGbrMijX19NmaWby6OZjZR/Mnxh+MTAIPT5J8NfRl5G9vsiz669unvsj5WEVYy63gdZMXMxlisP3ly9fWX/1ZNmbz59/PPpwdObT559+aMsxCXD+IeZk+P3f9Yf3PI/uJ8yvj74/92f9x8ZWDnZGT+x/BFmEpZkY/jOxsPz/zfDD3Y+1p+ff///yinG+//bty8v3rz7/OUPO/t/hl9/uf4wMPxk+f395zeGP4yM//9++/HzP9MfNk42uQBz4bfsjJ9+vOFlYxDkY9r08cmLV4/e/v346MENAR4Jlv8fWTgFH79+r8zIKSAt+e7ne9ZPTOzvRQTUJH79vi7MJ/Hp9/8v7z/z/GaWFBJ9/voFO9cfVgUBNzlhBTXb7/8/sfEwM35+x/SRbc/V02/uP/n8/Ns74XfSDAzaWoL///F+4hBkZWDg/cvELCz45ev7d1fvnX373FlAiE9J9NN/FjYx0Y8f//wREVRkFhZQVmN6+ZqBgYGPg1lKXFSBSVjNkf/GU0b2qydP3Xqv+us5v7TIeyZmTmbW/5+/Hdp76cHpx2yM3KLSf0W15XjE+dmF/l//w8D25Yc02z9DFl5uZsEPYi8lvjDx6At8eX/vx0UGhos/JWSklUS+8uvx/2RiZuL5JM6v9pf1DyeL4B8WRl7WH1/fvmf8/+cf78d/jII8wjyyUkL8kmzf2VV/fGV89vLDX1bmr39YXyj84+Pn+cPP9OPvU04GaZZPDL++/xH4+PfXv0/XGb4o/dJm+P7hPwMDMxv7v++/GGU5ufg5v/79+4P7C8sPhp9/WLlZGXLcXU0YuZ+wcDO//Pbt6z+2P/9+vX35hUNURo7bXpmLj5f3Pcc7pi+v3jH/ZOb9L/hOmJHp429B5r8/fjE94nz5m/cvu6TEk99vT1z7dO/1RTZBob9vfjz6fUuF0/rc82eP2Ji+/XvD8/O/qiIP94dvP3m4eF7/+szz8Z/AH06FX89+vPvDJ8nBxvLtyY9H7N/+sP7n+/j7qySTGr8Y1y/2N494vv65a/FZ7M7Pry8fPPn7guMDL5uyh3F5iIkIJ/+tTy/+fPz44+0vDxmDddNr2Jxt2X++4PkAqrP//uL8xvPgI8OH329/vHp768yX5xIMv2R4+f59/zr36NLXR4+9v3l9y4uPt38xagiLCzEISopKMzJ+YGCVYv3z9RzzB8lX/I8+PXvy693fdx/+CIr++f+L/c93Vi4WTnaub1++MzD8/P7/L8t3tref/3578fjZ+58773+8/PIN05s3rMxcP7+z/X7z7C8L838mlv9sXAxM35i+f//9h1WIgy3NUP49j8CPb3+fnX7z7Ma7myc/3z38SJpTkOP7mx98HO85vvz6+PnVX4a/Dz7KiAtw/uTmF2RnefdRkEf84+dnwjxf3j99wick9v0387c3v/78ZP39n4FTSlpXgUFYTurH968MjLy/GV+yXRJdumvD3ecv9VhFuIX4PrIwMjD8Y2N995fvP6Mkp9T3r1u/PVrx+Jr048//f71l4OT8xfDhy8tnDAygspCbk/Xnx68/WJkZ2dj+MXL+4v3+R5XdVdLYy9LwzldFxqfH+l5dePvxraYE159vL6YvODZv7RaGzwy/uL9xySjz/OPUYFMVEeZnYed6qPLy/meZu1/ffhN58fkP8+U/70TufPjFIvn2x8/fgt8ZRBi/mcu9//qWX0KcQ0iY8fMr5p////P+Zmb5/ofp3/+3bEy/2X5KCSuI8ErzCgj8/MnM+l2YlfXP3x9M7P///mDmFfgu9Z3/FufLm19uvmX5/oeVgY9XkYnvv6yI4ANhVi4Gri//XjFKy//79+3vTwZmps8Mn37/+/mPkfkn6y+J7++5WIXZ8qP8leXlX/KK/X7/9etfRnY+zo9vv/z++e7Hx+9f/r1SEdL0MJRj+Cn6j1WY/y3Ln88/vjL/e8f2n+X+5z/cn5g43zHx/xZ+++nD7affWRh/sHBKXrx75d2dT3yPeZ8+f/Xj0Tfmcx/3vbl76OnrD89ZPugz/Xn99yXPLyEW4T+Mv/6BDuMQlXjPyP6F+Ycqr8oPLv4f/z6J/H//4t9dlm862kofuc7z/FY+xXDzMzfP/xdsDH8E9IrMZ+f6Sn9lnHrj7tlbt+/cfv7i+vO3Hz6wifH2liRwKSj8+vOD/fU/HkY29qeC/1h/sL37vmnqxYL9E+/c2z3l6epjt1Y5fpD6/fPvGbbvHxk//vn2nkFY5OPXFx8+fhbiEGRi/8zMxi3zjfP//Sfm7JI7ft178vojw+evrN+/MzL8+sPC9YOBgenvH1DV8+X/58/ffzG8YVE1uKv8X55T7h3Djz33fzC8/fj3z6+fogJM/379/fSF7ffP778Zv3/+wPrtx3sWIS4hbk9Do+9Mf94yvVV5x/Lt9+tbfxlYfjEK/vsj9IWR8R+7EOPv/79/C7Myfv/wg5GT8c2fj2/f/H7J9Jf97/8ndz/85OH6++M905+/soJiH5h/fn7x7ifzOyZ2QX2l/+I8Cr85/v579+k721deJSkjOQk+Lu5/PMKc7Czcf5kZWNiZfv4X///z7J+/LBfeu7Dx/2Tkf/+bm+E3k+DHv6w8LFx/frLw8T95/egPL+vP39/Z//36/fEdy18pLnZ+Bj5WHeHfHNJv/jxle7vvYfHhOXcv3Cy9sf7skQMCv/6zCwnz8omy/v2m+ODPp+evvn18piz7R1lSVObvmyucf5lERewFlJiZuc/++fjz43s2ln/cX/jfyoBWfrB8Ufks/YSPQ+gFNxPTL7a/Hz7zfhD/xc3LLsTKwiegyy/OIsApxC/CLirDyiD59+vrV8/fcv3jZv769cfv709/PTn8+eZnNi65fzyivwR5fvzjecXy8u93iYcv2f/9EBCQ//75AeMfjr8cP378EGDk/vv/3x8Ght9/f3xh1RWrDnYUlJO8+4v1y9Nn7Kz/2YRF2Z7c45eR+skoC0qMfMJ/xASFhfhNNcU+/P/65iMT809u5l/fBf5yMStxM/0XYfSZEi77mOsuy5tPdz8qiIn/ZP7/7MLbH9K8It/ePv/MzvL65w+5v9yfuL+w/uaS/sP/WeYLw5s/fxgZ+P4wcXKKcvK+4vjGx86kzSTy7vm3X7wc/Ax/vogyi/3guXDvzod/P759/mPNq/JB8NeX/z9eHOWUUpfuaPL/+Zv70MVbon+Z9GTlfrIzvfv0nZmNTVKOT4aX5+y1S0Vzu39v/cjNy/CDT/L37w8MfxlYPvz9qPLF1FrUXkJIkMmGgYtl78vbz17d4fzLzsnKzsr0+zufoML3L3Ls2lf4Llv90Xj06MXf798+cXC+lWX99Pm/j4SCEAffTx52Li7+3+9fMX359UeB+8v5eyx6EkrskiLiitt+Prt34AEfyy8VPl62T++5pKSZfnxlZGFn+POXUYCN+d2Hf9xCDAyfOVk5Gbi5ONnYPj582bDjYKiuMt/f/1LiYmuvvNIQ4fj9g+H1d0Yx9o88MvxP3r34956fXR50tvuvJx//sAuwSv57d/H/P5b3nFLMQnx8nx99ZhYV/v/i538GBhHZn8/fibG+vX7o8udP378qJ6pGS3KJcOn8ZvnKzirxn4n3L+NTrpuvDoj+l772+TenoCr7h58cIu8Feb+/eCXKxsskKfDj1/dfj19ySMq9ffDso9BTvpdSLP+/MApIcgvyiYj8vc72Q/K79L9vz+cs3sPy/dkLXhGOZw/u/vgh/IFVUJD/y/c//zhYv3P9ZuLhl/3y48tfThHRL88lBXkYvopxCnz8zq4lxfRa6Pu9E2/fn2P7K//MXcr6rN7NLy+Yxf/JfHj3mPM16xcmDoafX3j/MvxhZGfl5WBgYdMTEeBXEuX+wccpwc3189/HL//e/Xzx/wvjbz4GdQnpR7+vPnn0iZ3hh4SU6N1PbB/+3zFgV7//8zX/73///si+/HtCllP17LvjH/aL/P39HTR0xfH7z7/vf77zcumLFxsrscor3v/5i//txw9vGUUUhZiZ2bhYWN+++/GH6Q3/p9/veUQYfn/jk5Jiu3/jDTvfoR1n3rL/lWb9/ItV4e+v5//5uZnM/qo+ffjx0zOWH2/+P7zy5d+dh19/MPz/8eHzt6+/Gdi/8f///e7P98+/GDgZWEX5fzDc/fnvAzMDA/tXbi5RVqY3n5kf//zzjuPvxz/v//z7yP5FQEVc8Q/XE75ftuISYjIsYv+kL3I/1RcRYfrNzWanFp/myS8o9PTp29c/WJSkxFjF+RjZ/gvwsnOxM/z98ePJp68amuodoUkcykqffn76/eoD638uZgbmP/zMHA+Vbmz69vo5y62PZ2d+38f07B+nEB+3CMt/Lt7Pbzk+PH734inb9seXTHlM/zD9+8jHJy7IKyIia/GR1UhCeD/Ly1cvnrN/+fnz+6u//xi/83N/vPycVUJJ+ivrz/+MH399DBQUFhbgEfj4WfDHFyYewY8/rrKysvz++f0/CyPTr99MTBx/fr7+/eHXj/8sP35++Pib4efHzzJ2CnraKgp6mlyKYkmWMq/ZvrHxMkoxPGbi4vzEwszMJMj7/wv7Xy7O77//sIgwMH75dP0RD9dHHnVZSUYelo8835kYf/379YuT8af4d342aWamjwJCsipS/IHBBl0O1mIKHr94+LlYlP+wcf349YnjG8f+B6+uzTsz58hVZgE2MXVzBll5AV5RSQFJRnZOoR+/2Rk4/vEK/Gb8IyDOo8ahDbpMm5P/x8snr58+ePr3heJPIREuNiZh4QATU24xRU7mX2zfJGRYxEVklV7pfPvNw/jr/w+Gj///3n/z8AXD229fz17++Pro14+3vzz494xfgesq/5N37xjf3vjIzvpZ5JPoA9H3ov8EFLiEmAWZOdl5VKwkGNTe/GT6y/jtFyfzf+5//ALff/7lZ/7w9BcTw9f/L149/nzr9cPbv/6x//r7SVLs97+fXz+zMvNICDIIc5x//0jk5y8hBmFeFhZGxl+M3znvsJ7kY5f7+fI91zvB/18/MDJz/hf7/Iv1EzMD9z9+XpHvvN/EJN99/ir85g+DECfb3x9s/xn+vnrz5evXfz9fsv2X+MkvwsX4i4ub/dOjp1/YOIXZf/u4aTL+ZXv5jvcb96t/LPwM3xiYmFj//xD7/+XB86+/2T5zv7v2m4GJU4DzF8tPVmE+fk6uHx94/77+IfKXVZiR/e6Hr1yif7+xf//LzPPt+/d7DO/ff+J4xvLuww3m35xcCty8TMyfH3z+y/lX9M+3r/+ZTKRUBJW/cT/mPXX7A/M3BgNNRR8Dmd+/WHbfeKbGxsDIw/brzw9Gbtbfv3//+/Xr0/sPX95/uPD4nYGWQVd72mcf3u+MH/59+sTE+p2Hk5mN78N/Rr4Vp68f+PBI5MNPBoWPDNxs39jYvrx491bkuRAr0082hg+fv3NxsIsrqDJw3fnwh0GU6cv1nxz/bj4Ufvpq3c9nHz+942Lk/MPE/u/LN3YxIRF25j8cfIwf3r3//OP7q6fyfBySvL8//vnPyccqwqbJ+O/nv79/vn/5yvjl6ydWdnYWoT+MrL9+f2b68J/z09dvSj9TtFyEZdWY//3+zcTBICpiL6f8iPXDbz5xth/f/z94Ksr4n5ufnZeN9fWrL/++vf7HJsDOL8UqxiH1m/PdL6aPDN/+/+T7/vghaFffu59PXr35JvPnL98fcTEZeVmNd29/s3N+5PzP85XpK8P377xsv5hfvPzKyMzLxxPraKktK/+Ym5OVnRt0+a8EP6vUv3dv3v599YGDk4nnL/P/P/8Yv3zgF+EXERVkEub5+OL911OfvzFz/vz28uvXm8wiHK7G+v+VWAQkfouos/zTYDPg42PXZGH4zcvwj4ntFwszy+8//z6ICPCoaP8XUuJh51V6y/td9IvArQ3vmX5wcqqy87D+u3zy9fdb//6deff1yT8+5k93zn74c/L/n9d/v6jwfVFklJXikDeSFmCXUVWV+C/AeeP2p3sPfj598/7Rm0fff31j+c907dOlJ38/cT35+u37f25m0f+CP7iYxK/8vCvGyfuV7z//R+6vn3//FhdkYuFjAi3+ev3nDTPDV47/PP/4Qef1fzj09hrLh3+fef+yvPohoKf5/907Zi7G71xsvOx8bBx/f377zyUozMLMyfrv628mwf8iCtzCUv4akv8EfjC+F2b5+56B8Q/T9VPn/whw/OJnYvv2iZmRW5JJgFf/42/2v9zMvxk+vGOzUvnBKc70je8Xx78fnKy8woz/BRl/fP7yl5HpL9uPz68Y3rH8+PWO5dqTZ1LP/rAK8r9m+/D32+/nN1/vf/Rq8+lrb94ys4l8+/T229c/318/f3f61v3TL89/+fZZXoyXn5X9158fH1++/PD944+fv398/f/p8w+Otz9eMLOZ25usLmsUMlb6zfz93xum76Be+v8/vz+zPON9f4rh3x3uz/8+/fnDwHzrxzdQ4/4/E7/gr9+v9XglmH8zvH7zRFfKQlhV88/vv0xvHr//yvrkEdOX388Ofnv+5slLJobfDD+/MX5ifsP05ufv/2wMDOwvHt0+d4vp0wcebkFuEcH/H9/+/f2TgZnjHyf3vy8fv7AK/GP+/PU3Iw/TNzZ+0f9c/N9/fhIQ0+Hn/P/x1fPX397yfvzA+v2HsCizo5jWhRe3mXk4vgoKvPrCwMYl8OHfFxYOnn/crDw/Gf9wMvz6wfmP+zc/07///36zcH+VU5dl+PtP5Cfrl7/sfA+Z//EIMHO9O3j43PS7N/68ZP796zXjT0Y21h9PH7+a9+TpO9l/3m628rqq/0WFuf9zsbFx8LL+E2MVZGNXuv/29/33r9l/M7x+9OTZ49e3fvD9+vWSl42NjZ1fUFycnZf7xvUdQn9Y+ZnUf0tz8wlyZKj5fJQX+PKTnfPl2+f//jH94PrD9p359/+f/F9BhSgjM4sCo4S+2A9VPrPff/n+fLn55e+PH3+VZbmMxYQ+K4lISTC/vv32KRsjy9NvPz7+eHfvOyOPgrgmC4MCl5S9LJPKe/b/0v94P/188PL1gzeM7N9EuFgY+WRV+YXV1eV2/rj/n5Nb+hrDR8k/0tzcslyyn+6++Mn3Q4lV7uXPT2xvvrOIijB/fs396+fvt6/+/mFgesv65y+vuLmAvKHc768/vn/9+uPmq2+MHOw//n1l5v//4dUfZo4ff9hZPvxlYGX59fsrNzfj6+cfvnz+ycnKxP7v5a/3n9+8eyOqKBvrbPef6fP7n4wsb98xMTBz8n7+qa6k9F+LmfUr73uRn58//OB4wvRWienv/28Mz14IcXJw/2T49f7Fv3/84nz8Egw8jGzfvzF9AR+jzcf7/yM3A8czUcaHf78+/viBifnn69ff7r78/fXiy18Xfny+/fvJ608/P39neckudPJ40eRlwtc/a8v92X7x5t3XD9+9/vjh0+dXD9/++v2HhYFFgoOLk5Xh6e9fzMz8zsr2FTZWLDx/GP4w/Pz8l+nXD35m0FmnLK8+3Lvx+u8jVj5O9r9qHJwcPP+VxT5//cyiynld/O36Izee/f339Nc95rd3/yiwSEsJv3n/+c+7D5K3fj75/3XP6yc/Xr758/fvL6G/jG//s//69pOZ5+6Hl8+/s3H++cn8h4mb8dfHX+y/Gf9+/v6d/c/XHyKsTH9+sX/7yy7A8J9T4P+nv8wMX9g4RTg+/mD68Pv2l89Cv3m+83D/+f31C7u4NMtHe3OnCy+eM77/zvKd+efvDz+YmD79fSHOKs3y95ukhJDAz/+v+b++F+X49uT7/99/v/4XEBER/i3Gx/j81a9fv7l/svzlFJTgZBC68W/CjT18bz7ys3Ge/Xn/xNnXlhwicaoWgioqbPwCfz7//vPt079/f0HLXv98+/LmGcuf7/8+sj24ceHEm/tfFPg5npx884b52c/P/AKsPHwMDMKsGjwat3/9eP3qKf9v9ntfGY8z3TYSkWX6w/ny3Z+/v/8z/ActGeLk42Vk4/z97ysTC9evh/+vPnnN+eXzwY/fbr/9/GP7T3Heb88VP3+RFv4o/ZtBh1VFleePAud/nn//PzOIcrEwSv9me/SL7Re/1pOn9/+zfXrziPnddz41hV887OySXDxs/Ir2nIIKvx7y/ZD5y8b67xebloTcX8G/rNxsf959FWP78fHjlzfsXxh+vf32hPf17x9yUl+/fP/6Xojx9+ufTOxK+lwJdsZM70VBzcrPH3/+FBP8+pCHg4Vf+NvPP7++/vnB9ffLj/9/P/3++fPtx8/ffjMws3KwfPjHxv/6GQcjCwsTB987xq/s3756GahxcPG8Y+BmYuH7+4Thu+in/xJsrJ84H///9PvXVf73nIycJ35///T+03fuXyL//wt84rgjKPSb9T/Dh/8SXP8Z2X8xs/P/4v4u/vbvLx5BAX6p7wxsLAx/Jb7Kc4g/f/769xuufz/+czLxfnn/jO25wGfO95+ZPtz68OXXndclZ1a/vMLsqKnA8OPfgXf3ntx6KcjDy870/z/bry+/f3z9xyzJwvz/86e198+8/vw12dlMVI7p78/Pv/9yfGJkZ/794Ssjx+8vPx6cfyXw8AvL7e8fRRhYPvxk+Pzxzb/fkj9Yvwg/O3Hh/IUHN95/ZeNiVeYX49KXE2YT42JkZGL//u3B67tXn7/5+OMf868fzNwCn/6+e/XrLwe3rLAQ239evq8Cwh++/Gb4+5fhLwPDn7//uYV4f3Ax/P3zh5eD+cevr3/+/fnx/QcrGyfjP8Hfv5je3pNn+8/JI8T56xszJw/vtx+/hKX0pDiNTUy+fgOdWvb1D4cwA6PCd5bbn9694nnz7t5HBiVh4Qvfvjx78/PPZ3Ex+c9fbv5nZGD4+uUXH9OfPz8Y2P4y/Hj/7z/r7zd/+d8xX//4/sG1K8evP5Bm+8Wjo8zExM3AwMr2i+Hv3/8MTOx/Gf4x/f//+uWX+zevfv/wVYDv5+Ov/7UkNaXuvvjwV+gB88dPzz+9f/dIlJGDjZnr/9/fvx6///L32Zf310UYGdQ+iT38+dpWkp+Vi1PolTwLA4OAEo+4AbuK6L9/Yv8Y3//9/fXXhxPf31778+Ps24/rfv7+9InDQJBHWe4G8xenP7LqcvxvdLn4JXgMlcUUHfWYzZl4xb89MxRmlb7zhUvy+4kHV54+vnb10c8Xn7WlFXlkGEXFhe7dPviS4ef1j3eZ33znElLkePn2Acur179es/xjUGAR/Mr2/w/jc/XvCnwsFvd/P/n78PeXB9/Zfv78xacsbSGS4OMhLqTDKs78l4ubiY31679nD99zfmVkeHn3w48fbMy//v7hEf335y/Lv2+M7NycnKygOcOvzH84GMV4P//88/f/r7//3n7/xsLLzCFip8LLwSnK6Jni8JqRk/cl+wcGxq/vnzDKfuL4ov6b5R3zX6bPd7+zKDEJv2b6zsv4g5NFQ0RYUIjt5p33nxle//3BzivC9/cVwx/279x/vnwXEzUU5PrC+/87g+jd7Xc/f3vHxMwKWk3K/uIPJ68Uq8YP6R+8P/7/4fmu+EPltcI/d1tzWSYuNgZuJkaGh2+/yIgL/+L9I/BfgImPievr1+8fv529cJjzN6eEzI/vj94077j1+f4LHi6270yc/0W/c74T+8X+hfcf21/z/+r8Qvf//5b6zP7l75s/74Q4ZN7wM6hKi/zkEJMWYhdh/PRYnEXp869vz/89e37/+6uPv15JfFN9zG+np8IiJMwu8YfjE+uXT9+EBfi/sPH///iCnY3xOwM3D/P3T6+/MIvxcv7mZBBk5PnL+vvr9z+Mv5h//WP4/5tHRPjvj5/fmdnZWdm+M/7i/sX84/9/TvZ/35iY+dhYGD482s78683mG7xcUlIibIwKwj8ff/r89ss31v+c3Ays3J9+vxT4+/vzB25mOU5Rhj8MV98/VeKQ+Mjw8u/3/0yMbCy//ghYKKh8+Pfi09tjd396yf3W1DP5JqLAwPqL4yvzF87/nL9B2135mZjfMv26d/4Bw7Mzv7il7//+ayIr9uvP2xu/OUXYGWX/Mjy69/6LGr/6DzYBJamnzx+xfPj/gvGGqLYT46unJ/5//nThDeOnD19/8b79d12anfvFTyZG1b8815m+if/5cvH/W87nbA9l/7K9Zfj9n/kf2x+O9xwG8oZaQq/kJTi+/nvL9ombjZXpNfOfVx+5GNnfKX7i5OMTZP8n/0vq8fFbj15++/nww5/vfMJufC6CzNKKwUcO7nrI8YBLSVSCSZqX4cvNz1/1uRUY/37mYhL7yvj9853nv3/9f6z2TeAOhwDrDwZG4fePr//8K/n6221eFZMISZHfaupiHEy3GL9vPrPr/1teDzN5TRHZyze+sH35ysv0l0VS6vmVu5xif1n+8TMp/v548pOUlPDDt8zCwsxs3D9/fWD99fUtn4LIp8efhFQk/316d/XmJ0bDSG/27//YeVg+fP/KzsH9/+9bUznj3+wv7917/+ru3/9/3/xhFeUW//2b5Q/bH05O6e+/n8uBuj4M3yW4uN4zfWdnEvrP857rj4SEApugqOCF00/fHrv14z8zhxAX8w/uz78/cTIxsciD1m4rCyh//PGWXYiJ9wXzDykhAXXWCH7Dr9zCjJwMPExcPKJcjKwsX798u3fs3OP7j6WE+EQ0vvLyWnF8eXnz/ec5S9Y8u/OGm5OdmV3sN/evf+9+sDAz/eb+zCugrq/6/paQHO/3zy9/v5G4K/vL4K3cS94fKmxin7nkRfm+/PvAx67F8unVw+8fT/3/8uc6aGmOOoeolp4ar5IE189fDEwM7O/f/uYR+/PnA9OXv6zCgqwMfzn+//nHzv2V6bcQA9O3/6zfv//69vy5qKos6HheDk6Grz9Zebh//njJySvJ+PkbIxPDr7/MXJwsPzkZeL8zvhVgPPv80cfzryUExP78+/SLh4vtG+v9J9el9GSYPvN9evmEX1WK6ek7TgmZG09vM39j/83yRUda9vqDzzzC7ILfXitJ6bz+9/HSlZva8pr6WgrvNFklP4p///WV9S/zr79fmFg5fv//+eXX359vn705f/c7F98b9s/6glKfn715I8bK+ZVRjY/z7Yvnl3++k+ZV4uP4LaYgx/af6du3f+d+nXn166cxh7TUN+GnX/8+eHrjnbKM4bvPB/98vPLskvInsf/iCn//Pf7x4uuTn58Y7rIx/P/1n/cH4zem/8xy/37fZOSWYIricPqk+JL72W9JGc5v7x9sZ/325YloPB+nMLsRB8+tqz9en/r38/WtX28EGbiff/krKaP3z4hLZ8e5a39//jX1k3zH/l/gl8Cfv3/UBDm+/mXk+vLjnjAny5c/wh+//vvFJyzO8I3tlzCz4Lkzj94K/vGW1pHgFPrMzvTm+XcRC1Fxju8s3+Rf8H1U/sT77ff76+9/MT98zsrH9e/Lj+/ffrPwMjEy8f/68JtNhoH96YtPnPwMDH942Pn+Mfz78uU3O8tfXiEROc4/38R5P974zMQj/OcLz8efH19///+D+80Xhv8Cz/+9YOJl+cj59bfYt+8/2f79/f7v/Y//X/59/PHpzUvmd79e/nzN94eF8e9Txk+8P/5/ZmN49ZflBx8Xy+//L9++fP/+GwsLryj/j69/f/1+z/SP8TP/jz+ff7Lz8LKL/eP79+/7iz8v//759e4/x3um519/83Ow/2VlZRLgZWdn4+Viev381do9h8VE+d5z8jOyy/z48+YdCxcH35c0Bz0+Hdkf/9mZfv9hevaFiY/9H+uP/4z8P568vPGHU1P4B4Mgpzi/xGutN8xP2B79fvXiwsezH28ff/7qt5j0R4YXLKx83L9favP+4fjC8ofj7dlXr5+9fPrq/K23Lz7+YPj+juH/z6/fhBj+scrwMP7+z8gn8IeB+T87v8h/lg9MDC9ef/756S23IMeXr//+/mZkZmL9x8bOyMjAzSrIzMT1n5nlJycfKzfTn9//WD79+c36X/gHiyOXNLO0+LvvT399+v/15QdW1l8qWjoCP3j+/PvPJfSH7c0HbmGhv1/eSIqKcXF9V+DmePz6PctXBllhIUkppe8/3j5m/KSqoKFoKMUoxKv0Q5SN7Q8jG9cvdgYmRhbGX38ZGJi/3Hz04dmTjz++v2X5qsoo8PX16/My3wW/csmyMt5+8+2UPJsqrzofi+D3H79u3r34i5Wdn/EDv4gKw9+fxz9d2Sf+/TU/48fvLOZCvObq0n8N+EXlFf99//f797XX/z+CWvtSjAyc3/7+Z2D+yPdX8s+/f7eZWbmZPv76sfTduTN3bj1n//j3/XuOb9/ZfjGJsfB957O4I/LpEM/fs89ZWV4zfGD5yfmZ6ZcwJ8und0+Zjrw7DzpJ8Q/Dp+dvVLkFv/L+ZP38/NbXr38/MnwQ/C/55Zss8+/nr388F/774NvHq59uPvv0/L0qa7CmhYyowkeun18ePWVhY/1w9Mmfz+x/GL6KfWX7+vfv3tdPmJ68ZWL+/eX5J9AYJRszEwP7y/eP2Dh+Mrz/+fk/NzMLDzvv//9//jP+/cUhwC0iJcsnLnL9w6Pnp9//FeZi4n/GzfCD9R0zE8u7f/e43r/49fbO4xcXn72XevKLnZnr77//DCIfvrKxfHvzg+UbHw8fG9Pvdz+/Pv7z999Lnp+crzn/Cnxk+i3+h/3p/Rtvjz76yP6DQZJL9PuXzwy/GX7zf//Hxs76i5frGx8L05vv3z/9+vPtG9NPPSnhUAf9z6z/d126+vjidVFedlbuf58+vbt/9cHiHbv4Wdg+MnIKcfx7zs7B8fXf91/fvn34KK6unBShxCPM+unLp38C39k+fGVkFWX9yvaD+fmH878uvfxl/OLnR/bvoi+ZPn/99YNZmJ9NgP3Nn3fvvzO/+sjI+fe1EAvXXym+O3+41UW4X7Gw/Pp28PS5V+KvfjJ9+nLj+U/G33+Zvn/4+Jv1BxMj789/H98ycLFz/H77hpXh+7d/zN/efHvP9I+D7c/bl79Yuf9+/sTIxMj86w8DF/e/H28ZGBn+f/r078ePfww//jOx/PzP9JuFnZWRwUVD8QkTw98/jGI8An//fWH6w/CZgZWb4SPbX6kP/3mfvX374DnDn29/eP7/ev2e6z8DA58Dq/CPLw9Y/hz4fJuF74+2tigPtxTDP4aPv35/YWMV42YS4eT6zvLv6f0nzx/f/fjm/Zd3jF/52fTExFn+fDzL9UX3tZAI6+cHXzleMLwx+SrBzvOCWZSDnYVPmEflxvvT39l59BnEreQ9ggU1LO6xs7x4xi3BJfbt1xthoUKVoGwT718Kf9//+MP1nvcV779/f3gEhcSZJRl/M/1kf87F8I+TgYOVme0LxxfG969+fN/z5uvJz/acGoruIorWXFyMf/bffPH51j0uCc5PjH+/MTGwcHB8YXj647MQ068XbLe+/v374cdvxkdcv/k+/2X/+1dMWePNny+/Od6BroZn4bzw/O4fIRn2z8+5XnLbshhxishFChr8f/nvwdfnz279/sXLxs33/fe37zf33fz26PXfDz/OXL8rdOfX7/e3vvziZuVkY2TkY//z/RcHkxyP4C9Ohj+MTFxs35nZmTg+/PwtxcspJiwnJsDL/Ofnx8883LJPuL//+v+H6cO7Z+wvuTgYOZg5frB8ZJP4wvbzO8u3C4zX/8n8ef2JW4KX6R8f33dOnr//GRi/fvzApMqmzK7BwPeW/Q/XF+af//8++vGT7cvz71/effnH8YZdhV/gB+Ov3z/Y/3N9Y//Lx/D5K/PnXx++fP/1iZNBhPPHD/l/f36fefTqEfsHHSH5X49fHLnw4N3Ld+/vPpt6aGn3juWMT7/xMPCevXTiIcMP2be/3jO++//nLw+v+H8pNXM5y+osfwkNjZ8MDD9+/WT8+o2B8QcnkxzDjxcfT7zcz/2P99WXn5x8P0T/CPL8+MLyTV5ZiEWc9dLnh9zfOB/fP/FSje8jn5rYty9/OfmVxSQ5v/85denr/Sev335juvfi7/8fn/4JSfzh5Pv7/R/b39/fX76/9ef9m/sfP71+/fvrT3YxgT///3EJC/7/9fnzL+Y/335+YWdl/fKdmZmV8ecPBlbwRX9cvP9+fWf6y8jw8+t7dhY+hi+Rhvq3Pv959urR708cbD/fcX189+Dt0/e/v33+/Pjfby4+gR/sX79/ZBL9/e2rnLqy7m9RZnFhuU9v9WXNtNW1lGVURHi4/3Oy/X396v3nDz/ef/nO8IXr9x9Gpv9/7z36wfifQYZRk5v/5dN3l9jYrbnl+djZ7rOzMDB+V+Pi4eP8x8goxfTplQgfOwszm/ofxU8s/99+ei31+fcd7j8/laWk2Jhd1LX/CnP9/s8q/u7Bm0d3NLmU1f7Jf1f8ws7GzM8rwmr1T/IPI5PA7+9sX5hZ/jN8+f+X9S8rCxvjz8/Mv//9vPH7zL37nxl+vPrPeevg4+cn3lz/8InvuSQL30/mf4J/3r1iZBRh+fXw/w/u959FP8gx8IpI//3A9+Tle+Yvn579/a77np3tl+zLXzce/PzO9k9F+Ovjz5///ZL6dvX9P6G3rMyMXDekX7O//cMtzMr0h//7q+8s3HyM3LzXrr1+8OTJ/+dv+UV5/3MIcfKw/2Hl4mPnecfIx/Lj+zcGhs+f2X+xPPv8T/jry5ef+CUE337k5mb9/PLlHa6vHx/c/fWNle/tT15mTkZdJz0GNh6GP8x//jN///BXiIv126/3vxX+y78Ueiz4h/XpJ15R3hesHHxv//xj//VO9KvsawEGru8fuPkZnz/6LyTA/vXnfz6+n0+Z2bnf/f0qz67znfkF8+9fDF8+fPj7//vPD0yM/xl+//opbCwVrWm28d5NcT4+A1GJt/+eXrz49j/rLykmIXEdiVdCP79u/cPC8erLXx5WDmamr19ZtVVC1SWZeLlZ2FgZWJhZ/v/6J/JPhkX02uWjVSf3s2x8w8LKzyLOzfab+e/vb+z/fn4V1xBm/sChzPKN/5sQh8TbZz94ed8xsIkLc/JzCzHLf/r/8gsv+/8vHz8JfPh09+Wvn7xfP7/8J8gh802TU0FTVIaFhY1bgJ1DToLx4Yd/P18/Z+E++uww7z1hHQURAdH/PALyLKzM/5lYf32+xiei//PnD8Y/n7n4hfh/ff/OJvzrzw/2b+8YBaXZmX7+/cX4/+9vJsZ/P3m4eb5/+8DCt3XPBWU5fibevw9ufeXlYeDj/fX1LSOTnODH2/f42P6/5RQzUOUVYRB7/+3N3x8MjN9+cGsriktJ/P76k+Ev809mZuYvv/+yvvn2hvUXw4df7758/vHj3Z/PvD95xdj/vfz49ckfJkMpHqa3D44zcHH/ZdDi4fvHxvGHlZ2fh+37f4b/HKwcv9595vrM8kySQeQbz3vWj5LcYm9/i7J/+SQk95eZgfPzr8tPThy48keK96sy2/9ToqzPH3/g+PDvHeMHvp+fnzEKMNz48Y+R4e+3z4yMbAyc/Ax/vjJ//f+Hj+0PKwuPHjvrf9Yfp/79+f+CiYNLkofth+w3vsdCz379FOHk4+H5+eLnr0+//nHq8oQJ2Gz4eFiCWUjhz3cueanvn3i/cb9/8usu1yc2JlaxH/w/OL/+ZGcS+sv0TUNQkIVRQfDzB0YW3i8sbP+//WQX/vXzGRs708sfzJL8oNMRn7CxCTH+/sYqKvD1xRdWMSHGt+8YGf58/8fOxgI6ZuE3CzfXl3fiqkq/f/37/frhD3aJn//vM34XeP/1/X9OLmEeUaZ/f/m+Mf5gZPr7g/kXD/u/VwIv/ikxC3xWYuZh/s/x68sPlt9cAjr/XstI8//69pP/2oeXP769+8715+t3xk+ioK3P34R/fuDm5Hj/86vQ9993/z5iU+L9w8/DKcTBKS4hzC8noSDAwyvB9/Xv/6ev3vxm+PDv4z9VM4G/7yX4mZhYv4u+Zs7p2YAAAQAASURBVPv67dt79mu/mOR//2RnUZdj4xD9943h98P7dxe8uSLy89fff++ZGX7+Z+Bm/Mz14scPNU2zBm8XLgXZv5x/OH/8+yP3jYNN5o8SF8PPN5/+v/3w8c+frxz/mD4KiTDwMkp8v/Pq6a+Xv58zXvn1g5/lKwPrn488zxhY2NhkeSTYBZl5//y9xn7z5b1rD66+/POMgZn5w8mzF9he7Th359vr57q/BL/+Yfj/55uggOh/Nu5//36w87AJcqsz/njHzsjAysj5/9f3r6w8v1kZ/3398lNQ8v+/nwzffv9hZvrH8v8nKyv7///fWFk5OF+aKPHdenP3+4s/fL9/cPP8/viDR0RFjvPTf46/PA8ZhZW0RKU4RX78fv6XQ4CHh/uPpATXb1YuVtZ/jDw/Pr5h//OH7d8v9s+sr27dfXb06tdX7569+iLwkUGQ8fOZ/18+i3/Vl5D8/eXd0T8ccmy8JtKSzBys//hYuIQF2H//5GL+z838V0pYVvK/HKfgDw52vh+CbGp//kkrSfyTUmb+/fb/P9Znv1+KSumEaEoJacgxMPPq8OvYiCs8U/rGziH1lZNPhIVBwkDgPz/rH2b+fwJfGL69Y/jz8y/7L7bvn5j+v2I49fvT+deMzJ8ZmTn//fj26jXjzzf//gm8Y5Rl5uP/wyT+WYCNT06Eg5mNcf+zZ+yc/N+ffXou/PUcy+MvT09+//dO4IMCmwA/J98XqS//+bml/7xh+v3546WLzy69uf1bQJSN4d+/H394eFhZn7xjk+L8zyvBxvrl88PHbHyi39+9ZeAS/vX6/b+/nxi/ffrL+52T6TefnDATBwPLbzYOpm+/OVh+fP3+m4vjn5Dgz9cP2FgUuXn5xPgFuf4LcX17y8QsJcjKzv5R6JswLysrhwgv439JThkZDaavvP/5GPnYpL5Jsfz9KCT8nP3rn1+c38UEuH6yszH+YXz/+R8zM+sTps/v3vx/+eMH+7//P39//cby6c3tI+8+X/105TnDm5/f/jN+fM3IxCYqyqXKw3z00R2Wrxy8EtyPb7249ejBO6bffFz/pBlYGJ8LPxFi4vz8T1BemImF6+9/NnZRJnnQNUl/br/7xMbBz/SPm4X1NzcDN+sXhq9MX21UjAqCzf9qiv/98UviHQcT53OGj+xcoAWvct8/ff39jeXrL6Yv7xm+CrIwMDP9fsV2/9vbZ4+/3v/48cNn0BlFn/+x6DD+55PlE/7N+JuV9fsb9hf/Pnx6w/b/3+8v31ie3Xr87ev7l68/MChL/hb6+uY/44fPP9kZf7Fzcfz7+eszB9MfFm6Gb9//szAxMfP9//Lpx7sXTPx8HP8Zf7IwfmL+y8T0+/8/NvY/3/7++MPC9P/ffz4FCQFTNq4rb3/w833+JMn04z/L50eP3n159p7nN4Mag+Lbf6++fHj97T2PsBifgCAPNys7K/OXjz/Ymf9x8Yr+/8/6kfn1oxcvP7969oOR8SbnLxVeFh5hkVNfP/H84jDkVv709dbhzz/leRTV+Dm/sLO9/f6Ll5GL+dfLLwKi3CwcbJy8735/ZmLj/8/6X/AnizQLMyO3xGtmjp//vvGxCfB8+6LKLCDNxfvJgClcUvG6Juf3tx8kmJkdJaRFVFm+MHH+5ebmYfsoJM3Pyvzt3wu2P+zMjCzgQzZFuJi/8Hz7/46NmfGfwG9WJoZ/zAzfWL4wfmBi+cKorMTLJfD5B6OgsAqfnCiHMqfUN86fvO85GNj5f7/7zv+c+a2S2N/rf35wv//67//XJ18+/mZ89ucJs/RHZgYGXkF+lm//jn2++uL1ZyEJrr//f31n4n7/+jsDNwfD1++/OPifvX/PxCf+j/f5959MzH85Gf4w/frC9/U/B/P7T9+//mbh+MMvJ8nNzPWV6d+Xx8/fvfzOKCLx++c/ViEuVgZGXgEOdlZWJh72X98ZGHlv/f71nvct5+0/f/jefH37/vPzNyw/mLi/8/2QePb985+fP4X//OKV+y/0RvLft/ef3/39yfDiN/MHxnfsjIIs/3+/+v6a+yfDd5Zf/3/+lmS5/5vpDdu/D0xv//14+/X3lY/fvv74z8koyiLBp8gl+vnPn/1Hj7///OnH2/9f3796/OXLE4aPbOcfvGb/fPfRy5sc7/gYBH/xs/3+/5fx+cflJ2/f/nKDj+HXP96f/xlBU90/vnPffsusb6zjlGj0T5j70xtW0D7KL2z/FD7w/PvC8o6f6fE39pu/PvN8Yjj3jUeeT0Lx3+8/z3/9+/L56b+vbF/+/xYyNReTk1XglZViZmDl4f8ho8DyR4H1Fdv7f++/Xvnzmv3XdwkB3rc/vop+/G0lrirDw/ZfQODdu6/sjAzvn7/79/nf7//sn1h+/GZkZ/jy4R+3ABuPAPu/n4yM/5l//Ob4A1rrxMbC8oeJi5Xx39+vf/78YWVnY1BSVbHX4GbgVeC+yyLBwvCZifvXdwZZdv6Av2L/ONj+M7KICkrLsf5jEZEQ5ORi4hT4+uPr3y/fmDj+MzL+eXfuwbdnd3+L8rBLiZqx8P1jZN31646+jqI6h8D9B6+uvuM15+dR4fv7g5Ht15/v/OwcDP9/Mn5l/PL8yXfGf2wfv3z49Ovl/augs2NZ//1k5X3+/ST3j3+/mJl/MTB9Evr2hYGdg5Nf5Z/Cb1n+FGGjc0KvmT/9k/2urPT8B5vEH6Znv+/yM/3j+8kq/IGDj/P/V97/f/gYGD7/f83xV/gr8x9upr8MPz5///vjBxMnv4AEk4CRpKWJlgKvMDszvzgH9+//P79xfOb5/0SWn/WfIgePuqCErL6igArXF3YBXn6Wfww/Hv5/9en1fwaOf1efsjHxiHJJvvz35hPH7R/P/uz/efDLy69/f/z4xvSbhePzz6ev7zOw/WdiVJAQsZBmFWfT5JBg/cvG+oXzGwMzExPjj1+87L8//WQXFvn36A0z07/vH/58+87Iws714stLftAprN///GXg5GT6wyfBpPz3v6Ka2D8OAQZOJvHX4r/+/fr/88vvv7zcP4QYvrJ/4RD5w8zJ9J2TSUHh/98/33he/ODgYPv/l/mT/n9ezl+KX9lZWP5Icv7+8fPf969cgqCziZgY37N+4eBg57YWF5dSEuZh/snA+/WjyBdpUU4RCf4X9++/eCvGKcMmJMT0hZ336wfmD0+evhZm+HrvH8sXnm9vvr79epXtIe8rjrccrD9/33y74NDDh68eMfzm/sv8+S8Lm8Cn7yyf3n34x5wtrZwZ4cHOxyj2i4OTh+3fC/YvnP9Zfn369vz12/f/Od5z/Nf4+VqUhf0dt6G4Lst/3r/8f79ycgtys/7l/PH41Z/bz+/+ZP7Cpy4kbq4kwCvJwvpx/6MLH+8+4WT4ra1pwC7FdPUDswA/l6CiIhfn38+vn7/5wsAhyMvMzszI8ZOXiYfj76d/rCyM/75xMjP9ZmL99fETKzfvXw7mb384/v4HnVr75+e3f6xsXH++fmMR+CfGIichy8zL9fj1qz//PnH8YWRTEf3E9/3liydfP3xi/fjzH4fsD3Y+BsafHOxCv7985P3P9YPl1/cv306/uX7307t7b3+x/2fl+vb91ffPB+8+dP3Kw3731bt/L86w/bIV+CMio/zx358n/57w/uP5++PntZevPjLx8vDzf/7z5t3rtz/+v/zCyfnj8+tXL+8+efaS+afo78/vWP8wMLLwc37mePP/w+cPH/79ZHn2h51RkCtKWujoibtTZ+26y8WqzPr3Hx+bwGMesed/5G0tOISZmKV+M/z/95vzDyc7A8MX1v+8337y/GH9yfGX7z/Dl08qnJzC3FxPmf/8/cTByc379yszJ8NvDQUN9v9iSiq8rFx/VETFmB/cvcf2SPT73ztq36yZZdSNxGM0rD+Lsv3lk3959vbv36ymTEJyj5Q//bny8zH/trMn/75+wyMoy83wm1NEUJ5f+LfqVwlOvlNizHck3ikp8zz8/vzn3Sf/P3/5/PkPw9+fv0TkWH5++8TO9OkPE8OPBxxcP3ml+RXZuVjYmf+8/MshyPfp4b3/jO+Y7rNwPHn29bv0W+5f939qsYFOff8rwfXhL9uPVyJ/mERV3gt8+/r/HyfjuTufX3OK8vGKMPz6zvCfifmTErskjwb/3ze/f3z+zPL9B+Nfpo+sn5l/vP7JyMjyn/0b3/+vKqxRzg4SnhL67Ip/f7C8ffP9wasnbByMGpJStnyCbGJif4TfcLIyCfFwC33gY+P4/ZPx/p+HnG9e/Hj36eWfH6x/QHdA/ma89mnLnhtv3lz7/ev7v9+st98/+fafnfXnvxdfeYzkBOJizT9x8UrwMMiyS/xjYGTgYGD5z/z15c8vdwVYv77huPP/neCfB//e/Pj85cOPr/8evX0r+fvbvY+3Xj148vbd5z/feUHLhn4x/WZ7JiDw6tuvtzw8H5n+feZmVpXREGYS+M/7lY+bU5Bb4J85089fvziFBPg4WTm//P3NwfiLRfT3b4Y/rGw/vn74/+/XD2ZOhl/ffrNzsf35/vsPy2eWX99AOzoYvn77zPDv/99P7Cy8n/WFWBll2N+8+sbG/pHh98dT/17v//bqyfNbb6Q5JNi/M/789fDHmw+fX/xj/v+N8f/PN+8//vvw+sDNL+9/SCkrS7L/fffx3elfb5zUVbklJZ59ZXnNzufFJ8okLPj+zasXX7gEWPh+vnp8UuL7Dy1WFobH/JzM3L+5mXk4GX/z//71jZeb/xfPv6ffGH9/+PaPi/0vA/unPx/+cbLLcvC////3O+MH5h8/Wd9+5H/07/Wbzyx/WH8xM7soePwQ4WB5y/lLioP51z9GA07B/8ysPP9YP7D8YvzD/IuN8e8/pjc8f0EXPP1j+Mt178vf948+vP777+m3J29Yn/Fxshkom3x9/Z6L7QfT5zcyj988enrkOT/H12+/Xgv8+Pbtx37GV0+F/2jIqfML/gkxdGbS5H3M9/mc0JeH2l/Y/soxvvv55sGzU2+//fr4+O9vvm+MDPwSfHZ8cs/Z+I+e//CbmZmbTc3a0IyNS/kvEzsrD/OPD4wybP8//fj178sPhq8fuSTk/3/68fHaM2Y+gf98ghx/PzL8/cWvoPztHSMT58v3fM9ZeN8p/WSX//f1h4AYI/PbH3e+f/r7TeAx5yeFTzL/ubk/CXx49e4359+fH79/fi7NwffhD6v6lxccb5nO/fv25wfLl///GRn+/mNheyfFwvaFgY/3LxuTOKvI6wdPdh+/zXOV7cFHhr8Pf3x59/bZjWdfv3NdenL29GtmeTUhjj/8n//+e/nn+av33/+wsfz7yv7n9+efH/kZfjIw/+X4z3v3Nwsryy+GJ1+eLb/+mPHlTyaGj9y8vIzf/jN9/8fI9P0dp5CGnm6sn+GL1z+5OL7riPz9LvL3t9A/xi8/v7479/yxMMevvz+/f3p36T2XwncOdX5JdSnGf39/f/yqIiQq9EuBl1nh0/07N948U2PiDvknEWygb6HC9+Uv75+711k/scioMLxg4/n29fNvVnY1JhkeQY63dx/+/vqDQYiJ6y8TO9vfv4z/GH59/fhbgPE/CzPr7z//Gf9/+vzr/8/vvxjYv/xkYvn/9/9fFnahn0wsTP++f/vLz8LE6iOlJCYj/Uny4wf2L0ysb2+z/9jD8E2JVfA3h9Blxjt8n9iZ2DkZvnz9/ezhlQuHDm8+9vD/YwV+Ee4/DHc+sN7h/+fGq8HO+GvPu9ufFJjk3n38+e/Pm99sjFwssmIMLK9/PBL6YCtl7PRTkItL+Mt3tsscN57+efHj6Zvz/898/P3z98tvoENo/jKy/P4u8OMrIxsfExv/P14ebk5+bj42YaYfX25+mrRq/0OWf8q6rJ5K+v/+/OWX+sqm8PvTP+bv71/x8giIOAtwa3NxiIj++fWJgYuJ4SfLX+bPTIzMHB/Y/nBz/2X6+fP3zx/3PvD8Z2D7JfmX79W/z/dZ/zOxcrN+uP3hD4P4v5/feP/zcDxjePnvt8Fz/v8MDFxnf3a8vybDwPX9yw1+doVIAQVjOXU/OWdBNqbv//78ZmK8e+fm7sv3X756L/b/x++vPx9wsCsq/jAwF7JmUvrJ+Y+BkfHb7y/sbF//fedm+PLkxfMHf//95mT8+5dT4NMHRjYBCX5lQfYfvz+8+PhPlI+JheP9q/csAgJMT/i+veH+ysDw7e/Pv78Yfv0XY2Lk+C2vws0kwfb3Pe+Fzzc+f/zKx8j2m1uYVYtBhE1QXVCVS45D8oco3zuh9z/+MrAyMf3m+8/9l52H5//fl79ZePk5hIz1pPlFf3I9Vbnx5s6L1+/vfX3x/fX7v6+Y/35nZ37/ifXb3x+/vt48cvn/N55/DD8Z3or+//3hy79X/xiY///4wijw+/efT//YGBjfcv9n5OBm5mH8xf/8yMeL99/y/2ZlYeL8w/LvHTMDaOM7478f/7h0tUWTwnzP8X779lHahl+am1nuJ/+nP19E3959/+rWO4ZnX1kZ+Tk5uDlYuTi+/Pnzj/GxyLdX/P+5xF4rSv7nFpT6x8x88eyjZ+wvDv58zyosIc7Fdubhp4s/7v979ubz/fdvXjy7ferilw/fn3x8dezJs0/fvv5j4v0nyMPw/SMP49+P79mYmd/9+vWHiY3z9x+Gf/85/rAw/WJk+s70n4GN8ef3/////GBi+cvGxsYNWtP5/Se/LIPku+u/2W+z/Rb4LCj+7+cHBmYGlt8/f36S/Cv3/d1Hlv8sPzg+Hz/x+Pr1Ly9e/tRnV/nK+H/vl3OPBD/asgr+Y/657tFdme+ymp9Y3ot8+PaHjZOdnfvnrz+fP+7681FWTEfq2/fn3z98//H//a/vcneEGP8JsksJOLG6/Pj3+QvjF4bffEd+XX0LunyBTYj7P8M/1q9s7/+z/hX4x7jr8qFF8/fff8cp7CwWaul47/rRQzfvefw1ZDTh/P/9868/XFx/eZie/ef//5qDl4+FjYfh92+G3/xMrL8ZGZh+CTD9Z33B9vYP7y+2J3+fv33B9PfD1+9sEo+ef/3xR+jrr99fZAQfC32QYpH5xf1OiVdQkYP3Gd9bpu+vmBXY+O7cu3Hjwd57577x/Lr3+s3pb3e/3r/7UvgNqyATBxMHIzPfu49vTt1+/fbFJ+bfP7/ceHvv+xezX4J/WD5eO3zj3NFbjJxfGRgZ2XnYOJk5fvwUYP7L/peDm4uLQfjPF3bBn79ffvjEwvDjx0fGf5zf3r3n52Vg+PKZ0bjImfH2zz98nHwvfnKLCnzg+Pn/E7OcINPnNwx3WD+z//rH+JSVne0XEz+7iILIr193GBlkv/5n4Wf/++PVl3s/PvK/YPnIxszw5RO7DMeX9185BMUE/4iJan9++Ynt/cUPPxnfszL///+PQYSH/csnFsZ/jNxCHKwsfN///+TlYmLnEv/0+9Fvfgau++wf2Zg4v//5w/qR6dvfrxzc7GwiTF9fMzOxM/PzMX759JtR4Dfry2x3L0EV8b/ffnLySv7++oSZnZ+VV4CV870CI8vxBzeatu6xe/D/2m+ut2+fcTKxf/739d9fAU6lf6K6Eky/2fm4/rGyM7J94H0o957vGfPff//5X3H+FuMQ/cj4TPyHwAchYanfLJw8vIx/r59484frBxMXy5d37//++PHz2z9ZVtlXvC8F/giyyIr4Kkpyy8gw/GP/B1om/IObR/Trq5c8wjw/v3/i5OJn/P//1z825v9f/vCI/H3+hl1IgO3vZ6b/bF/+fnz+4u9pnrsvXr1lZP37je05y29V0Iz1l3/MPExhfCK8EpZv/n7g/fD91YPH91+9efX3ty7Lt3tsQu/4vqh/YNaVlX744f8e5quOb6XlFKQ+/nzJzifHJynE+OvN5ztvbnKyGUorsvx5xSGo8Pvtyx+MzNu/HxK7y/ldSYxL5JfRV9nvv/9/5H7+697n95//vhbj8tOwkeT49IWZ7R8HL/+np68ffCidu4vnNTOjCae/nvR1PtbXR268u88kI8kjbsX0+Yfc/ZsnWAVE/wvwffp3T+Ij/+3PD9ivCv5nYvvH9PrPZzZWXra/rO/Yf8r95/jH9uP3P7EfDBLcij/Zmb79ecrFyiT0x1VD8/KnX1IfP/0XE2H5+uvj359f/r35/+kPswAH0y8uxh+fv/1g5vrJycP6/47OT6nn7G9YWN9fuvrvuQSTxHemd8zfhf7KC0hbSimJizF/YRUS+/H+uYjAk9M3FbRlGZ6/Y5NTZvjz7f2fX+zffjH+//3nHxOfBB/juz8MHPwMAp8+Pv7PycPLwfqJhUPg968//7/8YPp2/N8/YWahb3//ybD/ZeVj+feP7c/PG0zvPv/kFPr9nYuRlVHw929ulvd/v/K+fMcurP6d8fu/Pw8ev7r/gZlDQUyYl/c3G/NfVk4+dmY+8f9iYr95P/O/eXTrFd+bnyzy3/kEuLgZQHvsPr75/5PvH7OA4I/vDJ8//WP9++/ff6Y/X7+yMXIwvGX4xvyJ6evXH3/Yf/wW+crHxM8s8e/dPQZ24T/iP39/f/mbhQN0h9sP3nlXj3z+9IaPkeU3y48fTC+YGP4z/ga1ND9wc2sIcjaEBh0EXb/zgk9IlEmYiZVBmIWD8fef73/e/xH8wsDEwf77B+NP/u+mr5S437H/v//pmcQrpp+/WUWYuH+wy3Cxq/PxfxH584z7q4mO4j9pJranLNzSQjI8wsIGctyyLBzM4n90mNVEft5j4v35/gPjr1+/f7NzcXH9efOMS4T/17fvzKyC/1hZWP7/Y2LlYmVh5/nxjZGfi43h5x9mzu/Pbl9her763rlrz86/+vr++69/AixqAr+eSnKzMv7/8vb1vU2fnr9/dJX5+ZuHd64+Zf3HJPrTWvzfjdfsr598tPzDI87Fd+PLz+v3H5l8kpEV4/4ty84upML88y/bx/f/P/1hVJAxVBYX+f+bhZP/4/sPX5l+c7JxizByMGlLcTF/Mv4tDZ6O/f/+Hbsop4QMM7/1HymBVy+vXH/A+19Im4f53Xe2uZsvsn7+IeasYqUj/+Pvn+vPrz29xfbl5deL91+9+M4lwf2Ok4frx79PUs9/SrPICciJKrIYcsizsfB8YP7Fzsr+k/EjN/MvLqZ/X37++P7716/frzjZr3x8/O7Tva/vvt789/HL17dvX+v8+MErycnz/OeTj/d5v3Iw8zCxcYr/+SL879MnTk4ufjbO/7LszGwssl9Efj56yc35n5VL7C/X+z8fOT+zv+V6x/34+b2T7959+PCbh+HX8V+fXl65Ly0l/+c7E7O85A9Q4/HrtyefWHnZ/zBysbPyMf3+9v0XyzeWT79ecwkxfmf5+vbPP67/H978+vjr65efjJbR/uocf19zMr59+Pfd79eizJxMTBzv/3Gzff/BJv3nzwtWFtHvLO85Hv/5IMwpwSvxUt/MmvnojfO/2Lm+/eUV//37zdf7P1h/P/jyVfI7Axsj/0+5719eMv3l/6H0XuCzAtPnN78Yfn1+x8DM/YObQ/o344e/f7+x/GNl5GLiZhT8zPadjZmT8+O3t6z/OX9L//5xn5mThYGB4Z8AA/t97l9yX5j+Svz//Yz1Fw8jN8v/b7/+/uZlkxTLsZLkNhFlesH6k52djYH5F9MzVmZeBmY2fsb/yx6e3D/rvuLvFz8ZVd8L3mT8xM/AyPKf4bOAlpyUEtv37++ZxbS+f37OfOr1O8YvAkKyOro8dxh/c17gfav8yfSXuKKE+A/uHz+ffLrz/gvvf3E21vesf1n4edgExQU//2b+9P0rlzqjNKPyiRsPjXm4WBREuf8w//z14w8zA8MXBjbGb//ZOP/8Z2Zm52Zj/Mb95ctbbkHWPx//MrDduntx3t9nwn9+8PxhFGXg+M0i/lnwG//nX4zcLG8+v//1/N9TxnfM75hFJSRln34XkBFU5hL5+PvX0b9vFB/8ZFXhe/mA4avSJztOTR5+4f9f3jIz/OPi4GTm5/v84+P3H794fvF857suzW/z8/+v358Z/v55L87F9ZON7e2fT+9evmeWYb3H/N/kMQOnsPTLf3clZc3lP394+P//pIvH4r9xa+rIdFw7em/bZy1rSTE9ljuM/xVOM+x/fPHPI6FfbG8VBDSYVP85GEld/PjhzatnLN9+s3KKv/35hpeD9+/Dx/8+8L/48IOV8csvBgYORqF/3z+zCfF9f/uWk1f61/93/3+zcLAy/v3L8JPrh7q6hiLvu0eK/Lrs4tdvXZVSVPj+4SfL+/9PRH7IveN7/e8bN9e/b39//f/5VZRd/vmv6yosyld/fn69/+U3oa+svwU5v//6/J9dQIiTh5Nd30RMgkvzv9hv1hc/fv1/+f2zyE/GX5wMHJ+ZP/IISokIcPx8+UVYkOX+B0bub+/4WP//5BBlZvv+4/Mvfj62PwxcoFUeUj9/PPjL9Pbun58vfnD9YX3669dHvv/CDF+FpP5w/mT7ovSa9xPvW973/56wSDL9dpI1UnzFzG2tLK/J+P0P12P2L8+kWdmFef5w/vr56TfbC1YGlo9//7D84/nK/PL7h5cP3nx7+Z73Gyc3CwsD499Pvxi+8bDwiDGwsjH84f3++xcbI/vf179/CLCz83z5z/zqrxjb79/ff3/h/M3w84/wj/8fOBlf//3Dzs3Mzc3EwMLJy/WX4ff/T083nH78/53Af/7/oKb755cM30T/fGLn/PL7h+CfXEOTtmz/K2y/OTieSghoigvwcvBx/xZk+Xbv76fzL4VeC/xkfMf+9OdXph+sv6TZVH8/42QTZBP9zfBZ+AfXo4fPN7y4+eoL5zcRQUllMTWBHwxi4ndfPb/9+RMHAxuHADuXmPjfzx9k/n75euve9eefeEDrcRn+/2Ng/PyVhYP1DysrK+O/fwwMjL/e/fzH+pGJgf3zq/ffmM89vbmN9YPi88+8TOyf2ZhuMTHeZX384++nZ6x/GP7/fwdaj8As+Jxb6C3bp/efn39+/fT151vPv1z8/dn0l+QXVdErNx5+ZmAz+y4n8Of39Vsvf/7+zSIoxcHw78fLF4cZPggLiwpz//3Bwf/880PuH5++MX18+uHJGwbmryzswv85WcV/ib5m93jD+5wLdDaagryC1Jf3u1gunfp059+9F5N3nK6bsO/JkU/iCjJG3EIqP5UVLn089ewWw21GbjZmOSe5UCc1H1WhC0x/BD78E5RU/MH0/yfPT8Yfvz8/fvdJgZ9RjEFck42NgYeVk//33w+MjN9/fP7EzATaG8DA/40NNC/678/vX8w/OZ6ef3CL+YcNl8yLTy9Z+YXvfX/ylYWNUew/z7ufzz69FWT9//b5G+HvLGIM4m+/PFIQN/vF9v/fn/8/ub9yfmD7w8D0lfsPk9DHPz/+v/72Yd/Lt29fP2R+xszKzvyZVZFbhPHH72+MQn9EmBm4Xr/6/+f7f0bWbx8/iAkw//jL8ZGFjZmDlZlFgFNU9MvH39++fGAVE2L5JcL17seb3x9Z/oh+4/vAJcfJJC3IwsLGcYH9rTA7j+wTsTefP/99/5f1P+c99reP3/1xkFIQ/crN9Pu/qA4j/zOjYyIn+B/8YRFk43n4/5cwC/PbH3/YmLhYmX58l2IEXf/K+PPbNwYmxm+SjFwv3zAxcH9l+8r9XuQf8/e//3+y/GT5xf7r5zNmVjbJf+yf//z6xv5PkIOb4ecHMYbPn77JfuT7+4v1K+NPtu+M774yComwc/1iZ2W5duvWsvPsIWrKHPzqv/je/vn2jZWdiZVd8Oe3P1/YuXkk/5S6O+6+fuPP4zcM4iK8jJ85mZn/v2F4/oef8/8fOQ6x55xv/jKKfhF7wcetpcShxHT3wwUBNsaf/37LcDLf+3Lv9SVjDW32Dx/eMQqzffnMzS3A/vHbk1f3mf5xsbMwPf//ft+nm2de3GF++1OIi1FFiv8Xv/j/f/9/fP3OwPSXkZuJ9ddfRmZGDkbmr99+v/j45si/J28+/RJi/vJGhIX/+89/jBz8nAw//7IxfmMU5OR9zvhW8BvDG4G3jNyC35995/777ov83w+vf38RfeUqp8Lw+vvLzz+4/zJJ8X4UFeHf8/W1NOc/cTGtvwz/7rEz/xVgDWCSYeL59f076/mvf4Svv/kixcbP9kFGxUj453fGfwz/WBj+fv5zhek/N98nyV9yzDz8oq8+PeNgOX/qu/ybD/+e/Pr+4ec9/u8KLFzy7uzr/jzjO3nt690f7z8y8/KI6AZoWMoIn+f4cv/LexUuBZnf/95/es/yie/919fcdwX+CL9hfsXxk43lx1tWLraH/7gZv3/k/vvvBwsLLwPT7x8cLzg+czP++vNLkJHhxy+mr2z/mP4/vsv85PdrZVFeVkWhyw9v/WH78+b9p7/SHLJ//v/nY5L+K/9N7NPfV19YBXl/fX36mucb4zsWFm4Bll8c//+9YPzJwfGDHTSkLsj29ebbE9ws7pac/Dwyooy/vrz8Ky0j/PvN99/skrwiHxmZeP//vf+JRYzlzQdeeaGf958wCfz58P43y7d3LDJyvx8/+/3xPROHODvfb4a/mr/4mPi/yf5k5uIVk5X7IMgt/F7q96MPH7+9+/7lx+cPbP+Z37P+YxW/wy8koPj83hvWPxy//n2+9G2XzBcxaRXWf5zcbApsf9/8+sD0mfX3r+9vWL9+fvGD6SEbpxDnT55/zN+4Xyr8Z2T6y/yH9w03MzPr398//zH/+sWm8P/Pz3+iv0E3/v37z/OZ/zfjzy+c3xm+PvzDzsXxjP//z/esf4WZGL79Eef89+ktC9vP/395eNi4z5999fj83d8M71n+f2HiYuP8yfLu7y+Wz18+fPvPzPtX08bG20HlIeOvfx//MX398OWp2AuW53+YXjz58P3txUf/GJjY2H+ZyOqI/vn86v6nj5I/2f5+//aDUYqJVVpMgp2f4fLTFzt/fTty9fTDx2+EuTnZ2LmWPbm86/Kt44/v77/+a/2NyxwSQvpSHNv+3Hz85xfLvy9MLKz/WH4z8PMy/mf9zcPyk53z1cvLb15/mP/50KsfX/k5/33nFBJlYOHkEfrH9IHpH/N/Jp5ff599Znz39f3L3x+5uVmkZPn/sDJx/OTk5BWWZmR+L/+R7dOdL0d/vBD6+l1Nx4CNlevKs4+6//iVJZT///j74dcXTtYvqsLcvAwMvz//+/ryrSKb8PNnL1acOfX712eWn58/cDB+YmD59/uXNK+2+g9GuS+i0hw83z882ffixJynFwVfvThx+8eLx19Y+IUUlRnU/NWeMbzTfMP4/QFoY9dv7n/ynpIOnAwswn8uPn7M9oLp1dWbf0RE+P7xfn//h/U5xw+pD4w//zD/Y/v1+yvTn7c/tPiZpDmFpFg5eEV+/vv87x8r6w+Of+zf//Nx/QF1RoUY/jEwMDP+e/Pt+KW7T599e/T9vvhfzf8PPnDyinA//C8vqsL0Q5z170/GP39Ax7z+4GJmZGd6/1NYhJX57+fff979/yTw99+fH5ys/5gZvvJ9ZeD8/Pbj450X7r788eTby4//+fm+P3zOyc0nwPT9P4vIzyePf/z+w/CfgZmTn+H9T0YW1m/vPv3//vYNMys3409+Nbkvn34xSX8RFhEU430rwCX5zlpYk1OLhZ2Tmf3LRwNe1m98P3+z8/DycHIx/+EVYA5QsVSS4v127ebtjz9O/H7PcY2NkV35++vXT7mYRES//GJjYGL7x/aJ7cf/X7+Y3/378O/Pd84vn16CLnF4z8HA9onhLwdolR/Drx8MbxhZGJj+8P/je8TyRYD9j/wXdkaWf/x//rzl4hRm/vnnH6sEw4/vbKJ835gY/vD+YvjEwcLAy8Aj+oOJ7c/fD2zsDFw/fq6/8fjLp1eMzEIsX7/95Obm/fb1J4PAv7+fuThZmbn/6qubJQfafWd49+49y/9vP8UZuVlYeH5+Y312+w3na34pfUUlDpEfP6R+vbn17hkL069P4v+Y//9lFZDnUZfXkOPjNeLmY+BkecT46dKrFxe+3pd8K8Up/u/rL3Y++X/aupKWBsKfxH6+O/V8xqZDL9+94WBlZuVlYmVkffflERMzB+unj+/ZWRZ/3cv2X0yfh/szO9/XP+//s/CzCvCxc/K+FXj+/fP9f/8kmJ6//feb5z8r19fv356/+Mr1+cPvL4zv7/39zcR18c+3oz/vCr3j4mARf37z8T/mX4xsjG8/vbt2/8r5T2//s//h/snI/lv86dffzzm/f+b7Jcbxn8tE0lZX7quIBj833++v3/78/f36+79vL14zMP/hEhB6++Pu/e9Mpz59Yn/x+sKV1+9e3+VhZeK1/sOlrPyI9S3nO95XNz5+/fD8J5Mwr41IoIDiXsGXSy5f12ZhYHzI9OYLwzbmcwJ8/yUYOf7+YGD6yPqHm+vPNzaWX2/ZWVj+vfzC9oOXQfjfD4GvLNyMf3++Yvj5le0z2/ePf7j4fjC8+MrA852Fkf3/vy/fv7OdfP7yxbN/DGJf/6uy8zB8VVAQ/Mz+9h3HdwEhVlk2UZGvnIwKHAwffnBx8fH8Y2IT5fn66y8T82cuaz5RR6H/kn9Y2LjYf3Lz/Wf6++L/xrsX/n19LMfKziYv94uX6Rcf89vnP5j5WXkFxdk5X//4+PMX8xsGZsZHX7+9YGLRV5AXV1BgZWF48e8T06mfd79++yP6/5e2rKqqqqIFn9ybO09vvfi67/3LX/c4JMR4mMR4/sv8YtcSuvrn1RPO1we/Ptf6xy31+ctNpq88bx9+YxJj/PDRmEHjDzPDb9CSHvY/7/8wf2L6y8DIwsnzE7QFR5CB49f3v89BS7e+/f356ecfpp//fnH8/feZ5fnfPxzsoE2iv/8xsHz/zc/y89fXv/9Z/gv/+Cv8+++Tz+y/xH6///9X8Dfzm68/ub6wfmf9zPPhLy8bzw+hP49/TDp36PP758xcfEws77+ws//7+YXjD+unV79/f/j95j+rsYpQkpPx518sTP/u/Pr8n1PiJyvXZzZWvg+/mB6/evryy2cFVnZmHhG+339FhBSfcr29/f77tbOP/3z9wMzOxyvHYaFtaKegLmjAxqUh/s3wG7MUI5eZyEehf1el7p/+9uLB7ffP7r57d+f5xK37v36+w8bI95/ltxC/zPc/3w4y3Ft957wQixD3T47rv/4wfH8pyMn6l4+b8+VzXR4Bzq/cbNz8nMy/v7GK8P/h/Cv6l+31s3+fmL9xczLz/GB4/effx8+/2H6z/X778c2dp+9ffZNhfMvDIvqf7Qcf1x9uAR5BTlFOEXFR1c+fXv/nfcX0/AOvoALj36/mwmpscnzCopwfP77l4xf+8+bl128fvzJ+Z9IQEeZh52GUfffkGuutdy8PfH7/+sd/FkkrC2ULDWfJn+8Zr356vvfjzasvP7EwCGjLa6myHBO6/ejTX8EfIu9uvvrKw8jHyCv0Q+QU8zsZGR5xI46/TBx8bxiZWR8yMUn+4+Bk/MnEwvn7h+Rvrg+CzF++s3HyMDGI/WZjZfzz7efn/38Z/rPwcP76/5HpOwPD/5dfP3Ddufvm2/P/fLd+q/DICXCrMTMxyjK9E2bmY2RnZRMWluUWUpBXUZLTkhcQYWLn+Pv/L4+IvBwLiwI/A5MQJ+vH/8z/mf/+F/4o+O79of/H7vx6xfmGjVdY8u9fTkZBQdZ/Tx6/YGH48/n5P17Jf3+/C/zlEfj7jcnawERQRmzdxxuHuRmc9B2YhNn/i3HL/pT/Lf9f+gXDs+e/v9zh5hb4+/P3U6Z/f3/+//pPVkRKToBT4B3n5dePn194+frl1+N8bz8+Enz/6PWfX0I//739+4nl7pev35/++sfA8eXrFy5BbkYWRmYGFo4fzIzS/3///Mj0/y/zd+6vXN9+if7h5GJi/MHKyMzxk+P1P/7/DIyMf38yMzLw/v/6meUrx79vP1h+cjB9YGf/wfVT4DnDbyZ21k9/vv75w8jK/OHvn3+/BL+L/mdk/sf2jEHw59+LnIsenmX6/IXxv8h/ln9f//z68fP/p2c3/3/5B5o8Z2aTsJNztVLhklIRUxQU/SoozMLy4/s/BrYPTA+Y7n19+fvnH3U5SW5FDl1BMTc1S3ZpRn62Pyd+/L7x4NKrFz9/c/54zfebhUdA+hUHAw/bLRaGK7/uMPz+pflP58+Ov08fMXP/4+H+w/D2/u95F299efeAjeHvy18vZ1/ceO7qE54fv36wc33h+Pbp4493f/8LfGFiZ2S8Kvjy4tv3DMy8kkzMAgJc35n+/f7NzMr795cUOxs72xeWTwxfRH9JvOL5K8zw9eN7RvZn/8UY/7/ifvRDh03oFTsrOzuDMp+ADgcXJxPXt++feP/9E+RRkRFXYfnBLMMnz/7lhyaLGO/zT7yMbF+/frv4/iwLl7SkuKjWP6GXnC8ff/ry9eWnm88Y3n96z87P7qDE8UOK+RrD5RefOZ++fv/xyUcWDh5hdVkrtU+ukq4vGP7Ls4p+F/wmoKttISVqoiHuxieqx8N5Te3/HwkWQVHOvyxsXL/Evv979+/7T3ZO4b/vGFiesf9R+c8uIPiH/98vPqb/Hz8z8zAw/uFhYmH78vcD438mFnaef7/Y/v169+3c+3N3Lwqq83Fwcb1huCUuJcXNLsSowPfk6ZNvv9/z/eD5Lf5PhIn3999X3D/E2Ln/s/DyvXzz+/bJn6w/GJm+Cn3/9eXbh2f/3n1iY/j46evnHUcf/P9174+g6DvmN58+PFNQUv/w5ZewlMS7px9efX3x8fMnIW6e/zyfPjG8YxHUyNYw4hbkZkyoSxLj4Xj29ukPBh6Oz+y/Rb9x3GN8+v/d5w+vv38REpKTYhH9/eP7W3VWiasP3r15805TRuSd6E/O9/9fvP2g8E/wIc8ngY/szz/8/fzhhyAX2w+2Pwxf2X5xv2f7LvJP4Df7n5///zEx/WH9w8DP9OszM+evf6ycjEwcTL8///3Fx8LF8IfnA+NnDsb/nD+4nrJ94mbiY/73+xcjmyTz908MoJnJ33/lf7J+YWNm5mL+/u/ffzYm9j+/Ob5z/ub7y8DF+O/X1/8/rXVVXC21/rGx//vzj/n332+ML/gYZL7/e83Gxc/CzCbJxXj//c81h4+/ufL87qdXUuxiOqYyv19zvP5wV9Zd04RbluEfx9tnb9n//mIU4OFiYTz848X945c4GAQFZFj+SfxXZBV/8P7LP6HfPxkZFLn4r79++u74i593eT8K3OL+I/vv26dfDL8ERGSUHaXsf/L1Xz/9/cV7ob88fFo/ufVV/73/8VOA24dd6srPRyw/BJm5udm+P73+k42Th42N8RXfo9/PWbjefPumzCX1kvH5x29fGF9zcvBw/WH6+O8a93/J79z/OBiZ3wpKaAh8fq2sayHBwPSPi5nt3x9GfibBn9y/BL5zfhH4y/7v/9efPxnYfzH/ZXr/5fuP718Zfv39zCgkwP1fTPgv932mNzzLGZ+Jbn9w+d6br1/ZWIT+G8mKfrJl//HpB+cX1ldX3n648/0vC7usNLuMnYAyI9857sesTxX/Kn2xuCclISv17cvNv+K6bKyMX15cuiTAzvmP4fmL89yPRB5+/PXr18c/3P/Y3jF9//uXQeg383f2P7x/GH5+/f6WifPt7+/swmy/vv7mYGX494HzO9sPFkZWRmYGEQ6GVz/+8QvzK3+K0bXn5OC9z/VYlV351LOTok+5PgkJcHB8/sH+55ckn+J3ts1n77578pZXhEVQTvLlnncM79/8YuRg5f3994/QX8b3fIyK/1heMDOKM5j+deAwVuT4+pZH6NXTb3ICH97+5//J+l/g46v/nHLM//6xcLH9U2H3UjHhY/6y8tI1Ji62Hw+/vGP4wMDNxsL86+Oje+8vf/z07t9/SVZFRX0OdT42ft4v/79z/mV5p8on/oXvnwgTiyKLAPP7b//+sb9j/8/0j+Mv+6//oiwcnL9+s3/9z8vIwPCNjYGbhe8n03smhl8Mf9kkf379zvT76R+Ov9/+MTF+AZ3BzsjEwMDHzMD46f/r7///sv/794OViec/O/u/H39ZfrAwff759+dHBkam/4z/GL6K/PvI8I+J8xfLt7+y334xfWL+K/Xv9z+G319YGX7zf/135MLz648/sP54xcTM8p+RkZ9R5gcHC/N/Aa4f7P/ZhD7xcrPwPbWRUfnI8l+VmVeAl+nja8Z7kk++MzJcf/Pw86dvPx4/PvH2zp6Pd29+ePqa4Z6YEMtfLdYXMu9Z/vMrCUjfZHz0l/n/VwbQgVnsbz48PP3y05Nv3wWe8X4Q+83x5O8fOT5hbn4GhsdH38y+e+b38w8870S/fWP8cVtKgkmQlZ+Vl4njGsPPV0xsr5k/sjH+ucr4XfgzK/Ofn+8/vefjV2Lk5xDk5HrC+pzh5V+Ox2L8Hz7/YWXg+MD2X+oHK99fBj6Ojyysr+88uvHy67sHd/6zC7D+YeASV2H7zfeHj4uNWeI7ww+W97++cvG9/fzw9+efvzm5/jKyMTEzfpYR+MfHyMHE9uHZr9OPXstfe3T5+tcv7z8J8nAa6QvI68l/+fJFnl/05emnX968/v+PkU2NyVJf5j8fzznGb3xPBH6/+vr+0QdhIebf/1/d/fl7y+kVp7/c+CbMbv9DUuEPE7OQmpGqrKwGD9Nffp7PPxjZ/rPwsP7n/sfykYPx2zeG/0J8TBx/2DiY//5mZPzB+v0Xyx/xH5yfmVhYWFh4GJ/+YOKX4vz07sN5hh3PT/759PfD148fP72REJLmlJH8xsH0/PU94R+S6j85Xv3/Ly7xTsJFhkdd+Ou5W39ZP/74w/H3+/e/H1n+Mfxi+sb14febP18Zf//9+O3M1yPXzrz48Y/36w8JZYGv31h/fv7J8oWVS1iei/E/EzNodfDPS58PnTk68dS+m2dOMn1+8+DdFZaPH9hf3X//m4ed+8t/hu/MvK/Z3uryiIhwyovxMT/n/veW4yEvM9O/j1LvWO69+vPuxquHX3l/vf/+6ddnfh4uUQ4RKT4+AQm2P79Y/n/+z/L796+P//7/+f6T7/1/Bp7fTC8YRTn///3zR+Y7E+dvJvZ/3z5+//Ob9e+393++8jKwsP0QfsX6j+3fR6bf3O8Z/7P/YPjHwPKTQZj/7+9njFyc/958+s/C++fNl19/WBjfMv9j/cD0+82vb3//CzP//f/njwwz5+8Xa45e/vLsJ6PANyYBlj/sPMyf3n38/uIbA8PfX98Z37/4x6ykKc5vq8/2WPsH1zeBFyz3RZ7zsHCzs5xl3vzg7Mrz5//eecX0lunhrQ/HHn/8cOWlj7BDkJQyD9cTkdf/nr7+/vX5tR/8XJwfvxw4+frnla/Mvz+w/uD6xvqb6Qsrq9Abvr/cryQf//r2muPFb+5/3Ays71nZOL78+XD98k0TAdUPvC9F/nIa/uNj/cd29+450U+cn3g+c37/wcUkc4vjyc+vHxmlOEWY2P8wMLH+/cTLzcjw5BcD03e2f38EPvD9lf3EzcDyjf8X4xfme9+/Xn54+yfXL5ZPj9l+M/38+vL7u6eMHELfeBn5WJh4uURZf3z6/OomEzOHAI+osvgPaX7hzz9f//sh8+PR3XMXfn1hYhIRkTQw5lA1NHjD9+bvT5YLx258fs3B/FFRUIYtxtOdlfPj++//n7+6+eDXZ2buP/9YmT/9+/vowR9eGR4FBlnNb9xSD1lvvnpy4OXTXz/f7Rf68lP0rZyQCGgQ7g0Dk8AfzvscjFyMfxi+cXz5wcjAzizI9J/3+28m1n+M7L9ZvjIwsrL+ZfvG85WRi43pzYPvgr+ZWf48PPJr6fmTpl9UbnO///Pjx/cvb7iZ3/0VEHzN//rhq1dMTJw6orrWPCoKP7l+cfEwMPxmYP7/V1Do76fv/7++Zf37jenvp59sv34zMIjxfv/8iuXQ1Qv3Pz38//rbf4k/P759FGb7/PL1f4b/Hxi/f2Lk/MXx5fWt8w++Hvqmxi7PIsyufIv/+zvG57++/v/36K2+hNrxp9+4JX4JsDKxPBfe+fqhjDynrYoa45M7R38++cPz8/nr99/5PwoLiPz8xvb521emu6zfhX8x/+biZBR99e0BO5f4d6YvoAVefxjY//H+4WBk/szM9u//LyEB1uugVuHv9x9Y2bj+sP9i+ML4h/Xz/x//2d/x//nDyMj2i+2jENu/n9//MYIaoMxvmX4K/f3x4bchK+ftT79BrT9uhl+//zJoMv348Vv1H8PHP0zsrP/f/mDmFfz69O3qs2+TBAT/Sv39w/CdiYdH7BfPL6b/TH///f4rzPHn7U9+8Shj/4efTz14cFWfQZeF6S+77Df+Z1z3rrx68f4/M89HWV4BARGuW0yfH39nkXr88bbE66f3f7z4cYnrP8/7n1ycz+/fk/vB8ICFlYnpBxc7w/f3TL95GLgEOX4yvGD+yHyR47cgH8OXN4xMPH8Y37B9+vmXR+DD5X9P2Z6LqzB85vjC8PeTMrvs27+/fnIJsNx78fL9m/+MggKq/JaSYm9ef7724zvz7z/fQYdnS/C9ZPrB84b1nsRrvh/cb38JyYk/+Pjj/8+fP958fiHyzuCV5BvJ51xMivxiKl9ePeFi+fvnNzPzn19covzvvzGwMHMyc7Ax8/0X/Mb/lPHXxQvnGD58OXr9/+93P4Xk/xsrqcoqsB74f+vPpc9fv3/98/D3fyYxdqG3jtqKDxguSwkpa776Kq6o++0ewxWp9wkCWlJ/udkkmPgfvuZRNljz9rj073//2LmYBDj+cbz/y/aKWUhGkZ3v1wfO999+sN1m/CH0k+2dwD8OBuZfnF9F37MzcTG/Y/n5993fP1/Yf/H8/M3JzPSW+QPPb9avTBz/mb4LMLIwM3z7/vT2iw2cB9W/CD8XZWZmYRb9wM0vovvmxwMpNtGz/z4xsL5n/MRy8/snMQnBX1y8TFKfmF79+P+V89dPhv+c/5m/s/3/y8DE/ePtz/+/v3149v8vy6U3xm7C/96wSfFx/2P8JSDAxMwi8ffXR05Gxuu/eRTF/jCJMb/7wsf06ocAo+p3e1Y5MSnpn2zyrzm/qdmxaEtyfGb4+YrnC7fOPx1+SeE3T4R1lBg+cjC9+87A/k+DTUcMdLIc/3/uP1++vnv9gvHNm9fP3n/8/fcTEzcnKy8/B2SxCCMX6/v3//4x/OD9xPiL4T8HA/OLDz/5//3/z/Hn/7u/vAz/fzP8Y/v+h/Xr91/vf/+X+s/47stfJjYOxp/MP5jfcjBzM/zg/c33kPPb759//v36wv0FdPfjv4ffWP+y3P7I9pvp15d/THx/mf7852RnfvHi0dYb9zi+cbCxfmRl4PrLxcv699f/39+//vn667cw47vHT///d/3Launh/ITh1d0bj5+d/3r/2fOXL99/+fruycNPZ27dvnbnFtOZv9+evdl/8+jbE4xP33Pd//Dlv/BnTm7WR6wMP/d9/C/zmpHlP+sPLgZObiah79zc7H8Z/v179/3nr28/vnz6w8j89/9vRgEhRkEJ1v/f/737ceribRUG8cd/33/58f31z4+y7FIiX78pCAtw/2T+/4PnldCnf6xfbgg8kxKW1hFQEWUQYHrDpKbCwvtXiInj31+B38y32D+8/svy+gnrpz+vxP6wPPvByPyV/b8YGzvP/18/eH+xMf3//5ON6cvLdx+fvWR6+4Sdg4tH7AcX2/c3/3l+v/zx6MGL4+ce/371WZTnp7Wtzju9b/uEn3NeYPvyG3Sky69XXGwGT1XluXhN+V5957tz6slfPmb9L5qcklzqYtzCvAKf/nzh/8HyUoDz7eub8QwSfGwyrxne/P3zgPEv5+efjN+//fn+/6OsoxiPDMNvrr8Mn/4wMv1gZxD59fc77y9etmc8f+Tecv+XYP7B/5OBmeUP+2cBTobvDAwMzH/4OJm//WBk+cfMxMbO+vvZPcbjt3+wMwl+f/aSQUzo7Y/Pfxj+3Rb4/5npActf9tfv7gv/4/v37COT4jdxZjZBCVYG5p+M3Fz/Gb6ws3P8+sP8h4Xh36ffjP8FZX8w/OL5fuvph2/s/3mFOD//FGL//fwn219Wlr8/GDikBBn+sPH+ZnnPxPKX6f3XGy7fTf8Jseizq7Nx/L7H8Efup/gnBUUhUXENcSGNz+z7P745Jc388MO9X2IsXHxiLJqMnzlf/pNnYBN9L/WUm0tGie39f+bPrL9fvxLkVPvF/4iNgfG/BBPbf4Yvv3785mJnZv3J/Iv3/x9Whv9/v/NwsnwUYmD8zgg61u/r318f/n5m/v/mKycXaEPSz///2b5+AK2Z+cTDzPzvB/cvnh8Mn9l+Mv7jYP7HwPz2x3+WP3++/GFjYPnDycMKut3t2493zL8Y33Iy/v716deFE1evXn/O8pnrJ9PP3z8/MTKxMPz5x/iL9y/T0w9cQq++feRn1jAQ+OpvZ/tI+NmPt6/vPfz09ecHdgbWX78+f/3Gdu386ztP7j+8ffe5zA82sUd8en8VtMVY3rE9+/6a9+t3xr8c/z78/M/I/vvvf4YPb9n/if75+f+/+H9hNWFGdj7mX7+Zfvz9zfuV8f3f/+/f/ZBiYGFn/fPh566Hz/z+6HmI2Fl+ZeFi//v3808BORlOORFRrn+JDBo6bBpmfHoar36IqzEp8fFy/ZZgev9fTVhJUJyF9zX7L45vv398FBIWZ5Xh5f7E+l6Acfnlbf/f//n35RPrz58/pTg/ff7w5sedb3//fPjI819fSkSShfcT3z2Gt+/unrjz8taD6yzvvzDzWf7T1Rd5pPWD7dtftmfszC+e/XnEzPSTi1eIwVNWSdlS+dd3RvPfTH9Z2SU+cD57/1ybRSD4tz7vfy5OLrH/f379YPnD8ZeFWUlempdXnkNEnE3/K8NHhb/yfz68fsjBdEfqh5eWKbMq7+/f7Ay/v7B9+8/Ix/bvvcBngSd8T3T/yP5mE/zJxfrzh8w3zhdc/zm4GP6wcbz//Ufo3x+mt38Zf/7hYvr5nunZx6dnd95RY5IS5P77i/WVNJuc9i8O4X8iSlyCf1XE2YT+ayhJKv9X+aLDDVrlKCLK+e8rKwv7f56vzIygse5fXxmZGe49/Pzjywue3w/eK3AxX2S69Oc/AxOXzI8nL3+Ks3x794GFXYidj5WZW4mP6weTiIDatl9nrn78/ebNbXaJ76wPWS58+8B07N7/O+///ed+8ZFblInNhElC5ZuQIB8jr5zA74dfPzx4+/zOfx4FITFNcT7m798VPv1l4Odi4wMVs9++/vr6C7R9hOE/81/WPwJfQIcu8X9i/fbpFyMz0/eP/xi+MDAL/P7x+f/HH3+5+P4zcHKLqfCI8ypz/WX+x/efjZ35NxMD55u//1hZvvz/94uDkfUPwx92JgbGv4JMLJ++gY5qYHnB+oPtE8Pv359+MINuIRT8+Jfpj+jfT1//rXx09vuXT6zffzIyMP/5x/ifiYPx9/s/H1iYf37l/MHMxsTKxyugqclYbOb+TYiT8etPjn8szKy/+LnEmdn+sPKyfv3FraqoGCSuqKinIcz19h33jydcL34/4Pl47RMjy+d/H3h///vJwsrLyizP9Pbdd2EWWXvZLO9QBSWxX//+/5f7zfJMgOHXD0ZWRoZ7wn943jEy8v/Y/Wnrl/P/WO9KS8l8EWH/KPLr1rWbH15//cL18xr3hzeff/548fG7HNPjH8x/9UQYpV9x8Ajfe/zFVFGej4HrnxCPDq8gDwcHm/RfBiUODs5/jNzyG5+c/fX2xV+h3zw/mHl+/BFgUGEWFZEQY+T6xsj9mfkq27uvnxleXf+4/+Cpr0xfeSSFXA2NpayUlT5xMzL+5BTgfaHz7+dPZllWcU8TRQEJyWs/PzLfY7rzgvED16eH374/+H/uNwfXdyZOtr+/r7x+sv76lc//v/JJ8/G8/sDD+NxUSOUJ80vJL9z/GX7zMIqzv/zz/zPjeYG3hqL8AlriX7X+/OdkZef7/0/8AxMrz/+fnxkYOLj4mVhYuDl+c/yW/Mb48xvDtw/f2BlYXn7++5ud9ScD00em/ywfOJ/zfHj58cynD5xvuH+y/vn378f7L59Ufmjfe3/b7p/kX/HvQlri7wS+M3xgZlbiZWP/yarGwiLB/Yv9NwPjZ+Z/nxmZv/3mZ+P48O/Lu5d33vz9wvxN/IcyH/MnFl7O7xwCv1+xsHL8/fv37e8n7768evf542cWPo43kqDTUP9e5//OeZdP6PfDN0/E7/x/6/nT9Pv/N08EPuuyCfx49/nh/5esH/n5eV5/EZT49PUTB/svBjZRDm1O7icv/1wXY/j1ioWfm+nvO/ZvUv+Zmf7+fvyPQYiJi4vxHyPzr5ffWLn+MfGwcf1h+MTMzMH45/cPAQbRjwKsLD/5eOQYBaT+/Hz2/xM3i8TXL18E+f8xSvx+duc/Nz8Tx68fDM+ZX3Iycn78xcfG/JP3J/uH//KczA/+/OH7w/LpGzMnL9Pv/98ZmARU2Ly0tdh/MTGKfmUSkf398z0DG+eHD7d4mUV/CXCyMP9h/MnKzM/2j/kfN5vcd4bvWlY6eWK8nXeWffrEyf7j71+uf0wfmf6yMvB6ilhwMOuq2Dz58ugbH8uNv++Efot8FH35k4uP+dt/pt+ff3L85PnD+eH/WwYhNRnfvwmK7iwsXCkcrr3TF/56JsjM+JWJ+d8/TjamD89Yfgj/4/305+Xnu/uZjgUwGj75fYL1mfBH9r9Mv/9z/2Ng+sHx7OuFXxc5f/D+EBcSY2YU/sHCraLw/TPjtev3Ll779YH5Hx8bh7q2vgTbj8vnrjHLc/5m+SXO8u8DF9sDAaY/p9/KyLI//fOX6d23F0L3tQXVWB7/OqX4SeT4izcv3+28+OrTr/8CQlIqJowystw3f3z6e+P9t3diIZrSv1UND3y7Jvjtz28zwcsXT3/9xXWK8x/r6486kop/v34y4LJl+PvxNy/X84d3Xrz6/Vvou8p3yf9STB8ZGCSZpV+/vSLEIcDDwcT36eOlzywMr799YP8v8odRQ0CaW+j9kcs/f4v9Zrz+DnQtBAsbwx/QUZa//wn9V/jLeu/Pr1+fGYTZ/34VYP3/7xczC8t35h+CLGy/fv77w8Ui9P/XZ75LN77+5z/HIvft40eBb6I/RX7c4/gu9JnvIz8T8ydmBvbfH9gZ/v35yfmd4xuPsjDL3d9v/rD+4/30+zUrAxcrOzPDV96fXD84/vx7xcuorSAmeeHP3c9PHvAz8/NyMb57zv2Lh4Gfj5Pp/6s/XySYJAVV9fg1RVkEOPjZOP4/Z5OQlfvJwPHt//3PV0TZFWU/fPv24t3B04+OPnvuIMshyc30QZWJg5tdhkdel52f7+W7Lz/5zYREmFS5/v/6/+vbnz+gpXCfmBiFGX5xM/z+yPie49dvBtaXTEx//v/5/f6/KD/jx3///3/8+J+NkYmPU+uvMDPH1y/v/37/+OUXNxMngxyf+J9PL3+JsDD8+8z8k4GRmY2NjeU/MyPrb06mH59/f+ZjfvaB448Yw6/v/znZWBjZ/jCxsv7i9rXUNVTUVDUVluM3+PDq5n92BsbvXwR4JP8IcLB8+8L+H3wd7NeP//98+8H8//dnoW88XOqKDGlx1sxMP36x8vz/9ZNRgIGN+Q/Tiw+7r/+cMm/xto373lz5+e36ix9fPv/i4GT5+/vn9w+MrJyM39m/M/z7JS+k5yWVruD/6z/D6z+fWMRE44ND/3H/+Pb759+vzH8YPjNxsjD9Yfr+/QMLl+jXHx9OX/x/5/dXrsdMHz7//MrzTpBR9Iso85Mf3z8+//Tm/w/uFx+5fv/9zvTxNvOfB3/+CEjxv/j8gYv9C7cK3+m3u9n/cbMKCvJ//MP9iuPLf16xfzzq7z6dFfi38NqJB6/eMwu8NuV2+vLx0ys+PrHHfw+cu7jzwrsPv97xcYjKWfFzaUpdunHp7eX3N048P/Pg0ktW9puMD6wl2TlduK6+fMjIzsH1h0Pg0R92Ucb3Xxj+CP7i4RPg+8H868bjmb/uiTKyWwqqPv7xheH5P6bHH/8+/cjNqPiF8Zskq9DLH881Wf/+/cEv+pbt/T+W6/8+3n3z11hXgpXl1z9W0Z9/GZiZGX5KMfz/xvCP4QvHFxZWXgZWYV6Gd4wsDAy///z+//vbfybmf5yfvjH9/sPy7fv7L2zf/rF+Zbp95v2PU+IsPL+Fvop8+Mb59fnLLxdf6r6Tff79tzyP2g9RAc2//Mqm+izfhT9LMHDxsbExfv3HLfX/x1eWj7xM7KLgjVW/Ntx+8ubXT2V2iW/yPH/Yn7/+zcqq8EuEg/Xvm9cMP8R4JZmYfjJ+4xL8LyHNo8Em9VOS7zMzy8O/Xxl/83zkFLt2+ub/H/8+8v9h4fstxyTBqihnKGXiLKnNwPvjzZfvP7+/PnznAzPrJy6Bn2wiAsw/QHOE/39+/SPM/e8rAxPLB4b/fxj//v8t8ufvH65/rC+Y337//eDnB6b/3359/fnzF/OPLxJPf7KwMf9jYGLn4GT99fETP8evj5/4GH6y/RBh+PnzG/dnFiYR0PKCz6DExsD5m5WPhfE/28/fP/79Y2Tk/fmXlev///ffWb5+4mb6zPf823fJ39zfeIQUvry9zwzqILFy//7/l4Hzz7//zOwC/wSF+f7zMP5jZPn178/3T9+ENBy19WMCLf78/8r46z/7Z3amf5//X//w9OqLO3e+Pn/4V+LjWwtB7c9Pfvx6+/n/FwYuDq7fv76xf+H/zi+g6qgVrWXxh5H5y6uvHD+Yv796L2HEEe/uxSzI/Yvp5/8PbAwMfN9//OD9IsjIxMPxifXtiTcH2K+/43nExAYKrc8sX1lffvny8tMbln+veT+dA61L/3zrya0vB14+v/HmD9tnLk5eCTk5vd88DAxi5x5e+MPGyPyfQZiN9cPv18/YfxyS+Ov066XEF0FFTQ4NFtlvz28/4mH5ce/m6aNHTz1j/vTpuaC0qHeKkg2/yJcTl7l/i93++ugFE7efkurdq5ePH3y/99VlsbsM0vwSnzn5v7/5/VDwCxubyN9vfzj5WDlFuYV4BB99+c3zguWn8E8pNq4/f36+5fr9RuLv2Td3jn+6xXOf/87TG0JihhyfOCXVmL8zf1cSFH746OXLf5+U34sJ6/KziLEwvmBk/faT4xsLo8hvHlaFr3/f/RFg4f/+m1mS55fYW05GJkY2tj9/fv19+4+ZQRi0uYfzx3+27+zML36/Y3/8/MOpD2++fL6vKMEhpmLEwsF8+eg1matfmd+9cGNR/Sf5WfkT72eVD3xCnPwMTIwCEiy/H//88+Xbv3/M7979Y2D48eb/+5tPH929xMnBy/nw+9VHTJy/X7P+Envw8fUnPmZmNlbm7yxMr778/P/ph4AUM8dnbn6Bn6ysDH8F/7EyMj3/duv+v/c/jOR1FY3sxZU95TTPsX97J8ClwsD44df/ty/uXjrz59vPd8LfBN59v8XwXOAP759/PzlYGLgZ/v/6/5f9Pxf7v19/vzH/+PeZmYObgeM3M9N/oV8Mb1mZ/zJ84eBm+y8lyvuTk//Dzw9iP/kZOf+ycXDwvOP+wviRS4CHU+jjL9avzM9//mdm+v3h9382HnbmV38/czAyffn/9cs/tpd/uX7+/crA/Ok9wz9uxt8/vn55y/NFnJXjBeM/nv//XrOzav79/ZOdUeDNtxt/QJe1//v/9T3Dv3+/2BlZ//xh+PWJ5Q37z69f3/JzelqqO8WI/uTl/Prj+19mYcavnOyM/zk4WD9+Zbv547kUL5uouSjbV05mDr7fn7/95ZbllOc39dbK0/H4+pvhE9MPdq5/3/4w/mf5+/Err6KhYmaEF4ODKONfob/f3jFKvGbgYWf4/u4P0xf2H5++HRDlf8T7j5v149X3339952ZkeifD+ldBgO3Hf4afr68/fvHrl/Bbtj9//n5le87N+fe71DcmbmERgTeMX///Yb719Cnj50e8vzn5eaU+/3369d9W3p8WKqLf37GfPH/1Jc9vyXd/D5y6cPTcU4avf3mU2QwceR++5jwi+PIdH9fHZ6xW7NopEVaeDtYGqorCv7/e/vhn1blnv08+dhPX/8bIzfLpqy23pIqRgoqI8bePD779/ieuwRth6WYsofD3/QdhSdZPXy6+vPDj4sfXr+//+P7qOdMf7ifPX1368V6Y94cgp/CNyxd+8f/7/+HHrk9PbH4oaZlIMeoLfWb89ecjB99nlres79j5eJl//H8n8Z/z51/mnzz/fv1l4mFlZv3BxPyd8de3X9/+//8k/Y+Z8Q+PIBfDx5+fvz8/9vnyrxd/rr4QExT8/4OZR4f3/b9vf96xXP5+4QPbvx+y3+XYJJS+8H1Q/8koxcEjzsfJxvHn97vfHz8y/fjAys7/9evbR3efPvv47MzPZwJ8P+8++Pj1zwvO/38F2MX+/vjIxsbGxMX96+rfzz8Z2JRF+ezFLZWleQSZlZT4eVxE5eWsFdjEBNSYOX5b/heUlFZ9+unRtevfWfj433L+keJiZP/KwS30/++P54wSvz+/YQAN/XL8Zvjz9+0vZqZ3/3/+//2PjYuBk43p71+Gt99+8f9g/MnEzMb6i41Pj12KX/DX/z/fWD/9Ef/5/w8vF6/4X6437Jzsv8S5f/8W5v7Gys0jwsShwPD7JSsf1x9Rxr+svL9+/WL49P0HK/P/31wsH3gYfzH/ZP7J8EOEmY2R8+X/n4zs/39y/Pz85vuX/2x/Pv/gZv318x0ntxrTXzYmJub/TOxMDP9//GX+w8jy4ePHjyyMfx98+PSV6ZkQe7Cyjpe77hd+Ucb3L34yMDAwMTP//cfD8uPpA66H718pCCoycfxn+fLmJzsXmwBXpI1mpK7Zp++f/v75wPqS+8/X/ywf/zOwCTK8ePnnF5uytniImQUL/xemv4zsz/i+/PrCxMkAOn6Im/kry+OnbD++3v716ven/0//Kf6Tk/0lys3JIi7AIcgsLiTHI8wpyMDJ8Y7xw8ufP5//+f/uxbunN25xyUgqfGVhVpASZ5Pj+8TA+++XkCAX55u/Dz/+vfb1NuOnjys5n7Deefvg4uNLT358+sctpMCqp6r3X4RbiPEt8+W3DN/Zr4q+ttLTFRH7c+/p/d3PX3/ifMbx4u/r+y/O3Hn2+dw9QwUBJjWRvyxcjzme/nxznYGR5dK7LwwfP/G+f/fs150PIsKsDByiYlr8gpxmaoKcgr9l2Fl5uHh+CTEr8jD9fSjL9+YXgwAHJ7MQ7z/BT3+f7rr//cW3G7IsPzmleP+wfP/xk0X0Pysj6z9Gtr+cf7j/i37j4RVk4f7/78c/hn/cfxj/MXz79pfnL7vgTxbGv7++v/+hwcrI+vnPs68vPrPef/3926c7jExc3E8YeXhlvrz6KP5dRuud3HPmb79/f/72/RM3G5eYoDCz9A9BbQkmob+Mf/l+/vn2k+Etz3fuR+8Zrj55oMMk+YThk6yh/JPPXwRZuYR4eYQERf4wfmLiZhfSYOLg/CHw/s/zh//vSn8RMFAT/KXIyMgg4/JLxubh71887EJf2d9+/PyJ+TcHq8z2E1u5Jbg0WIStTFWVGVhvv/z57dqX/9/f/wWdIfn1P+OPf2zfGLlVfn9nZWVmZPj/k5nn59cXjP+5fvxl/PWfSYJbiFeQgeezKCP7b1Y2Zj71nyL/Rb7zMXALsclzM/36dePb57evfjKxC7J+ZeJ9/J3x89cfP5le/P/59ee//z8+f/nC+Jvh70+Rrz9+/GL7zMDEwcj3jfnz65Un727af57h7y8ePjkuAYb/fGxcn/5/+/+I9R8DEyfH18+f/jMz/2Fk/P/9/79//xnZOVi/fWHk5PzB/PvnJ+Zf4iIx5vp6oRJfBQSZ/rz6y8TxD3REJzcD08/d566c3XuZ4c+fT79ZuThEk9J1JHQVXv35+v/XX25Rlq+fvjL/ZWFhY/39/t0/DpEf3z7++s2i9kNW21b3uwLDr58fOf6y/fz7k4mJ6/+fL3K/uf+/4/n59Cnjf3luPsmfIs95Gf5p/2P6JCj8SVGY6ScDNycTJ+9vkX9i/1RZGb/8//T7z3vWz08Zf71gY1RkYRT69oOF478AP9ebr0Is3G9EnjIc+/fl5re3Ti/Zjz16vvn41e9f/grIcFio83Nz/P73TOANDz//X3apb/zar75tunlk0/3bq09deXzy+vurzF9/fmdnZvv89u/emzevXnkicJWNS4D9xbvP7P+k/75+JcvLf4Hlw3VuZjZ+Bc7P/wS+MvO/Y/n//Rv3H0U2QT5NDY0PL56JPf8oKqP2kuXWL0muvwzMX1l/iSsKaIjKMPz98OW3KpMKP7cGx3+B7/9/MP57z/D/KeP/n9yMvKxMv3j+s/CwcYLWOTIw/+X8I8nIxMv899+3bx9+/xH59+cP82sW5n8CLGKs/479uvjoxcebHwSV2Nl4BDgl/gtx8/599uuXwC+pR0z8n34+V+ZR/yP89+NLHnExZpnvrFqivCLCDBxc/38L//7H9u3nx5c/mYzUlPz1vCV/MXFycJ/79fH93eeMP95++MzGdPX3Y34W0bc/H5x88+n1zU8Xv714f//FHxaOT0w/Popwf5Pj+PGF4z7Tuz8vHr38xP6X4SGfuJICL89vJdEnbx4/ef31x/c3LEwCoPMjvvCw/WH+ywyecGD4wsjyh5H7y/8/bF9e8rIy/P/34y8jJzen7A9Jkf//f4NqOkZJAWWen384+MTZOH/8eP5O/Msjhe+SwkoMXD/Yv3368ptf6K8Q0zdRxh9sX34/+fP65y+Wb4xM/H9fvvr24w37v1+/njP++Pfs149vfzn4uF5/u/jk7bvn71m//2Dj5vzPwPSbnZmHWfnbn9d/v/5g5eH68+fbv3+cf5k//WH4yMPE+Z+D+z8jy7/3P7j+MjP94Pkgz1dl6qaWJP2Zh4P75w+Gb+xszJ///mZg+8/5583PHz8FxKTEIn1MeUTk/vOIC7D9ZOH4+/U1l6AQDy83JzPrbw5RDkFxnp9vvjy4/fE3L3uwnWVRUCSbhsaPfx9Yv734/Z2BkYfvy29mRomffziZxHmYOP69/CLI80aeW5xRlu3HK9HvP1TlZB8+fPqBi+kX1z8WBgb2v0zf2f4zftd2+MStKc/zTuTfZxGOH8wcaiyyr3iesPJJP+N4K/mJlVOQ8cWvdxeOXH//6bWIvLSThtRDJa53v7/9+vrq15N7X/98fc706DX3f/F7f0VO/vr/V4iH4yufqAjrd3YG5u98jD/f/Pny7OW3Ny8eTFuy7d2ZTyvfnH/C9P/520e/eLj0mfn/vH/86sfvqwJf91y5d//T5/f3Lkv8Yjv+/OU/Vg4+Vo7vX7/9/ffr5afPbMwMoF2Wv39+ZmQQF2GUE2B89+aPBru2trU0C4PI699v/jL8Z3v79ef3b/9BEzF3/0n+51YEjcb8+fX1P8fnP3+Yeb7y//j3ioWB5+/vL0w/f/1n+fP/56eXb5nPXHr/9dmP/8rMn5++f6zyVcFA+P/7rwLiUjqsGhbCEq/FuThZ/vN9+8j68p+kJA+H2Q8edSEOti//vzxi+MTI8ITt1ee37+4de8vFfOf72y/v3r9l+/Kag4+T5QuT8TuBjyzfnn9h/PzvAzuz+O1vXxlYWVXY5VSl2VX/s/x6/ePzw1ty71W+Sgn6KqkoictzMPPe//7u7+Xbd55x/hRkZPn67zfrR0Zmgf//v/3lYOX4zvJX6P//n99ZmVh+f/sC2i7+7wMD0y8WMXZhQQ6eXxLf2Vg4/31mlWLlYWX5+5uLgYHh2dfP335+/HH9j+BTLnExNk5O3ncC7Cw/3n5j/8b3+9tfxs+gZdPcvFyfeEFVBy/vf/a3PxiZWP8J/P315/93Jlbe7wxcXL+e399z497P/99/cTAy/f7P+vf3X5bfPDxqzP+/sP5j5mBk///3GwsnB9t/sVefnzEx/v3HycvOwvCL8R8nKxvDN85Pkkx5Cuq+qgbv2XhAK3+Yfvxn+vX1EzeLAKe8vFhkiI2mqTbvj7eMf//++8b05wfH/3+MrBzffrFysXGysHDyM31n/fnrIzsbowDvnxeSzKaqKvmZflySgn8/yTAy/GL48oeBm4P943dmdmEGpg+MTG8F34ipfOS4+/utEpsoO4Mg9/cv35nZ/j1g4ub7xyHExsLC/IuD+QfT+wvfn7BziPz7zmbIxa8mwPP532+p70K/3n4WZhN5wffp3b5bF08xvGFkEpRSdjcV49Pg+vXi9Vfmv1q8MiJ8SgqsPOrfmL88+nv/44s/nN+4vl/6/48bdM8mAxPTl7//GDk4fnH///fi7ddfb/99+nzl2e/73/4+55D6/d/sl/irn89+sjJziTNde/Twze+3fz9+42ESF/vN/vrBV50fEpICYh+uP2FhEJO4+YnxDwODAA/X15+f7//6+P4T22sulZ/sd3++NmVTCfKX45Xh/v3nGwM7C+93rr8fWVm4RFm+8zHK/mPm+8PGxPlb4D/HD+YfbB/YGFgY2b8z/hL4+ffnH+bPbEzMLOx/3z7/cvLujZ8XP//j+mLOq8rCx8/Iwf39y4cfoky3P9zmYmLgllf6+vm3oJQhw4tnEnJSwoqcrKJffjFw/GPh+PX09q4L5678Zrnw8IanjK4gl/S3Dx+/f/7KxijA9JmF/fevz3IsPJLs4kJ8fK4qikqCqkpKnCKS/N84WLm+CP9V5mD//VdASoGNg/E3N5soE9OHj39e/PjP8O8D32dWBlZm1v///337wsguyML2/jejCNOXv0z/2f78+MXwlek/EzMjMx+zIIe0vAQnMycbw2vmf+L/ZRilvzAJM377wMj++cPbP1/ZPv9l+sn69uc3oXuv3zP//S34WeArE/e/b785RcXYBf+w/JH7z/bmF9tPFi72X9+/MLBIMP79/pPlIeMPlV+/Pv79+pv1//e/f4QuPnj04/M39h8/GFnZ/zKD7lz6/fs9M4fQ9////jD/Z2FmYmTn//f3syCf/C9Glj8/PzIxc/9jZvv9m/Pbu9tM9/7cf8T2gee/pjzHX66/HD8EWLh4WDi4bHW105M8BOXFvv/+9/aR0PP3b/4xgdpcHALf/v/m4WBh//WNleH95/cfn9/9I6AgJKbCLfPu9Yd/n39qyIjbllkzs3P//P+O7cef37+/fPzxj4vhP5um5CcluXd/f7xk+ML899tvFjZhZlY2biEZZVFJPg4eBQnFjyxcXOzif76BNjnzCty+9oaH/++3f3/+s7A8ePxaTJxbnvE/J9O3b7d/XL734e0/RlFdaQMrrX8qgg8/PednlVbn53jH/ePVl2d3P/y+zcahJsTJIs/z6tX/v1zCf5nE2ZhYfzH++cv2k5mf5defN/x8PGy8//m/cf8S/P/uzocjl89sfnL66slHWx4/4nn8j4flr5W4hKSILDMXw7Nfn6/+eu2uyMbNz3b5x99Hqlzf33z6J8H79e9f2du8X3l5foh/Z/rN/YT786vfLPxfWU6yfrjK9CTQzVlYHLSK9u8fdo6f336y/GT+ycXwgZuNkYNF5Bv3c7YfAkwMvzgYfv7/xfn3x9/XnPxMrK8Ev8r/5frGwMDz6eOVf2de3xIR0Lz7/8eTW2cYuLgfP3jB+uiL5hcpU04ZftYv7PoyjD9fsXJrCn77x80oyCkixM7O/vvPpz/8n368+f/72l89GRGBjy/ecbx78Y7x86c3P7h/MR1l+fzx31sWvl/aSvLczG/ZWP5+Yf8u/YpNgEvh85dnnKoc3F+5GLgZWT++v/f1IRO7AI8oK+v3r7yCwuICXN/YWX/++Peb+S/jn+9/mT/9+sXD+OPHP37Gn5+//mdh+sPI9oPxM7+EuIKQLPvf77+ZWf79YuZlfCXzR5RdROLLx08MP7+/+8f48/cH5vcs7H/Fv3278/Xr71/ff3zjfMb57wMTK+df1r8KvMJMrD9/v//wl4HhF+MrdiaO399/MP77w/j1559fr//++PLj959frIJsLC9/vRQ9de3pv/ecLLzvGNiZfn959f//b8YfH1hYOBj/szCwMLF/+sLALfD3zy/mb//+/P385zvDpx+Pvnx9/fMn58vvP1ceOXnr3GUWVhZZBYUPAspSkjKB3jYO3tqfvzL9ZX9249kLMR4O0R8/ntx/85nz+8+XLEygZU4//v/4ee/Oyyc/fjnrSimoiD/leXz77LVbXz59+vg7QtQ6PsjhPxvb98+fmV7/5xVlFxdgV/v5TZ2Di+X3X2FGhhef/nN8YX3+8tnTV4/lfgmqCwmwvf/67oXgP6kPf1ilf0nzCX96xyb879XbXy9f/Hr7+x0vA/PP+1+ZuVkeX33x6xT3y98cKho8AXoqf2UePnnx7BOrkJiQ0Gs2hrffvvE8f/uU773Qb6aP3z8z8bCrKfC4axvy/mfkf/f+949/rDy8TF+/c8sI/mHm+/OHm+HfFxZ2PiamX/++s365zH3lyYsXV56svHn7+JXHvBxcZmJiKuJcUhIiOqJCf/8ynWd7KsMg7PCDVZ1bTEVfQYWT+Yssg/qPD4p/+SwM1OQef/jK9/P3p4dMj36JPOa98eVRkqYGj4rUV44f38S/sPxn+v395b8X3/7/YvsnyctkxP3v+8d/nCwM7KxMHzlY2Rm//pX8K/iF4zbnXwF2pr8sTAx/393g3nLzGPeNpzf5/n5j+sojyM0lLP7pz6ezny9Kf+b9y/9ZnkuEU+Lf8z9vvrK945Rm5Of8yc0pLMso/FuA69uPK0/f/N/17Qc7G9Mz9m/P3796/fQnk9D/3zLMWsyMrL+evv/57/+/D9/ff2N8+PnTz38fGX5xsIKOR2P6x/Hr87c/zMyiv///+/v5pYWBoYac2DeuL////2BnZGP6Lf1XiIfpAyPn/x+//31hfs30/+/PvxzvmTlYxBSFlESY+KX5/37+z/qPi0HgtzAvN/8//nvP7978/PvD+79//378/+kvkwQj449nf/hY/v/8+oP/7+8vzCw8Shx8/9h+f2GWFNaV4mKQ52f7y8DGpM76E7S26N8vJgZWof+Mb5lAe/64/r55xMrKxs7w/NjX+99+fv39Q+AfAzsTjwgjA+cPHm6Wb29/MT5h/Pr1FwfTj6/PmP4y/BV4yc7Ez/D/kyizHCs7PycjlyDDN3UpAWYm/qev3hiIc5kqMn3/9VpJguevEPsb/mf8/7R0JDjff//CISUrxMvO9ezLm3///v37ycLM8PPrjzvqP63FZQT4BJ7+/8z/U1mJV+fu/dcX3r7+8vKdbYBpRmrsfy7278wsUr8Yf+p+f/eO/wHHbyFhxk/32MWEBd49fsMnLcLAyvb277frrM+ePvvD8/sZ/z8VQdnf4vf/vOb7LsXAwynEK6jAK/NFQFBN8cG3B0d2P/lw48frP6+ldfnlLSR2SX3kZ+B7z/7nw9tPYi9+Mvzj+Xv1x39OLoUvUn+Yvn78JyDwnY3tz5sHnJ+51Rjv8//7/YuJ+dcnFh5ehl/MTL9/s3J//cPDzfzvG8tfBkYuDmbeH4zff/x//OXX23+Xr71ctPHqhsNnnn79wPD7KzMXM7O8tPgHtjusjySFFL/Kfhe4/5mRQeb3Vy5pTlGp7+LHvt35+J9VTkKckUXq7cuvV4WZf35mWqX0JVREkEtCjPmNICPokrL/DP+YGP9x/PvBwPTzP7c0CxvDv9+Mf5iZP/z7zs30/T7TJ94/Kp+/cT7/90vol/gPRuYfbw99vXDts9Un2a/s//+z/Pn88SXPd0b+F2L8UuLy73hFRLhkeAQ4BKU4laVklcSExOV/sv74yfJLgon1oxjP/Sd3vzx9w/9CQujjD20BjXu/HzAxff13Qugt89e/PJJSHJKK7xkEOD7ffv3188fX/xnYeUGHS3Ny/n3NyPLu7fdvL0BNYl6eL5Lf/3559fHLj38/GX/yvfj/+z/jhw/MAn9+v/n07w/Dz5+/2Zh+//shJ22ka6Ip+U2e8+uzZ1/EGX7z/mfQkPjzU+THv/ef3/79x/7n/5/XLN9E/nOwfH/N+P87G9tbITZ2Jo5fQsycf/99ecLKwsgkzPGN+a+kML+wiMo/1j8/X937zcHxH3SC7h8GLl6mfzx/WEBXMfz8y/X58xfOnxxfz3899egY+z+2/9/esP9l/fnnOdtX5j+cgly/BH6zs//9z8LGJfiXg/HPK07mPwysAhz/Odh+ff3/g+kbIycPl7jkXxaB/99+H3r38eWPB18Y/vduPPn5witZVoG3HO/+cPOwfmP5wPSNjYeFQVpBVODP18ffHl98+Uzlb5S4Ca+4wC9GVpaP/xh5GHR1pfTU1Dif/z1/9/MHtvcW2pqpQQ7M/1g/v2f7cfvPve/vvt14+/n1+y8KXxlffRBmFxBiZpL4wMElxvzlFCcn+1cmGbHvP17fu/+IifunqoSWCA+Xwn9eGW6Zl/+fvPz26uNVpnfPP/78wqikz2WtL/6Pj0356fubzz7wcXPyCXIc4//8+9+Px2yfvv/89o/5B9s/jl8ML/+8/Xddipnt6//3L15+ePONl+E/4zdOYY7/TKKsLD94GAU5Odg42X8wMYtws/Aw/GDm+P+fkYWNnePD79+vvr/79Oz18/cXjr89duHhgSdPmJ+8f67MznDu/pHHHzn/cr3g+yomLPrp+42rt9+9Ff7J8Yn5ixQL6+Vvv0VYxKQ4RBh+Pfvw4uXjj0wMn7N0dDjFBP78ZmZjYWfjZP/O8or/Ny/j159szMJM4gwcQhwMv/n/Mf5kYGVg+Pvtz2s2zlfsLGw/GL+zcXz/zf+X+d7D17uvP/517c5n9t9XeV59Z2H6y8Fw8/VNZRGdO1/vf2P+IyovI8zzzVJN2yPanFns9z9hMfYfF/9+Zfn+8PNfpm+cHM+YxOXvv3/z8/Unpk/sv/58/v6NgZH90yu+d79l/7Byq/KJyIpzMbMx/PnIKawsLswjICbIqszDwSTKI8zH+U/87KUbDx+z/L/3+99fNqZvEv//PWb6wfjzDdN3bjauv9I//37/IsMvrK7lKy/45gMf42fm//84OF9yKznJ5Fh7fpD5//ztt5//OH4//cnIzMf25xfD1y8fJN/9Z2P9x/L/6w+2bz8YhJmF/nOosDP8Z5WR+Xv319VX38V+fOYQFWDg+v+L7TX7J9H/fB////rI9IvxD8/zn59ZGPm+/mTi/8/Gzvn/97nXf1l/fGHkEvv/+x0nm+w/9p+MbP9+snH8Z/zN8Pnnv+8f/jOycv7/8+s/638Gvk/vPjAxfGdhZ/7169tfAea/318y/mVjuvP46a3fKr/4hRh+7j538/2ll6zPOb8z/+SWYvj98h8TGzPb31//3jP+EWJ/L8NgzarAxcP9jQFUobGycP/+/PPV8++y4rx6anLfmRj2HX7yg/WrpbddgLHunS/f2B/+FeT9/u896w9hceY/nz9xMT9hfPf1D/N7Sdavnxg5VVk5f7FxiLD+/vTj1y+m97K879++/czF+OD59cefXz95++fptgu/vvP9+cagZCYTam10jvvbjec3b7z8wCfGz/iB2/wHh9TzH99OPOD78PffH0FOvv98fExcv8QefH3G+4CX+TvHF9Zv7Cwyv5nZ2fkkPrF9/feUm4HnE+fXvyzcn/+wMLOJMrH8+8sKOvv9CwMT03feXzzs/zn/s/1hBB1W9OkZ46MHb+7feKv1iENaQoz99ycxtn8SfErPvr//K/VH0kbp7+/PTH9//X32557QBwNmAUlx1m/fmURYeLl+MK74+WcF23Vrd112w98MjxiYvjKwMDJ+5f3MxMn1h+fvf0FmZqZfDEJc7H/Z/n5m+Mv2j/U7y7d/bL8YPzG8/fFDlPE78z+ev//vXXtx8flHATFBpadM3CL8CmK8rM/Yf/x7p8Jv+Or1K4aHD/7f+3Xy16t7jPd0vFVlBZhf/VVge/v9zy+uXz/+Xnl2+/ObF384/sqJyjMJCYv++fP6DyPjQ97PHGwM/3VZJdllGXmEGJmYmH4wMP//yczM9IPh5d/3AuwiYgK/mfl+/f//VOrR41s/mTj+vH/F8ped6T/bTzYJ5l9sTEy/3jE8YdMz6kgKqA40fCsq+o7xFevr91+4Gdm//n779MWVT7dffX7ykeHjn3/Mv77/YvzL9In7O5uItOArhV/c35mZf4sIs3P9f/ad+y8T4wfxv/wSjz4x87z6+ofhx6+v4tws7MyCfxgYWH6/Zf7Gz8jA/J/tP+cPTbb/LAx/fv37d+Xj/6f/GLnfXGd49/o1J8/bv9wiLP8YmRk4mT9/YWJh+v2FkZnx3+///1k43n7hYv/N9PH/21cMnD9+MrD8/sHD8o+J9c5nBkZehu8MoGXrfxkuPnvH++/Vy3dvFpw//fnVmw9sP/8JsonyMLIyMP74+Pnl+59v5BjclJWZ/jN8+/P33/8/7H//fWN4w/SX8Y/Y71+fPjOwM5lrKP168/3ks6fPOX+5uyo7+7u8/fnx81dWFtbfKux/dWRMVRXVmHm///z8+v3L1z/fPJf4/1NEiO/HsydcBiKcf/n4fjI8Zfr18POH3yySdw5deP38/atXnE/f3lWRZ/NwUl/1/w7Hy1diPzhU5TW1mNl+33++5eqrI/eevfnM8lyN8Ycw76d33N+kxT9xv+cSE5ARYrj//MXnlxx8jC9FuP/z8v5gEhRnl/rNIvz35zsmnm+8X0V+8b7hAF02xMnyi/Xv/z9cjD95/rJ8Zf7Cxc4jxSj6loX7B9dDtlPv77x6/Yb1vwzvr2+/OcU//fynz/TH+78Z+433gpzCn79yKfHxyAhx33/6/cH3D3/+srH85uFi+8328s+/x//5WX6ICCn85v33XfAb1x951hcM/6U4eF6wM35hYOfkFmTi/S8g/I/1GzMzCwsjAwMHA9N/pn9M7AzM/xm4P/9i4WRn5Ht96/vR819+ffv9io/j7auvTKLs7Kw8v9++5vosfP/t388XP4m/4Gf/xWasqPT7F8c//ge/vzP+/P7591dm/l88vxn+PnnwUFmVienXx89KHOKnOF7Ks7Kzy8p9/fCY5Qun0D/Q9iImYX5mrl9//zKwisiLc//99/Xb5+8vX/9//en3G04usT9//3L85/zF+P8zxxeWD6+/Mfz+wyIhq6M6OdlTSVGZS5yZn4WN/wPfvx//2P6z/eD+xnj965GTl/jufeb6IcTw/S4jG9u3r9ws/3//Yv3IIvqG4/k/Fj6OP79/8osp/n73jYWD6RnT7xe/fv/9wsf++9dLyf9/mSRERf/xfef+xijJws3E+P/fT4k3f3+9ZvjHycjAzfFbgumr0OdPnxhfPFt07e7n52y/vz76xfb7H8u3fyyc/7/+ZeP5/4uZg5WF8ecHTvZ/DH//Mn5j4eMSEGbn5/zP/PUfK+vT9x9+/Pz0i/GDpIGJnBr3z/9fH7z6y/XtI+9DnlXb98jc+fOF6RuTqCDrH4bb73580fjuwib7n4f5DwcX8/ffDD///mFmYWcRYWFi+/zg95cf/1l4OAVYmY20FCQ/cu24cOk2/x8fDQkJT23Wz4IaYty///34+fUz+4v37IyKvz98/8LKK6yg8vfvH3ZxQVYBNdFXLIwqfAxfvrF//P3t8e+P91+9ePHl2/WPb74waprLqOtpb31zk+vDH2YuWa7/Umw3P+59feXtCy7m3+yCTF80PY1TtdTdlOR+8D5T/MzI+U+SX5hNQFnp26e/Xz+z/2JiYmb7/Y2d8f+PLzLfmIV/yv3nZvzFxinKyvP+17fv3xi+P//xn4mPlfEjA/OfP8wc/8V+/Bd9xP6G/6/o939M339ysR//+RCUjzSkhTh+v3rx+9P/7/dEf3/hYub789FLRE5chYtZSIzz54cPv78LsTN84vrC8puLhePLZ87vTy88+cX9xkpGToBZ8Cv3C1ZGJqY3H36z/mfn/PNT8d8PsZ+MvB/4uYV+f/r3V5SF/e9vRqa/jAxs/z9//feZi43l789/7zk+/3z88OG5C49fvLvNIPuLg+n/s2vfP/76rsTx79/Tlz+/sl49eeP93X8HD+199fKe0Bc+JgXBvyw/v/16ISTBz/mH4ecnsT/PvzPxCfCe/PtS9Cu7IpPSt19P3j7jXnv71IvHb/hZBZj4PnB9Y//GzPDu6fXvrAznft35zcr3/MVHZub3P399/s/z5fe/7z9+g5Y9/uBgZpfksDaSKXU3YWbhfPjsze9/v9T//pWVFmRk4WN98YabTYzpFx/H6/8sbGLf/jL8YuP+//8jE/dnzj9s/xmY2H8I8HDLcPx+w8DF8/MvI+9PPjYG3q/P3n1h/P//638Ozn/Cj/h+ffz8n0VSXJjrD9/zX+8E/v9mZ/8jwviH/dfffww/mP5wvWH49Yrp94/f//5L6PGwsbOysHD//sLC8IeJgYvz979PzOyi///9YXz9/T8Lx5+f/zk5WNm/f/n67vPfH2+YWH6ysf5j+8PBwMmgkWIe5eUQ5uguYMTz++uvZ49+Mv76/v3Hz4m7rrBd+fnn9YvPn75+0PrtyKvz5d+fPz+YWD+BNmUy////l4mB4dtXJuYf/KwszJwc/0DJhktVQfItw8/3B38++ff96zdOd0UTfRPtD6L/H/5luHL64p3ndwXFhHjkpUSE2f/9fsopJCX0m1WI9R0rI4MGs6CIuIwOL78A89efH94wf2dkFhSSEWO0EhO5LvJe6gfXT6Z/vG8ZWbn/vxP/wXFDgIHhgfDv3wGmpmo8jF8+/H/y7hUDj9iv3/xGjqLuyqYsrz995f0r8OfNn89iP9jZP375wvKF/7XU//+cTEx/uH8LfPnPxcnx+xcXGxcD739Ohm//RP7///6H4ef3f59+/3sn9Os34w/Gf39//WV+wfb+wefL99/9efNhw9u7fIq/eb5LcTz59or55ZvfDI8ePRTkklZ+9YWNXZbjm+ivH59ZWP6DtpwJ8Et8ZrnNxST+RVWLj5WHkZPtG8cvTtbv/5m+CX34w8XHdevfPzZmTvb/P4QZOYX4fnB+/PeV9y/jb0Y2hv//WRgYP///+5Ph3++fvxl53v1//uHvi7vfuG8xv2H58pH/wb//v/4w/laTUeFl5f37493dZ2+Yr8kycQn94hZk5/krzML44dXfq0++g+7JZmV4/vEnE9+fL2y8wna/ObZcurF8wZkbh89c3fZp3onND378YvnM9Y+dh5uLgeeHFAMzsy679sfHj96wsbCCPCLz+8Ofb1+5WH/9/P71NbO0eoGjQZy5PjsP2+9PH9lfvf39/Muf/wzmCsKfZTkZBf4w/X/7n/Ez6w/OD8ysPzk+/AEdI8DBysn2m5eR58cPVgZOFv4//zjYGBiYmTi+sAsz/GR5ySDIwPmLj4Pnx0cOll/ivz4xvfjz4/cfwa9ighL/OF8ysHCyvP73S/glN9+/vz++M/0QY2D7x8j8iYlLwIZRnJH9DxObCAv7n///OBi+fWMTkPj77jkLx1dGUR6Wf7/+cTIws4ox8bEx/P/NxcvL/oLp5vUXd169kzOV9RIzuc/96p+QiJefq7imwvuvL179/KDCLsL+4unCTduePXx7loczWNLoPzcT4x+Of3/+fWf/x/Tly6e/X5mZWBg5Bf4xsgvI8TKzMf75+//j62efvnxR4mf31pbVZRZ/+vLRg8+Pn3y+ev3cv2evXjz+xH+d8dvzW/cf3rktxyry8d3vD9zPHz378PrTb055SSlpDn6Onx8FJH9yiApwKDGzsgkJCmrrSRwV/fr35/c3H34JPOFn4md4dvXyz9t/WP+yc/CKvhH7deTfqwd33h3n+f7vB5sYB/fDH/c4fzH8Yf6x/+mD5+8eMzBwcgq95vzGyPSb8d2P+9wPud6w3v/J8Yjz11+ex9++8XLwcPEwMP8U/af5k/kP83+m///+/OP7zfjlHyPLD7aPfEzfP/1g+y36gfHTs5cXbr4S+vXm4fdntwTfP2L5Ls8v9o2VW0BY+MjD+w+fvHrF/eLPv3dvudi+PHn67T0/2/NPzFxiKi8ZhZ++Xfvs8bs3774LCDJKc7H+Ymb/ycn9Se63wE+214LfhTg4Jf5zsv5meyYEOj3pj8iP3z8ZfzMy/+f89peNmZmZUZz5DxPnr1//X1x6vPb3ZfHfXG84fjKxsbz98Zad8ZuyAZekhATfx3+cQv8ZPjyVYf1hqiLAJsgoqsrP/enL75c///D8evjnB9OV/18jPqpsfP1h74aTd19+evDiPTPDb8brIge27Xh04/mndx8ZuTiFlBW4+WV4WZ8pSohJ/uJn4eH+8+/Tny+guZz/bLwmSirdflra2lpvudmZvv36+vr3b0bub6/fMfz7I8TOEqms/YVDiuE3OzPD/9+cLNx/PnL942ZnZmBkFmb79kHoNz+rlAgHy9/PnKAFZPz/f7PwcjD8YfnC8v7fb2GGP2///mfjeMP86yuL1H/hn/9eM/xVEGTkFpbh+fn/+28mRrZnHD+/vvvLxv6H5cNvBtZ/TAJM/z68ev/h70/Gv//es7F++wPqf3xn+f6fmY+FiZWH8R/vP5ZfDP9/v35x+YcQJxfP3x/vv509f23hgStSgsLBPn7PhT/9vs/54P/zP7wM1QURmtZOH8Venb9258VnhtfMIr+//Q/hZmZj+8vIyMXBBjrz7Pvnv384WTkYOP5++fH/xxfGf7/+fmDi/sPE+ufn559f3/3+8uINM4MR++fnn15ffnPo4IMvD39LKLAba2rws39hvPfn8dOvLz9+uv/2EZ8YKwcLH7cAPw8H16Pfl9/9+M/4l/Xyibvv7z94/v2nsNFfVQnh8yIv2B8zqn/lZv3KxMjx5/7vj+8/KL54zPaL45OyGL8oB78Zp9B7pb9ebwTlzfjd1DQNlaWFmCVf/P7w+OlH7mes3/99+/T7xw+Gv6z/+BkZWN4yfvjz9hfHV/lXT9+x8TB8Z+b5wvGTm1v5Ltv1348Z//1n+MMm8v8143/Ot78EBP5+fvtDSJL116uvzGwMgl/P/Xv44T8bv4AM3xMGlq8f/wmLCLN9eMj5kZ+dl1VEjOMdEx+bAPvr3xyvuH4Iffkvz/X24efnLz+f/frl/X+B7wqKNYoywh+ZmV/w8HEy/vn9iu0b4z+OH5yPmJh/iP0W+cbDx83M9ZaZjZXtB8N/ZjZGBjYWIca/3xiZP3Ey/n7HwsrD8Un027Gf1y58E2DmEJaResbw6Tv77z/vvshICrFzPRaR/CcqqPPtC9e5U5c+6fEK8TP+N2D5/YeB/e97treMTCJfuM88uHl793WOf3wuXuYVRTmFxV6/RD/fOHZr5ZYLKy+e+vXoDhPrZ8b/THwy0t85f38X+Mnw8cvvT59/MH7/Kyjirq2RHGjKqKj8keEf15efn7n5fvz8zvr3O5uQyB/QsCKnBMsXHQ3plwLfGL4zszD+/M3D9ouZm+Hvl/+Mz9m4VP5KMv1/x/zj/0+OX6z/uBh/MT1lev7tw3925m+MXIxfvv9m+P+X+b/YF57fIl/EWPjZGL9++c78/5e+iBy75vtfTNz/uSQY/vExcX3l+MbJyPTjLyMbuyDrzsu3X7x4xMby6++vvwxMTP8ZeH8zfWf4w87CBlpozfzpz7//X0XljDk/3mf/L37s8+Nt525xMXG5GRo8Zv/+j5HrJ8MvVnZ2Az5NfhnBqlgHZQHjX1zs9taOS6vDt37knLbrGOuD9z+/vPn9/w8fJy8vN2iil5GF+x8b03c2ti9//n14+/Xnj1cffn779ov135svzBJfOL6xXnxx+diNxxx/P8iw/7aTE3vOxiAvwcH4j/vrm+8/mBhYvnz7wcDL8Ow/G9+PX3yM/LcEPr/4dvzCzWc/nrx4+oOP58f3r0L3BZ5LPpaTZWNm+8/8Vuzbn3ff2F+xs3A/FTdj5GRl/cn066PA7++fvpn+Fjst/ZnvJ/8OhnMPPj37+Oj2gaNXWd/9YmXn5OWVZPrPy/mP4w8XNx8TjyDrD1YWKUYOxp//JP6wsUpyfBLhE5T78UFIjktaQOC3xG+2z/+ZmTh/fWX9z/CZkVng36enTAwyv4V+sN7k/vbk/5dzvDcfXX727/33r7/YPv1+ysYp+PevyJuPUvwsP3/+/8L4nenXX0ZGXjaOH+zvWX5/uv5WTCJFRzPfyancRPMLL/fLlx++v/n55tw79vevfv7n+fP9BSPP33/fuVlYRH6qvP0t+JPx/7f/bF+ZGXh+sLxm/P6DkZfx1/+/DBysf3+/+M/E+ufN/ys/7n14wvL41nk5BnEOKdDyyDdPHisZOn989P7R19dXJV8xvGDg+sUjoSwCOiZegOP/6zdv+T8yucpq/GZm+MPKYO9pFulqL6+noaKrWFXu/Z9f7tvzlw+PvN/2+63AD+Y/3B//fv/F8JXj4r77vxlZmJlZFXRksl2MPKxEvwky/vny+eevv1+//WJ+/1qAj/cnB9/Pz9/Yvv/49pPxNzuXlaCgup7CZ64vHCxszJ++fH/7hZFdhJlRiI3xLduffz8kv7H9/sHJwi38nvv7H4nPnxn+sH9g+yT+g1Xw99/Pvzn//PnBwsT1gOEHN/NXDn4+zvcsvx+8/SPNKMTBwcX0/wPo2t6PrD9Y2FnY2P/9fszO+lHxO+ua07d/v//1n0eQ5TcDEysPw2/Q+MmPryx//v5hFONj4ZZg+PeC9Qv/4vX7D668yvjj19/Pj7dcecT05fX3/x/Y1ZilJYXFf3N+/3lr9curjxiZshOjGwp9xA20ZkZbPX7K1zJrM9+HH38YGf7xsLIw/Wdn5fj89bsAB7sUNxsTN8dPpvcPnrx5++g2w9vfjP/+sr77cfvkuWOnGf5I/5XUEXttwvGOg//Gq3tnv35i/fruy+8nrJ/ZP/P/5v7369PPzwzcrP+fMj599eDaicdvPv35/4pZQZjDR1uNQVHw2/V7b4Xfv/7/9d3Hj6yfOT/++vbx1WceNh43IeXv3ExPnz/hfvbtJuOPW9fePHv24vqVy69+CysJKT9/8+3dEyamH//5OX7/FvvPx8n/T+g3m+BjZlEhXgZeMQU2aZ5/bFyvfn7/zswo84np/Q0u0M7En8ws/N85mdh+Mv37zfTjK9uL/////GZjZP7x7ynbZ+F/vN94/v778Pjzi4uv3334+5qB+c6Jiz//s3xlZL7G8/3gg08sgj+F3nD8+fr0r+JPsQfCP999lWTUC9MRYJYWZRf68fvT58lrDn+/yfiO6dVvEUVBbc3vot8Ef0sxfPzL9fcp4zcGlp/8QuyKzAx8TCwSf39+Zfwp+ufjP/a/PCz/vv1784+Zh/s360smzm//7rFcv//wFTOXDr/ik+9/LnPeZWYS+vDw8W8mQc4/L6Xv/PstLsV3/++v65/+qgnISHD8+8P77P5bFikWUWt9Y0kjnRAN8w88HD///GPiFFcS+JWT7tE+7YDA77uH5/61TZQQYZZn5BZ5/ez6B/b3/CLCTsqa8jr/5IWl/7Iz/n35gY33B/MPhs+/mX79//P/0yNeflFGZpYff3////SGi5uPkeOz12/NVQLPvrz+wfybj4v13asvn36zSgkyf37DyM7Fz8/O+v4318fPv//9ZmD5y8jA8ecfAzvX399sTOycPzlY+V+z/GUV+CP+5r8UB+cPxv/srG9ffWXh+SvN/vvFXxbQrlXQDrx3v34IsTOofv/9/Akzw29W5p8fP3HxSvxlZf367ToXjyr7j4//f/xl4v/G8JX/3++PX99+mnv42Kf7fCwsL/7xCTB+ZXpx490u7i+RXuYKgopcv5m+/v4+e+PZazu+x5a4J5vqv+Fn+Pblj4AK15wcl8jeTbNXbIkPDvilJMTIygK63ofj18sff0Q52Bn+vbp7/+V/Ti4ppv+fBP5/evzvwps7T6885vohEeRipm1i+OXbh9l3j0m+/vX+OdPnn39+8339+lHgxXemn0xv/iuz3r59/+mTc1/f6P75+ez3F25ZbTYOBan9fx9+fPmW4a2eJOuvP2Ksb/9x/b755s+/X9xSQn8+vNx+8yr3z698ypryzIyfuZ/8+vhF6I8YM9//4I+/ZWUlL519wML4999/lre/fwn85vvF8OvVn88sz1l/ffn+kYODn+Hh7w+8P/+zv2f+Jfr797cvbzn+ifz8+oHtB+dP4e+/vzMz//v1n13gHxfnH4aXfz4J/mdlYPj/7d/HfwwcrAxsPxlu/v4m9+4j4y9xfSnzjwLveDme37jDK8n1g5mDTfa7xHexB0/4XnG8F5dTcOOR/sPFcvXM44fvTjy4KPTl5QcWbhnJAIsNUX48vOKBe/a8u3uQ+/cP5s8sTEIsnB/+/5L794/zPfMz/u+8DByv//zk/ffj+wdGlv+/hJlY3v1jZOL+K/CH7Tff73tPz3B+5/v6Q0OY4/Ifnnvf74uzskopKL54Jc/z4TObANuHFx9/CUrK3v3MJiTxSf+p8Mt/TG8Y33CLq3mpmf4V42JgYuL8ycjBycrGwavMIyTOzf7rFxPnx3drNp++9fGU8MPX23necjNKhdnbm+vySiub/vn47s/n33wMP35////595//LCysrCxMrPx/GJk4f376z8zOyMb25QcPC4v8H47Xnsrqf5jZv397//M34+8fPOy/Pr9nFZD8Lcv5muWvMB/DB05GBt5fvG9ZOf/+YeZk/PX1Lf9DRpZ/nL9+f5b8ysrFzvr+2/8f7N8/vfnzmvOP1Du296J/uRmFpfkZ2diZfn75wv7nHwsfE++rf1/ElKW/SnKwfPnN/PfP179svzlYJf6/+fifgxV0cM2H/0wMf57deDBhx6FXN19zsbxl+CHDxMX47z8n09dXbx5+vfHhIdfXv9/ePK7vm3t6469p0X6FjqavONk/vvn19+vPz18ZeJTEFtSEnfgov37rPo73H//9/vObgfXPN8b/v56/ePHo28fvXz9/f/T2K4OkOM/v3/v3HLh8nZGdg1FViWkF77XfP/4x8jAKv2T6//4P6x+OL9//MX7+xSfHwsfOxPDr1/unj+5+/fflrvjvrxd/cnOLijJxMzO+Z3z38O53jo+/WYXe/uL7/v/J92f/H7N+/cnFKcr65AvLH+7/P978EuL6zfr70a+frGzK/xn/m7BJMIn9fc7AdOb1/TvfP/z8/olBhI2Rj+XLr7cMXx///cn45d9Xpv/fOQU+fnrG/Pv3d8bPrCIs0gICDGx8IswCP/iZOD6yf/r58jfLP85/vBxsbPy/ZZ+xc4r/4/rGyPDx3x8Ghr8/fv/+yfD/42+OPx8efv7ziP3W3efv3n64eOvBb5H/3xj/cP3/xHiP5a0Y7xfup/rKCm6y2p+ZPj5+dFlenEGDR/c987efokIefg6zEtN+Syi95RacYu+sFmL76f3/H7xfWD4J/JL8wfaZnY1LiEv0LyPP978cv9h+ivxh+vz/JyPbK6bfQn8Zfv5iZGNj+P6Y7Scb8xmOE69/Pnr6VIePi1NS7eujP3duXGB8+Y1DRPK94DuOvxzfvry7Lfb+DetfZk1eNT4+xpUrFzPziktIcjOxcf5nZ2b/wvCV+fOJ+xs3zbvB+Ij/z68XH//+Y+ZmZ5LkTzWT/i4o9OPxN10VkZ8//n75/ZtdRITh+f3vTMJc7H8/f/3IzcnPysX6+cP3vz8//2EREORm/MPIwPTj7Zd/fALcHF//vnly7+u6C/f1jUSeqHE93vhMX5zv/d+HnN+EP//+wszPwfSA+ZvUR5bv/N9f/WRi+/GXmY3tx+/fPH//M37gYldi/fHr47/vDB8+/2Zl4eHk+MbA8Y+DRezH49ccPG+f/WT7wc3A+paRWUrMkNNFRHrLz+c+suL6Moa/2X79/fyfkV+I9fevdz8ecPyXZ+b5/+TW8103T7y8/o2ZkfUP028mLraff54zfZf8/eMLlwKbHb/kwVvvXvwRb/T3CUpUf8LC9PvVT+b/f1n+M/xkYGTjZ5dkZb5y7XHulNUObD98wrwZBASZ/v378v3J518sDJ8/Hrr9TpWfSfjfzyXnTn65911EnkdZRoFF+OOzL9/u8TD/EXtteJv35Qv2L6xvv33n4uL4qsQq8ViJ8cev51IPRa4+efj7sTCr+hc1Ftn/5kycf4Ven3387tN3HsnvPB8ln/A+4P8g+uPzX2bxr/Ivft/l4RRkFvgnyCjG+IaBUfwz66PvirKyt95q2Fr9/vzz9uUbTx5+/vDmK+P3v//UONheiH3heSb4m5WNj/vTLwbBf3/+//7/8jsD67//bLw//nPzCf9l+Pvvz9uf7P+/f2RgY/jx8zPDd2EWnh9s/1n+MrL/+fXlNzPP9zfPObhY/7KxMX758VvwP+sPQSbGL79/cAhKinHwvP+hwaf5R5pB/OOnF38+//rF+J9N7JOAvim3KIcC0/vX/xTYOQWkBF7+3XXnwT9zyUJFh5/CzF++/mP4+0uIm/3Ljx8Jxc2M1+4zi0j/lPvB9Z7rs/JXrttc/4Q+fXsk9Pv9A0YGwT//PjBLsTG8YvnH+YHx219mSdFfr9mYhV4y/5Xg4vwZZKbz7v2tm++YP/5jEPz/m1NcSJz7z8vv3CJvfj5iYlcXZvkhxP6M5xMT7/fPv/5/efHjnQgPKwcf048Pzy7svzBv8qn35749ZLzxVZuDleXbvw8/vnz69J9XWkRYREaR/9unX99//+ZhZfz+8v13JgGGP++//fjDzc745dff7/+Y/3IIM4K2wP349PPvrw8/3rEwMjP8+8/KxcfIraYpb2utEexqvD0iaUND7Fc1Zt53PF9//eBl4v39heE32yueb4J/vv5gYXn//y8XLwPLT1ZW3n8CvP+kfnF//fTnHwvv7//sLIJcnP8F2FlZfzG++/yOQZCTjVOIi/knw4dfX//8Zf38/9WTH384WAUYmRkE/jGz/mcR+MvPw/z3928udtbfYv+5frH8YRKS+B+ibvKH7TvDx9dM7Kx/P79jfq/y++OTP794Pl/9vv7kp6c8guvSvTwidV/8Y/jx/jvHHwYG5r9/WP4z//v9/9vvV9+/KehIT8sM2v3g7/6j5xh/vX3P+vkfAw8b508mhv98Pz++ef9g2+mbHx4LsUgxm4GCjOeywH9WLk6Lf8L2t9XYGOXkWJlN1eUMhUQNZNSU1YWF/nNIvGK+8/bdr2csDGzf5PSVXf10Pn/8fefCvR+/fspKMv79IvL09zOmF/8/v/nC/Inh5z/2t8JCnHz/mJg+in5m/vmThU1JQIFLxohbjkda+fmdO9fOPzj56snrt2x/eBj+C/D9evbvK+Mrxp+/fzKKf/v34bvg64fv/7z4Brpv5gcbw78/AiyMP9785fj1l/3/vzcffrD8/cv6j5GDle/3P/G/3yR+/v/NyyIuzsr2jpuV8wcnIwsD8x+2X2zf+f7++cDIwf+f4RfD7+8ffv4QvPrs85dfH06+ec31i4WTSeq37JvHT/ad/MD45RO7sJSkvKw0k9AnHi5+SaVibfPfkjyfvv1j+PGD5ev/Tz9/i4hw9eQm/hYx/fn7FfebXz/5/rF/Yv0h/pv/Py+H3LvffEx/hD8zMLH++/T1Pzcbw+f/zGI8f97/YP/3lv09N9NL1s/v3225e/2dOC+/BgenMNc/FQlGxv+if0UlBZjuMTC8l378U0CI6cuLb7cZmD7++sP45+uVz4/ffXnJ+enWxM0Xe6at/XGZWcRcMrzJTyxU+4cQJzcbc7S5Dq8Qi+A/Th5hpR+/vnz/+v7dFza2X+//cfCy/fv76/efbwxcAuzMbP/+MHx+/IeRjZ/pK5+wMBMfvygDLxuvwOevn58x/vn+htmQn23ho0fH7j3jkWK9/ecl428WZg6O9xyfhf6zMnJx/fr+99vf71+FGP4y/PvG8OOvwpdfbH++//nA8u83658vbF+EWURk/zHyfWX5xMrMw8n15+sPrt9/P7AxcfLJczBxiP3/yvb1PzMvJ5sSu5AwpwgDM9vfn185WAT/MTL+/vSUmZWNlZnzJ+t7NgkOPgUhRx21X5zif759ZfzOwsTzhuE/N+tXhj9/RP4aKc9qjlJz0nrH+vvHj19cv379AR1YxcwIWrnH+v/n3x9//n/7819dW7ouLWjL+Qcr5m5k/sHEzP7zMxczjyTnjz/M+848vHzhAQvrcy0Rhes//n3i+O7yW/QXN/+r389fMDF/5P4iIc0t8U9aVUn8I+crtpcMj288uvP0x/e7f1h4/6tbSVrI8DA9fSv1n+vPx79MHN9+/WVl+fSN9QU3y18uVjZOHoN/nO/+/eX5+49NkPE3z3Pz71yiAhysP39L8Fx5c+0fA8MnSWZmvn/ML7j+//r9/9sfBibmn4IfuZg5Of/x/xC48fYZ17+rzMxM/9n//WP8z87757ekhNR3pu9ffzz/Ifib5R8DD+gYCQFeFm4mBjaOJ3wsH7j/sj/98eI58z85Rt7/LD/E/v77y/FfhEuSl4WfhU38L4vovzcf3v38wPXmGd+75+++a8jzveT8/vnDrReX33zjffjt+SemD9ySAgzffj/59PfD07dvvr3d/e4FB9Nn9l/MTIzMzAxM/3+Bzr1V05LtaPT/yav9++1n1h///v9l4P77+wnXc46frAIyCn8Vv7LwSTH9YmH69fuvwPdfn8QZf//+yfLlNw/LP7HvTJ/ZXl/7fe32X5b/jAYqwvysDC/+/r3C+obtjcBf0Y8yD3hu37v9m0ny569vTMd+neBl4xS5+b1q++q9a09ePH7p7zcGSRf78sLoFBO/dkM/zQhTLn62m18+s739wcb4/Q/j16+/mfj4pf59fcbMzfv746u/4jJ/fv9kY2N58/b/t69fedlY/zP8f88m/PXlC8Z/3758/cbO84/5C+iEQHZ59t/Mgobn31XNWZzd2il/9Mevb69Zfvxk+fbn2z+mv4w/v7H+YfkvwPHl72+u78ysbFzvOH+IMbGxyv37wPGfk+3334//vr79xfaX/fH/b6yf//Hw8zN9ZXjBzajBIs0mxMbyhZn9p6SwABvr2yeMPwU4GP78/8PKzfT760e2vz/ZeEU5hAS+fXz9/48g6y9hJr5feiqsYhLsv7mY//z98P3J2z/fBX+wvWBxUVmc5m+ooviU5e+vDz//fAUt0mFkZmT6xvCf8Q/nfwZGpt9M35h//frz4T+ztZtKX0HY2duf9izaz/DjL9+vV2++MJ48f+LL9ZcMyvyeppY8KmL3BH6cPHLqITejPhevECM7K8f3/68/inKKgpZxsPwwZVC89Pba+zvf3l1691/wm66aHI861+3b39Y/vPX04oef7z9/eMz04/unz3+//Pj9+h/DT1mh/29fsfxR/afMLM7EzCwt9tWcW1SdU+T1pz8frr/jEZRgZ/su/0uA+zvLf57PTP/esP39x/SHge0n568//zh4OFjfsIJOaWNnY/v34x/337+MHH9ZON6zvGViEPn/SfDzy2e/GTj+cvz9/eP97/98/1n/f2f89ff1+79MQkwC7L9+PPvLzsTE+vsf8xdG6W+f3nxh+cXA/IeTU4Kd8zsDw6+v779//vLli/C7f0yffv1+wPH1zX9GzhsMgmySnAocPMy//3Fef3f96Y+/Rn9/btt89dyT13yc/xjY2H8zMzL8/fvr65/PbJyGhsr9mV6/GUX+PvnBIPr313dm4c8CP4R+srD/5vsm8E/y3t/fjL85v7D/EGP+85mR5R/LX37QOTPfvv/n/sfByvnh8rPr917+fPhFkZmLlYf73/e/tzhuuvIaPNb48/Xdl9fX33L+FGK6c/XbpQcnnj55f3f7lYvXvuR6qmWXRE3K81BWVXr3j4mbnb3c0o3BSpPl7sNNNx/ce/KB9cENRg7mF8+fisvJffj5l5+Lg+HLdxZWxl/f/woIfGNg4/7HwcfKyPT741tWEd7fP/7wiYp/fvGBh+s76zfez4+vCfByK8vyhXELfr8tzPBFmFGA58/v78z/uX6xfWH+x8vM/JOFhfEnExvPb+5vXB/Yf/znevKVQfjBH6Y////9Z2YTY/3N+uvPG05Bkf9fWb+/e/+V/7swL/fvZ2wM/34JiYv8+cP898u3W4+/MP/k/vf5DSMX27+//GzM/36xsDIwMDJ++8wJWg354dc3hiv/HjH/FP3yhYX5xbs/P7j+MjH8+C70xc1+aYqXqrrEl89/fnz8zcbMwM7w+/vvf0z//zOxMTKysjMw/P/7j52Z/T/L139/Pv76wM6oa6qcG+Vz4MbDU1v2v3v0e9ayPV9eM/NxCRhx8z1j/26goqXJIP7yJdPtc7efP70mJCDD8fLTO6FPFz6//iHC+ODjlY9/2O+e+fH943dxflkzQ1VJVbHvp/7e2Pfg8bH3zx894WT5JcjP+fMXaGzlv5CUEDP/FyFOZvGvIh+5vnz7yqj0/Ze69JP7P+/xvvvxl1GAl1GLUeoFx49Xbz69ffnr70dJRl4BUPOO49X/n9y/v35+xfTiIw/z/1+sDCwMv/8z/frJ8O/f19+/f/x89Q40Ef7n1d/3Mj8//vn/l/s/5z+W779+/2NgYGb5ycPGwPpFh19IWYSH6R/3/6/fGL9zMb7kYmB6/vs3148Pf7k//OOWFWFn4WMVZuTh4Xn8/N7Dd6+//vrHxf6Pj0GM773o8y9Pv//69OTVa/GvfGrinKzCIg7vueaevn7vyUMeDkZ2NjbQuj02ZpbPf379/PVfWkhbSf3DV1bh879+sDP9+MPw+9s/BuZfrOwcgj/EWRWY2Jg5WH79Z/zxleE/KzMz3/8/v38yfv3L/JPpxyeG7/9efPtz+vmL6wxPVOU45diF/v5h3PjmrMAjMXaRv08FnvJ8/cLy8uKn7ktbeNhlNLkM9bVlGWUFv//gUpQS/sjKyvbt7/d//0W4Rcr8fQ8wcr57+Pij5FsuZiEhAfbPjKzvXr1kZWb/+efvfw5u7v+/GZj+vvvMwCf27+3Dp+y8opx8goyfPv5m4Pz66aMAM/OLP2ycvz/8YZf6wfCLRURGlvNzgKPoihOXmf4z/2VlYfjPxPqW4SvP1/9/mP6xMXCwcTF++cv1gfMvv9rPfxc5f4iw/GNgYfjym/Pd748/mBiEPgp8ZHvKy8bF/5npNyMLLx/zzzccvxR+//oqLvLzz0dONlZ9AZ4f/OxsP7///PqBg0PsP/MHBga2//+5/7J8ZPwl8OvPWz1R3R+8L5h///rLJPfv9zumXwx/TTTnlFgrckg++f7r17tfPGz/v/5lZvz2n4mH9e//f//+Mfxl+MnCwMIGqnuZ2Bh+/2NgY/r07z0fm42XwQeGfzOWLGXYc4+H6R8nv4AA+7frLO/Fr//RFZO4+fD1nxds7/n+6ooqvub7+U2Gj/HF3w/Kfx98fcD0iHnNk2OfGViFBTjMTaV1pGTP/Hvy7uGDb7///v35g1OYnZ1VVFj0y9u/3GzMP/je/Pku8oftGSMbKyePnuDHi28Vb7FLS/96IMbx+fk/Edn/n18x//h+4yMvN+ulN2e/v/7ByMz0/z0rkxTnX/bff77+EP7P8ZyZ4wfjF/137Hd52Rj/gobzvn/6/oPpz/e//ziYGDiYGLl//v/CAAolxrdfv735/0/iP/MXfg4udW5hTr4fmuJyDLfeXlD9x3X7y18uAdZ3PP9Y3/zhFPsrycv/+893sR+yd9S/vn3w9Tc3Fy8TqHQQ+///Gz/Dl2fb9n1V/vr3NwOLiaAMA+/PPx94+DT++n1hbjz2cDI3LyMTOws37y+273+efNj67e7e4ydlXv/9+ev783ecgqx/f/IxMzCLsH7++k2MhYGLWeAPz7v3/39//fdb+AP7W/6/3x+xsCv8/faFhY3tL9tvBl52ztv/fvEy/+Ji+/P+18M/D3jlVXnPvGNS/Mn/TfGRyI/3B98xvfnKwPeWh/PjDwFZNhb2R9c+vF616/iZa694WH9ycbIxMTH+ZWZVkuNycLcSkRC8dfPRnXfvPv5m5Pv3+es/PgYGhv+Mfxn/fGXnEvrx/QsXJ+enT4+4xGVZWH6zfv/w8x8rNzfrty8f3n/7LPjnI4+k0r////99ecXwh+kz51deTmE7R5n/f3gYv/1iZWRhYPnPxsj6/zs7E/8v3h+8zCy/v3H//MV4g/kPx6///7m+/fjKxPD/Gwcjm+Dvb1+5frIwijL9YPouxMnEzvaK+fdrxt8Mbzm4RJj+c//g/83ApCrGKsRv8I+NmYHx39d/P1l/8/z7wfeP8eefX1+ZuH5z87H/+83FxPrjP8eX/2/f/GXgYIgxW1JpZ8wn8fzr9z8ffrGw//nOzMD45w8jFyM7AwPDHwZWxv+s/9kYGBl//f3PyPTv53+Gf3///vvJ8P31z3/ivFFBVoFNLix/fn/58+fX18/f/nznfsf29M2DyUs2vbz3guvP4y/vOWY9ufL15ecfrB8+iv1W+c92g+Xv6dM/Pj1hZWf6JcbPyiz689Dbt8fPPPny8/Nfxn8c7LwsAl8YBNnvv2b9/PuX8E9mBhVGlh/fv0u+E+eW+Pj91x+1v+94xP8oC+lwcgmKc/99w/5FhFGCiU/0P8etT/+jFDXnxjuxcGr+Ynz758tvhv8czH//MPxn/c33i/WREMvXj39YOb/+Z/j9k5+bg/HX378srCJ//35j/8rIDlqU/ZjtIztoRcZffiZudk1eTnU5oWcvvlz+9lZdjkMWFEvCf9+/ZuYBXdzB8vvP94e/BVXEJb9Ivv3z+Q8zAyPXE5b/jJzff7J+5/3L/urvd+FX7z4yPn0vI8L5/e+/n1/+/P39i4GbT0BcOITp19QTj999eMXDxfjjG/OOQ5dP957g3vnnrjojXzjf+19f3z79zPz+H8OrPz8YGZhf/+b4xPiDl5mTm5lDhIXhF8v/H0y/Rfj+M/37z8H6n+Hnd9bfbD/+88pzM/1nuPPg+4PHL3/+kf339ftnzjd/GFmklBUN/vMZ+Bsx/f73nOkv32/hv7efXBHg0fDnELAR5Jtz/Nr9N59kGVk4OLh+svz7+o9dW13G2NtGR9vwwfd37x8/+vyPlYedAXTgAgsbJ8OvXzygA3K+v33EyyzD8OPjXzaBP+w8DJ9fs7Ew/2dkZmRk+cUt+uvjCwEe7n9/uf/8+cP5T5yPj0GPS8nZQ/XrP7Yv757+Y+Jh+Pqdg5tP/Oufv1KMTGwcXN84mF4xMnxiZ/zB9VtQkIWB4QfL67+C37kk/jB8YvjB9Zb9Fzfrt9/vf4j9+M4j8IdXSFiAgY39/pvvoooiEmxq/1heMPxg4mbiY+Xi/fzv3x/mn0zcf1nZ+ZgY2f78E/z98fmnl9+/PPnxm1mAwUdrVkSQqrzUs49///78+v/f//8///7595+dlY2DkfP3739/GX7/YGZkYGH4z8jExsLM8ucvGyPLb4b/v3/9Yv3z59OHfz/4eSoc/c0TvH9xs/388vbnPxHm7585+VUZ3v9l+gO6TJbp3ZO3lxnOn38tzi0pwsZ5+MXVVwdefPnxnZOfhU+K69PPV1cf/31/8xrrk19///Oz8TIzyf3n+aP+7d+Dr99Yf//5/P3fV1EGXgZJZdUvv9kYfst+4f707svf3+9k3vBw//6tIyArL8Akzy3I+lOS7ePHTy8/3fnHxvjj1V/e10xfPjJwCTH8/s38+9dvRuZ/jIx/uX7//MP+5/9P5h8/Gdm/fWX4x8Yt9f/7F0YWof//f/9gZ2PlZvn54zejsJAAN5uZiKCECNfPn281+OW/fPz++zuriZqkpDIrs7jg798iDH9Y/75j+MT8997Rpy9vPmL88P4/Kw/HN/HfPP9/CYiy/mf79Zjp1483jFzsXDzcP5lYHv9+//UV6EDzn39+fvnzWfDfB573r9ZdvivN8I2V6/fpUw+/PPvzW0aqJz9yW1URV6rq12//P977KsD0h4GPkeUL4w+mj5yPGHm4xBg5f3EyCTNwvWP7KvCP5RXjH8Y/v79wffjBJPCfiZGXXYiFjeHDizu//715++/pW3UdW5HPbEeY78ooqfJ/+cLE8YX7P8vrn49+vWP5tvbx9ZufbzNL/9b/9mn5uftvX90TZebk4ODjYGb8zy5gpqqiLsrmbGasoS777R8TA8MfAT6B9+9/fPv99/+H1z///frDI/31y1vQqsYf7zhZ/v3jkXn18BonjyCnsOSfT0/+/P7z/Rfjzy+gqgp08cwrpn9MvxR+/JNxl/3HoMT49y2jsBA/+29RDS0RKUEuIU5Grr9/hPj+cj5nYn72nYGF/S8D13dxjv8svIICLGxCbC/YGfn+vfn989/vzz95OSQsRNzU2Y3tBTiNFZREuP8x/mVik2L4+ek/Dy/D9y/s/3+xsbB9//CFlUPkH89zztcv7h25Nmf52be/vguY6vWkRWgrSL7585nl88/fP9gZmH8xMLOy/WRk+PPny/8foHMg2NhY/zEy/P7/h+nX399/Gf+x/vjzn5mBiYOV9TcTM9Pfv/9Y2Rn/f2BU/8fw8zcvE/tPdrZvjAzfRL7KSEmICHB8YvnG9PMD069Pzz6+ffn8jchdpheHGd9df8MhLawq/f+XhPAPFvU39+69/vCfhfE/OzsDK9c75s8M///c5/zHJc/+l/er/Cc5/l8fP327+fLiV+YL754//fVGSkLESlT91Ov3777+v/3y1QPeL7/Z2RiEX796/vrfl68nL5zMXnz16/dXzPwaf36/+MXAwsTJxsz2j/EjI/tXJgY+jn9/P4MaMX//szII/uZ+8f/vL24Ghi9/OZj//fj38fd/IQkORgZDia9cfG/u/2J/xfxfkPuVMrfs818//r79pSMsysPF+Z/p8V+mHyzc37h+sDJ/EWJgYGH8/e8v4/d/AoLff7z99+HHm5ev/7MI/Pz7iEmQWZCLj4HriwwX++Mv3H9/f/v3/TsbJzujtJipIO/Hvx8OHrz8+OzzFx/e81srdVUE6alq8wppTImNljHV/8nyg/Ujm/R30Z8ivL9ZmBi4GL98/cgkw87N949B6CcD42eGX4IMzJ/52DmZuAX/fGESYP/GJcohoyL6n/Xv2yd/XzP+Ffn3lVeSUejJn1tXn3NI8jL9EWH4z6bCxsLI/vE399/3G3/95GIVNtAXNfnyq3P/baZ/X4U52TgFhUVYGG7eedwh8FbFRE9GS1NASfXH90+/fn7jY/329fsvTg52JRXVR7qcPFy8vxiYWViYP73/zcnxj0dW4y8r97evX1lZ2f//Y/n9/RUL62dGRiamn9+YBUAD+h+F/ofzqJm4Cf/i4GBm//H33/dHL5//+P+f7SPbPw7O/+++M3GI/GD+x/L6OzMf31+GP1w/WN4++/0DNG4D6k5xf+X8wfBdT07EV0iTU0FJn0+zyNdCQEDoLyvT719vWFi4vv/4+uP3h99crAy/vrGzif399Zz5s/CTj192HH738Ms74XCdyZX+FkKiT7/9+ff1J8Pvf/+ZfzH/Zf7PzMLE+P/3H9DVCX/ZGEBttn+/GVmZWP6y/Wb894vxNwtI/se/v/9+MTIKszP+/vYl/uiWPV2HBXl4DIo9uY1kv35kZr/7jVn09w8eVlYx/m//ZJi/fv3LxPD36btL1x/+/MDGIywS4WZu7GjO/ODl/5fPv78Q/vb69+9fPz/9/fvpg+Df/8KfWP+xMIuxcXLJOnIbfWMQ1ZP5z/P/+8Pvsv/Z5Ll5JASUL3x9+IP/xW0GJl6Gj9rv+PU/CL169u71A6F/jBw8P9nZWf5wPhf5I/mN8TsrCwc70ydOxn////Myf/n3iunfv/8MnF8lv/9n/PmHj4XtIxsDr9SPP5+YOXmYf//4ySAk9eO3mRyjEI/Ib2ahF0yf+D8y/eYRUWJn4vj/9f7z52LsLOpqItz8ghx/uX+z/2JmZPz58zkDMyfTf9Y/DP9/vvvI8o/905+ff999+/b21f9/8uzfGVmZ/rH/Z/77i51Niuk+45fXDH9+ff/5+h3bP4FPXpyiM89fap294X+yyaSiIDV5qZe//r37yWIvqpqtbyhkaiDhLsXF9VeM8z8Tg+C3r//Yvv7/zwS6t5lHWIVB8hfDn/8MDMw/GRiYWPgZmdgYfn1k+fKTh1eQXZL5/U+G7w85mX4xcbNxirGo/mT++OTrGyaG3yz/vj/6zfSDR4Ln/59f/N+/MbHdZ+MX4Odnt2JnW3r/Fs/fv7KcnAcuXFz29t4aRW9tLs7nTKx8bN/YpBQ+/frPyMbPI8L///cfpm/vnd+ziXAxsLGyfv369T8v279fP5i+f2NnYvz++dMfbqH/zEwsDMz/eeWZ2Vh+/mP7++7++38srO8Y2TmZ9Ph5pISkX737+v0nx/+37349ePef4xvjH8Zvsi9+f5dk/s71h+/N9y+fOHhYPv9/w/4XvMH0C+fv/4KfOTnCbYx8jTQZJdj+vuNmZmVjuPvg139u5j+s//6xMvz6w8H1n+U/O9vn3785GJn+/WJh4eL5+PnAoXMf378RcLWZEhMrL87/5Ptv0OkLf1n+/P/F+Jvt/7+//xn//2b4/4+ZjYnpH+OPf/9//WZkZPn/788vxl+MP37//csIKtEZ2H9xM/AJMXD9+9+279Kj5otW///rSsuW83/+8eoVw++v/7+yPfnxT02aNV5XXVSQ4ReDKNMLjtv3Pr15wqQsJ+IVa8Yj+IqF4c/7j69///j2j/kpO9f/3z8ZmAW+C3Cw8P5+9/+zyNO3D958fvXm3t2HkjyvrrzmY/8lpy0sYcD9movx7vFLbB/+CnzhMRRRZ/jO+E+K793vd7dv/fz2/BGot8ICOpjxH/9rplf/fvP+/c3zGLTB8OcfRhY+tr+MTMyfGf/zsPzkZGXhZv3+5R8D47/vD//9ZWL9+eoXL6+AgKix8h9RHtFPAv/ZPvAyfvrPxc358RvLW6a/KiLcrFyi554+0WVkktCQ4BdhY/wkyPDl+R9mjn/vvn8X+MT2mfv/PxaGlx8ZPn7+w/3+7+/v7P84vnz6c/35V+F/QoyCbCK/QKdwfnr/7eWdh4JizH+/cDDLCLkrGMyI89nrHyggI/70/zcGhr9S3/89Pv104fOT9fEuLtLW396zSUgrqf8RZZL4/pf7D8drpn8s//8LfOFjkGWUePOb+/vff3zcHIxS/MKfRBSf/fnxgYtViJ1VQZyd5Tfr4QfP2PlVxKVZ///7Kf1ThumfGAMTA8NfAVZVVaX/0qLiPJwH3z86/fgJAxMbnyDT5+MvTl44d+TS2Rnf30y3cPnIw7Dx3eVfHz6wcwnICIuySgt8e/Xh36dPn/6zv3jw+Asb14M3X1gY/3Iy/GRj4/jz//9/FpY/H5/9Z+P+++MPBz////+/Gf58+f/l5+c/r38z8fIw/vjNwvP5+89//376WqtxfOP99+rDfyZ+hp/MH78zMj7/zPuZk53pEwMXw6+vbDxsgn9+/vzNwM7Ax8v2TOgHw7u//xlCw9yVxYUYebk/Pn3168ePjy9e/eDg+/7h6z+2vyxM/1g5WJl/8bGwsP/nE2b68Z+B7y/jP85XL57fesnIamo5LytaTlDo5Y/ff79+Z/7PwPCf4R8bMxsDEwML0/9//9mZmTlZGRh+szAw/f3DzMEK7oX8+8H0l4f9P9P/37/+gEaIOPj+//m+ZPXRS0uXWAhJ8CgIPGT9brfo+uvr5//8YmX59Jnpzf+PQnx82nKWxlL/FRh/vH7z9c5/HqGPkQFmStKKgjwCR9/f/c8k+I9Z+L/oX2YudiYmJgYGrm9Cf99IfOIQYVVm5PjFwvX5G4PAPfbP/IwS6hIiCvJPHt/7wcb8nZH3seQbnq/sdz+deibP8+PT11fv3r0G7b/7xM4p/evXtx/8X5m+STH9/8r9/RfjOwEGbra/7F/+/PjFzCjw+x/j/3/veP5IMvz+/4vrK9MPFhZ2IWZGnv///jAx/7PR4+Vg5/zMIiT49ftfxq+2/Lxv/736x/rt1ae3vzllTUX+MvwRuP38tS4np7CiMJMwOwOH3B+hFwyQoavfH9kYfn37xv5HhINLVPGfKCPDv5e/P/24+uDOozvv+VkY//79ycHCzvr79yemf+fu3PvLxP7l1WcWDoZXAn9ffnvzmfEvHye3zJ/fx3deiO2dyuGpb6okdkvuBy8/2+cbH/9LMyloarEysH/l/sv8npP9KzerELMgoxQrM//fX++//vv3X+K1O4+0kYCk6Ms/CtIKn2R/cXP/4fvEuv3EwTsfnn8R5P747yUTE8f/P/+YWN/z/r/17OOft08+v2fj5zh24d4X1lcczL+VFQSf/Wfm/ia0XMtm9/N7G95ek7j3n/33vz+cfL95WRQExb/w8P/4/keYn+PLX86Pd69zM/z8w/SHUVj93zcG1v9/fn7/+eX9FxY2RibGv+8fv/rPIcD26yMTJxPzTx52Bvb3f17++8X4/cMHNh5llt+/AnWFPjHxf/v+5cvz73+/v/su8IeLTfifwNdfDGwCIlzfX/9k+fOFi0Xs95c33zi+/hRSjDQWt2Bj5BQTfPftNzsDCw87439ODnZpEX5+PmYmrr9/fn7884CBjfUvGxMD0x9mVkamH6zcXz7Nv/BZ1s6gMs9FTl7oxRcG0HDC31+Mfxj/MTGy/2X4yfyTiZGNlYGRgZn555+/v1mZ/rOwsDP9//v75+9//1gYmf7/+8fMwvSPl52Lk5GL4ceecxt2rDus+0XwoxgDhwSrhgiv04+f/P8FfnHxvuN7+efnv+fXX8/78tzERLzaz/cXHz8TF4ONjTU/HycX4+tPL9/e/fDj79t/f/98ZP3Gw8DAwCbJwsb0V/A7O9dvMeYf37/ys7Fy/mJn52aUZxDlZ3nJ/O/x04e/OPj4P37kFPwk/kD0BT+rrKCR5X/xF5+fPH77+8/tT6x/hL/9+8zDycfy9T8D55ff3ziZhYRYWPgYWL7/YeJk+PeRgZGTlUOI+wffL8afjMwMDF8F/rP++/OD6SvHb24ebm050b9vP33iZGD79fHbX45/YlycnKys37l+fP/G8I/3C/PP/0ycOnz8d39/+vntrzk3Ow8PH/NfRs5XPP//fGP4xfn3+58PnxmY5ZVMgm0yy6NEg+0YWGV/f/vx/fefXU8OvHvxgI1PnJ+Bh5GJlVGYl+PXv3s8r3+8+8bFwfj65oszd+6+/Hib/++n40fO5S5YY5FmutzAcd3nFyd3X+fnEuFg+c7yhZP7OrOChDj7V/GPPO//cf5jZvvGLMHFIczGy8H+68urr4/Y936594yd8RvLX3keLg4hoY/sbN+//Pz45M2jc8/+vvsi+I+bifsb+58//78LfeaS53j+69c/dl6OV88ZxT5MvXb8/csn/GysrGxM+hr/Dr27/PzVd90nrD85WP8w/P3z8SXjf9bfXJxKqjKM/Hzv7j1h5Xzw4Q3TbyY2QS7ev9/f///+gZOJjYGdh01IlEOA/8enj8JCLL+/f/v1n4OJX+zfr59/Wb+zM8uIcv5j4ORl+f6TgZNHTljQ08vwx89n7EyfmGRERf7yvPvzjvMZC8tvTlBhyf3pJ7PEN6anf779F5QQKgq00lASes/L9PT5Z/bvX78xcP9nZhBRUeABn4f67/s7Vg5BLlb1/9+/8fz7x/aXiQF0OP/Hl/8YfrH+rg6yslCW//jj//9v/5gZ/v9jZWD+z8TI8o/xHzMDuHxnYPz/7//PvyxM7AwMTP8ZGRj+/vz9/z8rMyszIwsTEyMTB7cQp8D/v9suXJm/9rC64F8uEVYOhj+//wn///xBTFvSXF2Gh/nnv5fM/7+/Y77Fznr5OzOnPCc/l6GOtIoTr4OkKGhR3Mc/7H/E+V4yMfz+xMHBwPGT/bvoeyahj5zCXIzswt953jP8+vWH69/vXz//vvnx4cHnhyxPRL8x8v9kEfgs/u6xwMfv755yvf/29eWjy0fvs75gvPfp4WvQnv4/Ap85WP+DBpPYWFg4uX9zv377+y3jny/MX9iZeTgZ/vKxMXxkYP3+g4eZ6Rfb//8MbNxf/rMy/PnzQ0RY0EhaXJmFRURUTPC7AA/zX+ZfH1n/sXxhAZWGLP8YxATYWF89fP2fl5XnnxqzzJPP7xn//zeSZ2FXFPnG9OGvBBPjZ2GO/xL/hHjsfR3NTRQY+cUzrZ2i4u3ZxUSYHr5nuiK2ce+jz39e/v/+5rsQ67c7D1nZuN/c/fhVgOP3jz/M/77e2Hxz8snjp4/dqbh6fU5lUIOc3fZzJ9bNPmrxj4md7wMbpzA/By+LMifDD2Yx8f/8XCKMP7//+f3jm+oPTjl2RtnfnEKirP/Zf916//buwzfvfl369lXz5w8dFWkJYVYBFglGHl4Ffp7/HOJMDAwMnKxMkv94b735J8QsJPaVXVBS30hQTPzFqx0v3n16dJf79avJd28/e/NZ+g8TGwvbPwZWZhYOLhb+H6w/GRnZuET4BeSlvjH+EWRV5eb//Z2F78eXjz+/vhOWEPrw7hPTjy9sLIw/ntwTFub/9B00jvfr97f3d+7ySQv9//LhNzPf6x//2Bh//fzy6S87M4O4ujL7J2Ur7R//uTjufwHdlMEs+E+Qke3Th49SH/78Yv//7c3P16zCmkqeuobiguy/hBUZPjK/+Hfj+28GQaZ/7OIyTOz/f//9xczKycDJ8/ntYyY2FkaGH9+ZGP7+YWD9+uU/10/+3z/5fv6ffP/G29+vGf78Y+JmZgGNoLP+YfzB8oPhBzMD++/fLAyMTAx/GH6xsP36+4+Z8fufX6CtHMyMTD/+/wadCcHCLsAi+J9x565TU1sWKT4S+8jH9Ynr9/9/X/9+ePuPhfutuJAI+39VTZ6/vCK/vjH+YH739eaj+sNH3jL9tHe0DtO1/ycqevb29Ytnrp+8duXjte/cotzfGPl+MnxkZ5Dg4BL+xy7w6csT8IQmH+N7jh9/vzEx/WNn5BB4If7p4+e3nF/es7/6w/KWl1mN/83nT6++MfEr3nj/mumPyp9fHH//f2B5x8T2g/Gf4L9/f9n/ff3I8peV+53ML27GX0y/2T+zM3J+/QtaL8DK/J+Z4dtHRmYmxu/cP/4wqclyGAoySAuzMTNzv/3x8x8z0zsG5h8c3Bw/md98+MzIxf7zJ8ubjz8/cQpw/H7+nfGHuDAf8w+RSx8+yzCymIqJs8jIsbyV+MX09rsEh6W9raYJy+fvnG9vf3nzm8nMUEvLRPuTEBvD60cfXzFs23r7+6tPgiKcQpysr3//4vnM8vz1Exbm328ZeaWEWS0eCvz4y7oj2ENCSKLw6vblm+9pMH7+zCr4WYj/l/g/Fr533G//sopwC38VlJYV4/0lxsbKrXBHXISdSV1GmlWd4zPHe86/jFw/BfmYmdX5xL9xyL9/eePU64+Mf7+yv//H919URIiPiYXlP68Ai7iCgAjvb65XLO84vwne/Sjw6gf3T8a3r3/MeHPx7cs3Ri8Z+Jm4frH9+cT47x8TI8O/v19+v+P8xvL7989/rL84eXl5NPW+fnzHzsrHzfz73dd/TKy877///MkvyMbxk+HPX1Zeye+MnMy/PnHycHLzMzFz8X188eE/rxjbhxdsfLx/mVh+/v3D9Pnbu6dn2ESUbPnVebiZ/7D8Zv/Ny/CP5w8DB4sIC99D9r9svP//sGt76URpm8sp/mD59ufH7++Mn16JsqqwiImxivGzcLMx/+dmZGdhY+XmYOXllpT+y/CV4x+oo/mL4c+3H3///+Bl4Ofls+N4c+3CpHPH+f8xcLOx/2Rn4WRkYmAFnTsO6sNwMjH+Y/rFwMrAzsjEysQAOqmPhfnfX1YGUB3x+x8zO98fqR//l645N23pGtX/nMzcnL9///r+/ddXNiEWdp6frE9+nb97/hunmZFUU5LZf9ZvciK8OtwM/89/3HT95Lf/V/kERL6xfft06OHxMze3X37CJPDn518+pr/vmdmEWD4wcUhz/mP48F+ahfs7J8OvH38Uf/N8+sPBKvKP59PXv+9ev/7K/P2P0FcOzp8/vrx+wSQrwcPGwyf4T59HhVX6kzofI/svbhZmjk9Kv/78+faX+TPjb/a/XNx/f71g5PjJ8EOY7f8vtj88zH++/v7//yfnJ9AZsYwsf3+xCMlx6UtrSonJfP/x4+2PR8yfH379/4/zO+NX5ne/vv/k4BYTYPjDxcn0kfEd20eGT8yij39/YGD4Zibw+zfXt7uvXnJ8uyPwm4eR4zfjfzZNNWkNRZ6X7xl+vmBm5n99b8f9npXrXt+5Jc8l/luG59f3h5/uPTt876Xgjz//ZORYvjNxyPP8Z/x26/l70JCxsPC3L1/u/jt+9NmzskMbfqy+KPWDgYNDlEXgF8e73zJCIl9ZOf79YxBiZuEV5GZ/xiPA/OcnO+Mnnn9SnyUkuIRUBBl1ZHTZxf+K8HOwCHPeZ/jI//+7MIukCC/jPz6WX8J/H/C9evbsLJOIhMRH5f/s7N8FVRX4OH4/Y3l3//fjq7w8v8UkDVXlDFiZNnw8/+nLZ67fTL9Z//9nZ2X+9/c36M4RVkYGxr9/f/37+ZOHgZNXnJtJXPbthx+8IuKyajrsfHys398LsDEz8sr84eL5/fHpv1/fv/9jYP316c0HbjZOFh42RtDiDH4Opi/v/n1//5tV5PPXn6Iyeu9fPZMU4vAzVf8gwcD8gYP5+yeuvz9//uFieM/4+9cvKy15NxkuLlkutl+8n5lY/r78/Py/MBMXvzA76z8BPqafjH/+fmL9y/nr66tf/99w/WZn/sfyhYGVgYuf6c+vX4zf2FjEGP/9jdFR85fUuX7x7IbnJ/mYfnEJsP9iY2Jl+Mv4l4kD1GNl+PP/Nzvo0CYm0Izx3/8MzL9Z2dj+M7D++8fOJcYsyMq4b/GJmcs3mHGLMkuxMwsw/WD5IS4g9O3L638/33F+lf/JLionyKymqqFuamhjovdCnlnTWMNajTWZV0lZWuUbM+PxO3uvvvzzmpE/0N3Cykj4PzsDy6cPnz9//PXh56+XPF95v7Hf/f/v77/vfLxcDwX+6wl8E/rI9oaD/SfrX67/Ar/YvzP/YNaXYVFh+v+QTViZ68f3D5/+vnwk8sJAXui3/I8f/5nYb/5k/sLO8pP7l8hXzncy/wW4Of/w8/H9/M3CzSj4//ffv2yMDBzvBb/9/feHg0uOn8dEgImHi+H56zd//7MLsov+/CPF+J/xL8t/eRZBjv8MTBw/f3xjFmRiUWCW+cP9heXrBxkmyY/fWR8wMRoxsbz8zn7qxpufnz4x/P7x/zvT43dvvn7+yvibkVHky/EV1w5uPntt9+MnYs9VDESEWTgYvrxj+i/29NnrMzfu8n/5ICjFzsLEKsgnwcHJ/ET894fHN/+ys7w9z31o2y61N9wiolKC2iI/hUT+S7KyM4m8+/eT8+2//zzM7ByMTMK/f/J+YZRWkmRh+/n22yOGDx94GIWYZOQMOJhkNf4Isvz49/Tjkw+v3zH+lmT1cXEIM9TX1pAX/sclLGXFpKzM6Kihq6muIf1F7IrQR+ZfLJwSSh/eX+d69+rup+v3fr35/eX7g2dvvv3+xf3zPycDx9//DBw/GZiYmH/9/ckK2lDF9vnfJ7bfjGLKKp+khT69fy/y9/kfDtbff/g+fXj9+fkLxl+fBQWFfn79Iiwj8+HLT24eFqZvb76z8P798vnbt++/WHj+MbOz//3Axfjz8/sv///8+M7yVlBeJoBP4rXgR4bvn79/vf/lw+vfipwWVrKutppcTNJfv317+/n71y9f3jD855H6IyAq9JvnOzMj51+uP2K//665de7j849snF9+sf75y/L7H8tnhp/fmZk4WNn//vvz/q8Iz/9/EvIS3AGv5RZM27f0xSNpBjYWPrY/jGz/eJgZ/jL+Ay0eYPn7/+dfZobfDAzM4HT//d+f38wMPMIcXMzf9u3Y2rFmqzO/4Ffuvwx/eP///cX678fr3x+FfvP+Y2d+8/2dvrxktIs5z2uWF38+ebvYJqvqPP/DZOVi/Yjp1KkXn65dP3b9I8+3D/9UrBS0FN5d1Wb88+3tXz4B1u9ffyv/YXz6gfHlr5+KTCwMbH+5vrJwvWF4xvr94/d3/5gZmTnkWKR/qHNzc3Fx8bFz/P7yl+33o9c3GRj4bv/9LvtD4aXMXwlxPk4Bnp9cjIzfhBgY2Vg/if0ResbHwMPAx/iX4d9/ps//XzMwsDIx/vj2998/bjVudcGPZlq8EoJq3z88lBWS4/z3jY9XSISX/TvLrV+/WV98//+ThY33L+u3P9/ucbKzcH759v3vJ5Zvr75//8r24dfff4+ZeQV//f/8Q/TXt4f/GH+xsP778PjjxYsXZFg/f3r56OqFd98/PWBTE8mviuwpz+LICuaVFf7z7uH/Z0yXTz0/w/iJj+Urx4dfPGxsf3gYGS5/fPqT+wfH109ffoirKzAysHPy8nEJ/eL9++b33V8ict9ZX3IyCDFLCIn9+c3A8JNR5r8Qx4f/XN8EeDT4Pwv9/vH7Pwsn0/33X7jY3/5TZBFgFef4+P0Dy8eX95/ffXaPUYRL4e//X1/4bly7wPKW+b2+iN7B71e+vfsgysv98z/LJ6Zf/H9+icurvv365O6vT6rfNQ9+e2Ik/FpN0IDl3ysmLomfjN+ZGP78YfjG/Z/rPzPnz58ff3P/5/r3RVta/N7thz8vX2Ng5WTkFGL4x8nFCrpf6wMTBzv7vy8fP3HwCDBxc376xMUhwfT3J9+v/z+ZWHn//f73n/3nrbc/Pj3/dpHrYzSTNJccr4Qam9Jryc9sL/4yKPBx8Mqo8vqoaz0UFHx956w8k+hveaHPd9+LCgiyC7EwvPn4j0PsD9tb/i8sDz78ubzj3kv+V4libhzMH1g5fvz5xszEzvX3zzcORtG/DCz/Gf7wPnqxjfnzpcdPme8/Wjr9uFEsl4aazGdBtm9ffv5lZmH+9+sf2x+G3+y//v/lZGRmYv3/4wcrI8c/IW52NuYfDfvX3Zx+VJFP9SsHaMnqPxYGrl9sn/gYBD/9+s3I8uozo4eOvLoa83eGz+//MAncZ2YUYhfkUmD4yXD56bP7FwWNZD7ue/D06zsBJyXBy4q/H/zhEn/z74M477frz//zCArd+MNq9o9PUJ778Z9PAl+4GRlYmIWYPn/5++MXJzfvV+HvzOwMXKxfv/9n5X32hUtGlYvj/W8mxTt/n8k8F2Tg/MrCwmMsI3lC+9vHfb9Z/3xm+POTgY2bh1eA4fdPtk9cXz69YGFnZfr/m41R7OX/b1LCIvoCzNK/XzIzcDD//fqThe/Pz28sHP9/fX//j5FbiEXz9+c3P7m5/jMx/nj/gEVQXeTri2//+UREBL9/+sDPI3Dr87PvD388E/vM8+MnO9PPr8zyUjyM/9h4Pj7/dOvy5+1f3r74w/X9C7OgmIJ8qLGVlKO0sMJKWRWTX7eUms4+/P2D8fHvq+sfXpG6Ji0grfqEX9hQkUVN+P+HX58+cgmLPmF4K8bBysTFw/qPgeXLT1FBmT//mXhUpZmv/f/+5fnrPyxC3CxsPyQ+Cv1ifPuTS4NZ9DXvd+EbnGLqrB+/87AycTFwvHn2nPEb09u/T9j4Pv149efzs5cP/2j+/L/7/QdZTqYXn5m2Pjv59t1/rm8P5Bk4OZ984PryiYNT/M2jT9z8ciLcYv//f377892hJx//Pnn1+y8TOyMr6+9P//8wMjFw/Pr/5yfLr/8Mfxl//fvy5y8XD5ucnsabD39YfzAzfn/x9QcnNy8HA48QG+NvHm6OH99+fP/x6++b58ysDF8fvOQWYP31m5nv72tOduZvr54dvvL4yvX7n698OfH8/e8/H3j5zZ21JHXjjbhEWFiY//388/fdp29HH59m+CT4/9t7zpc/2dh4eLjY/v+X+s8O2ifM9/HbnXsvF63Zzfnj64/HbzoWrHz28O6fH+ysHEL//35m//3v8Yt7Fy7venTq9IXb504cu/nm5bs/LKwsF55V9B04/eieBDsHOwf7v/+MLKxMDN+ZWZn+c/z7/5v537dfDEw8DHycXBzM3zov7H/Qe0aSVYhP7N0HsT9cHLzM/z4x8TDzMYv///P+zieOYE1Rc3UpfnH1/xziAsx/GP/8YHz25vfPZ0qSnJaCCtwqfJtvnfr+9Pf/Ty/uMP/iecvO9vSZ1Cuh38/+MHD8ZWMV/KbDySgoIMkn8F/wLy8TA9tPFr4vjOxsfwUYRbn+3fknyCjFIKTwT0pYWfz337/s7xl+/2VTVlT+xv2VX0OUVZzv4rs773n/Mn1mZLjz4/+Pf4xizDzMvP94f/z5/v/nJzbQml52XiYuWQ7uv3EqGrEJ6tJM795842H49OvLj9/cHGw//jKw/uT78Jvt3fern/+zvGL7wvGH6R/Dp99Ckn//P+H4w/Cajfnj81u/2f/cefPsxaOXL9l//b//6eOXrx9//tTgEhBTEuKR/qgrz8Mh+vfG/W9fnrxkE/ph6aBuJKb+7sO//wyM0mxci6MLP5qo8wmz/f/78d/zt7+usTy9/HDXw5f71m59vP8y258v0qyM3Excj+V+CAl+4hYR+feLkZnz248fDK9u/WHi+yb8R0KAV1pAmfPnn29Cn7kUWIT4vopL8TKq81kxSTHsffjg+5MX39jfKr7nNdQS4ObhZGDm+yMu8PHPJ9afbAI3/77mYhd9+ZPpx2MOtr+8QgyMjEIqZ7+//cMj8J2R48f/zzck3t/8ef//G94vfzk0/rLyfvp16OU1Du4ff7+9+8crwcTCyszE8peRkenbJzYGTsY//5n/MbCx8AjxvPwvY/yNl4efh19C8Pe7d1/+fHzDzMb8+89vQX4ebkHB7/+52f6+F+Dm+vOHUVSM891X5ue/H0lJKdmqifxg+8f8+/fTDx+4Prz/8ouFV0/Qn03mHzfbx1+/DD7/XPn5Huv5r3L8jA8/Ma1+cmf/v4dfOXl+s338x87J8efto0+vl27e//P3Lw4uAXYx5v9vf609fP/Lhy8sDB8Y2FknPFm3/t7ps9wM+57fn3Lsxs8jTxm4X7MJM/z7++jb7TOlPUcv3bkmyMfGLsT67x/zX3Ymhn+Mf/8xMvxj+MfEIMTMxcH8qePWicMzj0v852Lk+fmZSYL39dffYsx/pWX+fX/P9J35L4tUsruugZ7Cd55vD18/Z3n16tc/RiZGht8sHF//cn0SkeFlYvv/4++nF3+/vGP+/4eR89On378+P38lcuDhtf+sPzh51UTU/oqw/GFi+vXz/1dJYXlOVi5+Kf4vYj/ZRURY+H59/83D9oaDU4j1EcM/0AZPnn9CnMJcQsLPft1XZJXi/f2T48lPIV7N739/f2N4wywkz8/NzvZL7MfPH4yP/vxk+fr7/3vQqipBhn88fJnminGJVtr6juJ2IdxMrL/Y/jMzM7Ix/eX//vYX819BLh7u79xibP+Yv3B84gZtDuL5/o/5H8ur/78Ef77nZeW/8u79wxdfvvxk+f/mzX8G1m9CrOpiggbqrOb8fOIf2NlFuEUkhFgZuZgY/vGyML/+9vkv49sfT7/++QO6bs+FW3p7V6VQlJmApsyfH6AhYLYf/AxPP7x4wnz6xtW9Bx/vOXru/LePyh/5nr9j+/zvy1fQUVwMDIJcEgKf//7ikuL6+vnnS7ZfjJzMX/mkuR+//ympyfv7J++7t2+Y/jNzi3B+/87McvfXR67/jIpComJcxvKiPOys/zm/8/MyPv3O5icm9IGFk4lTiY2D9dtP5o9vfz/++/k98//vvGICzFz/WX7zsL1k/Mb3l5vpP5+aBIMg94/XTGvuXfr34+fv/6//sv4GjXX9+v+Lje0n87+//38xMLJ8//PrH5uwgyYfi5D4i89///748uvHz78MDP9+/vz5+e27r/9/fPnEw/z1v4Dct99/fn/+/Obh/R9MrHx/xP/zsAsrcLgbybH9/cb+hvEpq9CHT2dZnjBNfHfv+ce34swcZ558fHHkuyof26mXr7Zee/T0wncveWke0LE1zEz//ty++3r2uqN/fn9n/Mf2k/Htl0/MHFz/Pj59OeP4pYfPLi3/cPLXx39/OH5zsf998u/LvzdMX7g4v79m+/np91/Fr2xM/P8uXMuct+3d0+eCPFyMguwMLP9//vv35///P+yMotKcrD+/xZ/Yc2TCLuuPfznkORhYpTiZn3Pz8jA9+8v8jvH3959/1ZiCTMX05bme83348V1IkJH/69ev/Lw837g+MDCxMnHy/vv//sbT5+cPPGV99+sv9x82Nq5H3EIfr7xhFmHn5hVlE+Vh0mVk4frHJSsk/F9S5i0T79+Pv/6z/WLgEnz9h1uGV/of6x8OdtHv/35++f2F95eirBIvK88PxvcmEvzsv1g5vvx98eT1u59f3zK8/8/61/6fMSPX+9+/GFj+/WT6xfj3B6jJycvJ/JudXUNSs8RBylhb6AMbjyTHaxl9+dfczP+//2L6zPjj109GHoGnn1/++cPAKyr7m4mZS0zk76unf/jEP/7/z8DCw8PwmuG7zLlvn9+//cD67xczF9P3P8y//343FBZSl5H8wvT3/bc3Ogq63z58Ynr74z/Tb2bmn9++/r9+9PrxfbdOnn6Uf/z8zif3GRi+SqtyJatatsR4sSmJf2dg/Pb7NSvLd3YmMc5fPO+eP73/iPH05YsLdx29eumxEAcjvxA7twQ/33/WfyLizAy/v3HxsbOL/Hj39zcX8yem/1xS/NzcH7+xcvP+Z+bik1D9LsXJJ/BXhOnRs8/37j3+wyIgo8ChIC+moKb8nfMXD9u/rb8ffmV8w/Tz5/cff//9+c3L+4OD/58IMysD07d3/1//1OUQfc/z9wPzm8s8T5/effn9130efm6OL7+ffvny/wcj4x9WBjaWH9wszH+Z2P8zsLBwMfz7yc7E9ucbxze+r3Kysu9+83398ZWPk5X115dfH38w8kmICrD++/Hx91+Gnx/f//v+8Qc7x8ErDz49uPPxy49f77+J/OHhFxb/y8D7/OeXEy/ui7HILH959/6OpzLfZd9+fHX1yzdt/m9bnn/bd+0+959/SS7GvGxCP/6/+/X6+63be2euO/L3xQ+Q7Syf/7EJ/eZ4zfKH9Svv+98X3i7Y8eTVo7fMDAysf39IMvBzvPvJ+vv7/9/fGTgZvvz/8/+F8B/mJ3zMb7/uuRzVdOze80cKQjw8bFx/WJiY2DklOdl+/vwet2HZ145Nhm+4GfjZPoDOBGFg5WL9+Pfvv99ffvx4ySYuHq1pICsl+u7/e6YPYk9/PHzz5NE/Dq5Pn76x/xBk4WT/y/578+PLK7cf/ffxMysTp2y4tLe1Ms8vNiFmLq5P7CJKzDoawiZmwsJiYiK/xf8w/H7z8eNbdhYmHl6mrww/hfj/Pf34hYH5w/evrD//3/nw3opH9tqlazwszH8ZuF5devuZjesjy7cbHN+efGaR5GR357eV/P2V6T3rP6a/P7/w/vrLyPzzyz8O/h98PHGmMgV2zCpyXK+4dF4+v/Pz1kdN5tfWCb6//3/7/+vPly/vfvz+y8rI8ffvt1+ffv77+ouVmUtIQErw/x/QDj6Gb9+ZFK4+ufPpDwM7A9PPP2zvfrziYmA2V5YVFmb98o+dg5Hr1Y9/Hz480uQS+M/IyCPK8/sPB8u3R3/fvrx3+PT5czcErj9fvOpA1Kp1eu09/YePfVOUdAgMZ+b5xsDI+vf7jz9s95n5Obj/szL9f/P3Fs+Ph39uvbx85eoTEWZmViYOAQ4+jg/f/v/7z/iPUUJW9PePr4qSKr8/fGP9wMDBwKLH8ZVDUVxYkIVdVFhe7DcjIzurpAjjYzZzCTHm79zaEirvHv379/g+iyg3723B79++sXAx/nnzh4Xj91NmJgk2boaXn3/+Y/uhIiJ5/cdbboYvWgJa9x/c/y7yVeyf8mfxtyr/pc9dvuRkr833l/Xvf1YmFvbffz8xMnD/+feL8d8/xu9fGLm4/7HJM7B8MdcXvXL3/8/3r1jZuDg5/vz/8/vjf1Y2bqHfoOvy3vzlV+f49vAli8C/R0++PfvMLvLLiJP3yTvGXyw/uQX55X9zrfnxkOkzjxTjt5dMr3/yc6jyMX6QEuH6+Pf/D6bPn9m+i7z/+/zP439PDtx+9urqB6bv/9gFBH78BteZP97+kPrBBDohguc3I+P7u0+/PWNgkONjl/58cvOVb9x/mUX5/v/48p/1O/Mbzl/MH/4xM/3h/SX0gfvVmQtJS/+uSWMU5RL9xyLMz/bj/e9HmRv3ia+5Jsgr+IOH8bsGh/ALFmYW9rcf/v779YGRg11KRjBYW1fs7/dnvGJfv3/+8+yJCA/vd67////9/s/I9FmYjfHtryNPzp5edJeNiYNbkMdcS8Dsj+qiH3eFGX+zMXE84H7E9lWSV+Kz0hf+i+Lffn749+PNK14B+S8f3/B8/cv65zWLrO6z688YGNjYOH985hdi/P/z2a8vvzTYGT8zfub5/lxQkPHRewVFiT9fv8pqiwowfvr78SsDj9h/diG2r+++8vzn5Rf9+p2XW/l7s56ViDTPd+5v/978Yfn2kpv9/6v7T5kYefUktI4FmQgsO/zjCy+LAJvwb753nz8JCvAx//zA/pPhy3+hv//+/v3+7/WHr48+/PnJ/I75Jfdvhj9fmRn4f0iZ63ILSfK9fPf8z5/nH75z8v9hfcz8nfPLP8ZfjMy//rNKfPn/TpPp60PmL0z3L19SlWdluflu/+W7HD8ZRF3VP3Ny+Zjwnziu+uPG2x+MDMx/WH8wMLOKf2X9wMzIyfDvy++/79lPnHqpLC7KJ/rz1Td2Xl5mVjamN89/cPD/5GHn//v1LR8z/1ep3wx/pd7xfBX7yvr961c+JjFOUQWGjyz/fj7ns+f985TrDfPTa2/fsopxM/zl+v7q0x+2F4yvuVh+M3LKf/rD8F/yDf/ft79/8vwS+Pf7DzcT6/eXL6RkxAW+/frDyfqU6dOH/2+FXvy/IfHs91uOHUeOiZpLeXI7fPz9nZtF6OvvN4wM7Mws3KDtDv8Yf316w8DFxsQvLK/G/uguK8fnp4ys4n+5WZifvGGTEvrxg4WNk4OJ+RM/K6OLu8bmvfuFn/7j+8myg+kHIwePCB8Xk5LgffbvPx79fn3tJjvbf0YOdpZfTxk5NWW42dV5WFZw//j/8f3s6XuY/3Ox87D/fveCkZv/P9efbx+Zfym9Y3zIycrEz/yZ4euvn2x/Pn/8+Yvt9/dv4E4X58N/3z/9ZWBl5Wb89pvl6/+3zKC7Mr78+cYizsz7kdGGSfnC41c7voTy3FrhFqOjpLP98836UwsMljH/4mDnkuNn+v/t+bPP/z7/5mdn/PuPifmZyNOgb6FiIrIygnd/MbM8fML65S2DpBzj16/MLCxsjN+/8Unx//195u7VrbvvcDNzMv79ruSlLvydafbta2zv/rP+Y3jPwKIgyPXt9VcJPvGHn77/+cn7W+it2Evu35xMQlyc7Bx8XP8khVTF359/81nukfw3nd/vPzBwfhL8IPubgY2X/5c9t9nr77ceCLL+4uPV4WeXecH2RdVYko/l991bDAwM/5mZuaVY+cXY/OS1jPiZeEX+/GJlZ/7G9IvlA8uvb0wMHKy8/559eCLHKRYtYX5U4cOPB3f/v//+9/9PZn7hb78+C/CJfHr2iU+ai+nr+2cMHLfffWNm/MP+jffnn1//vnJJKX1XF5Vk/vXn91eWX395BRg4vrH8ePnnOz+7/PVPr7/8fMvz+edPTlFGjjf/ObgZ3j7//Y/t/OFbL35++MvyXsjVNsXBhPMHx9L3Jz48v/vv/28+Hr4vP76xMLAwfWVhAp2zy8fAysrO8vHHB5ZNb264/OeR4Jf5Icrz6tEbHk7uH1x/eP58/MPM/uTTfxVuhns3X/Hw/P3H9FeKgfm/ONfPH7/kRZn/P+J+/ZFjK+shsTvifLwiqjycDzWllb/+O/KRg/nzH6bfbL9es7N85vz1898rLk7QvhM2NqZ7LD+f8P65cv3XgU9X/jNxy/2T+8Dy/Qs344/PHH/V/j7/9k70FfPPd08ZWZm+/PvAwSbM+Pvbf9DAGeOPf6+YGNhZGXj+szKJCAoK83EwsLD++viW4Tvbp59MT39+5mQFtfAZGf+94ZWRfPxAT0j5Hcuft19+8jBy/eb54xfgJqHG++bRx8+P3///I/jjH8PfDz8ZPvE+eff93NPn2759+/HwHQMzgyAnF+d3pj+f//38w876h5HpHwPzn2+sL3iYvv/6zveU6SPn9x+/3n74////F0YuLgbGr5xfv/76y8XC/Iqdhffvzx9cvySYWH7//M/8lec7l9Y3ZjFh5a/8zPaKoty8//bcqpg4a8fB9ZUbtwtOe8/IwMApyvj/x893/1nF2QT+CvC8+Pzxz883n9W/FxlZKcjoPWRmZvjyl4eLhZtPjPvLJ15uASZ2hn9q8hy/7665dGnZif1M7//8+fdD3kpTl1HwwMdv8h8ZhVl+sfEJiOjxiPNK8iowP2Hg+/Pz6y+++zKv2L5Jc3Exfvvz4w/DlyfyYpL///0Ere74Jff87yMWBjYmFr7PEv8Y2L68/fjnwfWbL+6+/s/KqcIkIf5Jgk1FXuwd251vFy/ee/f/48ffTNxyCqyhanr+mm95hQUZ//H//vj7y8+nHCxS3359+fn7LyOXGOsP8eevrrMzfnbwsPkuJP3t659//75yMf7i+MHx5t97IWb2Vy9fnnv6+P6Lp5ysnxl+snxlef/1P5+qLJuxuAQnF/tvXpZfDAycf5kY+BkYPrJK8wi/f3Hj0//vDP++/GBn52BlZ//7+b/kZ4Z/nAz/GL59/iQlwe3m45QUYcQgxrr19snjiw8zv2Li4uT7/f8dK4sAM6/Av8/ffooL/hR4yfHn5x8eTjZmvueX3525/Pnrw4effv8WFub9y8P4/fWX7zx8X/7+Vub89PIfoxgvJxMvoxAX+zteJsbXH///Zvt68+1vESYBThGlP1ry0sK8zF+ffXv65e1X1m8/hfmZ5FRlmVhe/P3J8YVLmJ/rjxjj39+vud5//vL5y5ePP1k//hVj4eWT4frH9OH/V5GPPN9/fHrPxfT88y1WSZl9r589ePTg96+fTCyMf359/8fK/P836FAhxr98zAz///749v/vu58/v4ooCzKJyn9n5WJ4/4Lx/+dvrxiZ+Xh5RIX+f3t5986jAw+/C377+U+Q48tPvu8ivMoSGo8FX1w+cvbnq9+fX75iFHgFKrSZfoL2Q//8+uPe11tHn355/YX9D/9fti/fuP7+4v7Cz8X8XuDtH0bej9JPGN8J/mNgYnr3/+v7Z3/+vWFlYWZmEAedcyf9l52N9d+fzww/OH7wPvzDwvjzL/u//xws/MwSMvLC4hySIozv+Rh/8H1gcWSRkeL88Pzb7LaV6vuuKXNyfhNleM/1l4Hlryjn7y8/fjK/+/r9H/NXYb5US1P23/zv//5k+PGHh+H3bw4+Nm4uFpa/v5lYWCSk+F6+3HHg9cmNx349ZeHk4pUxZ/e0Un3G8UH1t8BX7i/MjJzy+hKq8tK/v7+9z/BFmu33Zx4B/r9ioONHvnx99O31z7usn9jELv+89vf9T96/PExizOK/OYS1mUX4xPhYfsvySzL+47r9/aGAjKqzkBQ/MzcrJ+//r7///vkkxCb9/M/HT4y/NRQY4mWEjWRYX37jZ/jx8efPt7+YP7D9Ufz94x0zHwMbw1/Gb4+ZWP79+fiP+clrQc4nYR5GLxQ5GP/x/3n7noH1F98Pjj8c3+8+f/XxI9u/Tz9+fmL6/ffb95/syqKMqvIs/3g4GH/9+/uL5+2bhz+52F+9/cnCzvzlM/MnJs4fXJ+Yf4j+/8vx6/s39n8c7LdZf3Ozcf9lePXx8Yc3P6SFeK9/ebjr7rFdk/b/u/7wD/vn338+/vn/5x/D51/vnjPwC7I+f8/+V/EH53+GV3/+cn/ieMv35M6Lg8wvhH6w/Gfg5OZnFpXi/cHxn41F4p8AtwADwy++z/8Y+Fh5/vF/4f7E+vDjm2+sslKMH4R42JjNmPlFJbn/cXP+/cdqJKzNJiVppKipbMTBaFPqK8nDyvaV+xzjC7EX4v8F330R4hW4++mLCAf39/c8AgIvuf7/Ynwrxakh+5/185NPzwUZ/n/5zMLAo/6V183O/BcLC+t/xl88XEz/WX//+sjDyP2N9R8zwzfWP1wsjNyf/77h/fbn4dc/n6+f5eblZ2Nn/f6Pg5H9M9OX/48/fX/76us/Ye7bDz79E/ilqazOyPXn6P6Ln5984xVgZGL7/5+dh+n7b6Zfv5mZWN7xf+B6z8XIxPaPkYHxx8/f7P+Z/v5i+8P/9e8XNvafP77+Z/0j/ov1wT9mBl5+1Y9vnv3++J2Z59/fnxzM7N9Z/nF84//G8omT7TfbH9bXDD/ZGX6z/pdjFBMW+svzR1RE/tOrh2xsYl+FPrGJC8p8+n5r52fO/xyWCkw/OUS+8Pzj+vf9x2dmMV4ugb8fPv7ie8j3PVDPQprty1cuWaYv739wi/zhYuH89uPVm3ssbEKswrx87z72Pzp9bc0rxvcfWfk4xUU4dcwkLzN94nzxTVqEj+Ubn6gO4z+GP/85hB7c+MQgx/T2xXVLKZvfv188e8LwV+bP988/Gb+xM///JyHC8OH3V87HHJ8l+X6efyGixiIvq8X/6c/V7x++/P//9+kfOydd9o8/GNi5Pv98JiRr+P3HdcX/4jc/fXx7+ZGjAT8Lu9ibn68Y/4mz/HjFzs338+s3RhY2FmYGhl+/mDnZvv9jZmb69+/7bwYWVmYBUQkxjhP3nl0+8pLx42lGTvE/Pz68Y2K58uY93zuOL6AJBK7v/z5JK3Ia8/B/Yv4nwi50nf2N2B92pmcs/8R/s3xjffP/M9vXj8/+yD36fJ39IwfoLoS/jPwKfJ//Mrx7+Yn13VcGTsHfDM9ZBY2ZeZ/9e/ib4dc7TmbB3zzs7Ez/frP8/vddnPHPfUZOgb8sDEw//zEw/Wf4xcgIuvP5NRMr9//f36OcTKXNzB5+fczPKAQ6a+npt0ufb4v8+6+gqsrHLfj3+ce/whxcbz59FmZ5/+afOMenZz+EpP+++cIs9v3zk7/KbO+PXOeSUlSQkz377DTTh48/bn98dZ/lg+A7ma/C7/4KiXO//vhOjIPpNccfTvHfQmyMDIwCHzmFWTj+Mv9gl2H5yfBdXUyK9/+fm8LP1727wPaX8SfDP2YGTtavHxiZWX8w/uf68efvT9COt0+sX5hY/v7gZRBmZ/oupcLw/SMzlxArGxPnfwEBYQlxUTFNNREdbtb/1mx8LHKf+F9/ffrw9/N/PL9/M/7iYWNg+PX900+eb/9ZRX8w/OF6w/WdCTSVzvD39/+/7Cz/GP//YfvO+YWZgfnn328sjBwMn28w/OL848IaHWkhEyDP8Pczw2cmjk///3H+/vubge3ZfyYmpr8Mvxj/M7AzCv/mYWaWZuD5x8n6lfvFlSd/3jC8l/37n+cvx+vv907+efvi7f13Xw7ef8/2/70gm4QokxADI8PHNx9vvRFg4hazF9eW42R8/+/Hvz/vv39n/vf+DuOL97+/fOXlFvvNyfPr/Y8Z249dWnnn35d3bJw/5NSk9PTErv77xnLzD/tvPmYmJkMzEx1xdWU+tfuXb0pKMqkzsqpy6Pz5/ZKLWVxJSFCBQUKSV/HP/a+MfLw/H8vJCqn8+cvI9ZuDjZ//1Rum/+/ZLn27Kc7FJqnEa6QqxPzx/7efP//++iGmpCL4672koOlndh5p1k/W+uxMjKzvfrxk/83BzPyFkRm0ipiV5T/D/++/Wd99//8fdAnU30//fvzm4GBk+PX+x4sH79/+MhGR0HTSYecR+Pbx/7f/P7k+sjL+lP7K8OTXz89fRN7Zainp8Ql952DjY+P49O+H8k92zg/sPwV//Pj56x8LK8tfRi422SfsdzleM379y8LI/O2X7B89fn4hDVEJVv7/7JIMf95x/+JlePHk1+0fzN//s3IL/uX6w/KX/ack1+/fDP857/9jEPjN8YX5IzMjw/d/oHvBOJg4GZmYQDyGn7xrn1/98+qpFJs4D8O/y69u7Tt+/PK+h2/u/+RjA525/JkTVDY++8fw7/lvTg4mtt9svOw/v3D94mD9JMnF8fferw/6fK8/vbl++9zHr/+ZWJl+MXJI8n/h+K74lJWbl/Pju+/i31gZf3LwfmH8y8LxjVmFV4lTWPzm3+e8n6R/fPoh8J/h7Ncv/1gZPnCyMT/6+vDd8xdPL//78/cXOw8j5y92Ju7vjIxMjExff/7k+MvB8YX9LwsHEz+3nBTnR0nN729PfXz25t6rb4+ev+L/9X7Nn69rXr/hvifw/e+9xzvffnz6jVmSi4P/LyPb519fGVi+c7G9+8fA85QZvH2F66fG32/f/7D//MP4/M9vdobffxk+/2PgYvj/nv3PT+5f7GLsIWpBBt5CApzGfFJqahYMYj++MX9kesbxi+kPCycXw6df/////fWH+/v/twKC3DxP/nzn4/324c0XVo6Pen8Fv7NyMjJ9Osj44dkLdhZ+HsaPr558PX3ni+jXOxxcbCysXC+/vX8o8ctK+7+hIsdfNi5OXknmv1xcPMycbMJsDK9f/XrL/OMn+6+fdbt2nzn9gPsTA7cIt5yWvpL671t/v/64+4yf8beBEK8yp/xT5hNXXtzce/u4srL436c/b7//+vLXly/v/j9//JpLnO3NrUcfLn9kUvrNdufRF54H/7/+/6fN//H9awEFAQlZ3o8Mr5V4zaV4hK05tYXU+P79/cnJK8YlwvWflZeN5S/Ly2t8zy9x/GBnZhL6/JONg5H/Jxvjn4+f2Zg4mRj+fOX4xszAz/CHiZWD9fvPv4ys/Iysf37++s7AJfaL5dm3l09+/v+ix/GXzUBfWIhZgIXl819O9vcPvzIJMbFx2PFI8rH9YGLn4GJj/f7pw5///168ffuZ+TP7LxHGNz/eM7L9+vXw6Y/7zA/5QHuFuJhFmNnlfjI+ef//79Vn/1l4ONh+s/zn+sPFxcD0gZ2Lm5mZ7R8X8y92Zub/vxmffv33/R/TJxbQ0qRPXGyc/34zsTJz/WP59/XPx+cMzCxMHGxsXBy/7vzfcPcy84vnVx/fPHzyyttXzBxff3349f/zr19Mf//zsHz5+/EXrxjnT0ZWEZEvf36yiYGMlmBh/fNSQIBN9LPuKwVZdfGXHN/+giZtpST+Pn/5mv2P3CNBPmY2xh/fuP9K8HKJMfKwMLN9e/WD+emvR3y/ONn+Mxzlu/qfVVCTX4mR49935hd+v/Qei/y88fAO80+hr1+usfz9w/CV4+efT3///mRl4f3P8Ivpz//vPCzM/7gZeP7K80uKSjB8Z9JgYfl54uz97WeOz779gPfyb05mltfPL328//XF11uf3v75x/aOkZPr5w+uHzI/GFn///3L/eMFHwPf379/OP98u/P/DyfDj9+//rIy/ONkZvzz78/Xvz/fMjAz/Pv1lkdZ0NfI0IZP4eC7B3dYfoe46oXHuHHxCf7+843pB8PvX+//gc6L4Wb6zS4goSSs9EdISOmV+EMeCXkW1ef8TAJ//vxi+vj748dnTD9/MDAxM7DxMnAzv2MR2fX65//7dxlYfj3nUazU5JRTNHjF9IaJ4f//v5z///1m+fX6969vX7hkePhlH//52bJh+9cTN5l+MDJzf1cwFGMQ+Hb48qv37z9ICEkyC3Gy8HN/Evz398W/W0+Y2RkFfv7j+Cb9XZSHT0dQ8O9vJgE5ltv/3slJCIlKM7A9Zv/+/h8DA8PHl98kGH9JSym8fHXv60/2vx8ZhOR4hfiE2VmZmf+JMwtyc3Bysf1nEXn34+UfvnevXzFyMnz9/OXnj6/srH/+/f3z7+NXJl6JH7+//WHg4PzJ9ht0TI/Ar78cjKxvGBh+MP76+fO/4K+PH4U5VFnZf318/ojl11dTSXFuCTkOLpEv7x+8Z+Dl+v/PWEZAWl7p48/v39ieMvz9wcTE9+/PP04RyZ9//39nfv6Tg4H14xNBAQMmNuH/P9m/sfwT//VNgkuM6QvHry8fxf+wfeT4ycDPxcTHyM3IyaD+h4EBtH3wz9ffnP+ZfjJ9+/X7OyMj5x8WLkbG16xc/L9YmP7//P/3L8NfXm5mFp7/7KBm9O+/r//9+Pfk/JNlO04eOn7p/1spNvaHrHzsnz7/fHbtGRMHB2hz/L8/7IzMomK8r29yfhBm/vn5OyvDvz8/OFm+Mon9kRKXYFFmEGX+xfDryTcmgY//uMQ4/3z5+Pbbi09ff30T5fvO+u/bz7c/OP8J8fDIiorwPWO6w/H9z5HnvNfeXmF68vzazZ/vvr94yX3w4zE+ZmY20d+X3z96/u7D979//oNmzXkYQYcSvWHh4Pn2/yP3L8a/v77/+8nxiZlNmFWAXUTwxz8mnj8/Pn7n+/bsx4tPz1+9uvvxNzfzbz4WFq63H1+zfWT4/v0nG9M/lie//v/+xMzA8JfxyU+WdyxsXAzsjAxMb/7+5GL9yfjv95Pvv/79+8b875XA3z+MvAYSSf5uXH9/bn95h4uVNZBX767oK1NZA2N/U1Zern9/fjL84WBi+MXA/YpfWoRT/YOkiCy7+n9+NtaPWm/ZhYT/MzCzfP7+7gzoDtkfTKz//n759fu9MOcPxq9PHz7/t/0lg4Awf4OfsYK+1ZO/PwSZNRg5GHiZf/38/eEHp/hfBka296+fvf7Rf2D9m4u3uf9ys/MycfHJf/7w8tfnl2y/mdk/fxD/zy/4n/0s2+0P335fZPqmKS39muPNecY7TM+EWL59+fXlPy+r0HvGr6rvZL5K80vy8GrqS0vpyQmyCDPx/fv45NuPT4+4xXlFlQR0BdlEuHiZpTmffHzG+J3p39cvHDz/////84n7L/vHJ4/+iH1+x8Dw+8+XP1y/GNmYGP5ycrAw/fz8j/0/AwMr4z9GRoa/H7/9Yfjzg5VV5s+PL/8Y2Fj/feTi5v7//+M/BlEGFoE3P56KMn0xUJL68l/o+w8uAUYWPUlBOQmJN5+fi4gqizOq/v7N+JeNg4+bnf/LP95/gl++MQhLK/IICH/99/7Vi9d/mF6LCIgKSnJ++vPxE/NXBlGun1Hy/WZKrHIcIkL8YuI/neX8mP7/ZWR5z/D757dvP38w/eD6+f839y9WFo7v3xn+/vz8i/EbDy8747dfDP9//udgZ/rC8E/oEyMrJyP7H5YP7M9evvn7gZvxzyvWf8K/uF7/+ct2ju8h068fr4TfPwYdHcH6nfmvoAwrzy8uLhHZPxxMf/78+MP66zk/5/Pv3L9+fLIUUxVUkWT58OjDf0Ye9h+f/2gKCnF8F2GUusP4j5/tywcW1vsM983+sN77/+HzAZH3j16xvJJnPPP1LO+f7+8Yf4v95ZbhFhL58ppLkJ2FYceXh+FfWIQN1Bi+fWUADdKyM/3+zcEu/OXnS+a/HH/+/PzB8JOZ6e8nVubL959+Z2PgZRf49/7NB9HHTJ80+N88/8Xxj/2/zG+O+wz/mP4I/Pz/BrS94j8TE8O/98yMCv9ev2T4/+GbKCvr3z//n31hYmP6x/ST4Q/33z+Mfxg/CUjxWXmps7Izsd1680XwpxuHwcXnb03UJP4zc3lYyHy9q332xVXGB7z//j1j+8/PL/Ht33/me/fevJf8IiKj9PPvIxZ+Jo6vvM9vff19/w8H+yeGf4K/udl5//7+z/iT6ycDw9fbH/7LKjGzq8hzPv35lusrK+Mvlm/f/7Ex/BNkZnnDyvOS59H7U++mnLnz78V3HgZ+Rq7PbEK6v/4/+PGZR5jtt6SglDiL0D8J1s+PfvByKsoxsrN+Zf7w7aOksLLqd4438q85v7N//PlfTvwvz0ehnxyvON8wsX769Idd9v+bV1ySIo8+v//Bx8P7lYHxlSCr0HcJFe3fzFx/fn7n4xFj4GJlYOL9C9qJxvmHhY9VkEGF9dvT5zyKXF9+/Hj79v8vKWbZ37yC/77cZf7Dw8HF9vcXGwMLHyfTu79fmf7+/sPCzM7OwvXj+1cWNo7voC1bz/5zyTL//PLuP4sg53tdY81vrJ+5eXjYP9x4+fEdIyvHz9f3frEJ8QgIvHj54i8r8+/frP+43qswc7x+/vkX2+dfX1i/iHGI/mZkZ37w/RvfTzYRdt4PaYHe0jxvOAT4c+XFbx+/8JaJ+9uzEyJC/G+fM/9j/PuNkYH1y69fXKysX/79Zf7Kzi3MwPiXBbSg4SMHn9D/n38Yfn/494vj10dOht/MnCz/fvD/YP39++/PT6wcQj//vWX/Jf3rz6tfVwX/8Tzi5BZl5v7M9On/n+9/2Bg+v/nJ8OuToJgoz2/2H0L8/B8f3frDr/D+H6swtxDnt5tMr7+///7x6y+xfwIvGX6wcbxl/iX5/9vvlx84/v9R+iN5m/m/lKgCo8JDtl+i7K8+cH358vn9e3auz6wveD/9/vuchZH1P8dVhtcaTAoP+d+zvfv5+/870OqxX0x/mf7+/faalYn/Hxsj138eRm52NlY+tn/P7zx7+5HlzSfGt78Z2Jn/yDPw3f7KwfObm/cX6yMmdrH/P7j5/8szCv7+yyT6W/jXz19M/wW+/vz6jZlXhOMtA8NrHkZOod+MAr9ZGf7/+sDAwiGopRYV6KXFqXDg+x3O3yKuzIp3v3xUEhdh/yHy7efbtZ8eBbmaa4nq/uV5y/xbhI2H/R8rG8dv0V+Sf7k+8H/49EyGQY7l/fefZ39+e/GfgeXvN0YOZtYfnBw/mFgVP/7mevTz7+e/oi9+PF+05trpw6dFv7JysvMxs/xl5uH6/evbDx5Bhm8fnzx+PX/Xif93PnL8Y2HiFmYT52D7/p7tLwMLA9N7tj+84r84BbnlJHkkRLg+/Hz59MM3FmGtv++ecrz895zzNd97qZ88//6y/P3GySXAwsn5g0tIQJJRQObJi6uMfKAN7+y87HLvPnCL/uUQYnrw/s39T+85vn5kYP3BzsDIzMD4k/slG/hOB5YfP74yM7EKCIiri737wynOKczFJvrp96/fn96yMgsxsfB8+frwz2+G/98+sP75w83FysnK9e8P60/Gd4ycgr9/PONk4GFkZmX4/o6NjZ0TdI/lHyMFoUJ3Ox9Lc35FM8Hf3J//vOQQFn//8/VfJuZPPz7xf+XhZvzO9JfzHzPHP6YvHIwcP/9+FvrPzP6d4c8/zg9fWWTVeRID3bWFWF7/F/v+768a23MpYTb1H2x3fzP/+PeZkZPjO/M31veM/0QYQEdnf/3zXfQ/+6fvf/58YWZgBZ2G94/37yf233+Z/4Dawf84+D98//0LtPz2AwszKyMzE/PvH3/Y/v9iZeP//uHlDxkFLmYWrn//bz37xc72+fFPXibef78Evr378fUVC+vHlx9eCgsxfP3Gy8r9699PSSYhJiYuGR6h/xzSnDwKbC5Miv94WBivPvwvzyLw/+vrj6z8X/+xf3rEwsrL8u/PP3bx74K/2H4IfJFhZhf4yKzAJMT07/7v35J/Wa79vXH7ybtjj+58+cjKwPjpHwfD/99Mf1g5fv//yfST+fvvj/+//PjB/pXth7ixpjQTowbzu7e/hHk4PjP9/PefmfUX4x++P4w/GD8x/Gb/9OnfE5bPXAz/nzC8+s/Iwchw/zOrEONX1nd//7D/4XzH+vH1n2+MTOxf2L8wMbMx/Ff6xPn5F/MfdovvSiy8nH9Y/0qz8krw8zz7+u7Wh08ujCIXWJ9zyTGJqsox8HL8ffv32+MfXz5+ZJQUENcQUPkj+Pno64/rRF4/firw7e9/jl+sTNws7Lz/uL78+vGI8Te/jrvTuu5yj9np1z7cKJtyeuvig39+fGbif///9x9WEYmHjz/evPp40dbd3z+wsLP+YOJi/Mvy88sfhu8MH/78Z2X7wCZwj+fj6/vfeHie/3z89w+TlZgKw4c3HH9esDIzMn7/zsjB++zNO+4/3Dwc3/88ffmHl+W3IMO9h0/vPL7Fyi0uwMf29/O7bz9+3xFneveelfnTe2ZB/nd37l/+9fPji6ffmL58uvWA65PIT5bf/5n//WH7zM3A/J3pH9d3BmYNmc9Mf7j+Mf35/5uF5cfvX9/+MYCuu/rzj/X3v/9MjDycAqJ/Wdi/f33F+J3r17cPf9nEf/5gZGBkYOJgZGJg/vv75yeWP5/fPHvx8RkD+yMZPhEmaTbB/8q/3vxi4+B/9+z9N0aG+1+//uP+8Ovvx3ef/vzg/c/FyPKZ88+fD4y/mdgY/8tJWaiXOllry0u9+Paa9+2zd88u3rjz49CtBxdefuP/8pXtDxM3y7+/Aj9Y2VkZvrH/+/ftPw8n07s/f0U4/n7/8/PrDxZODoZ/7/9LfWFi4/7H9+Hf9x9/vnEzSbP9f/ufme//z99///x9x8Im8lns3f9vrKz/GZk+Pv8r8PTbHwFWRobP/Ey8f36xCQgwvmJj+Pzpx+tP73j+Cz798oXv/+vPb1+8/8rwj4NJTvynhJaU2E/BJ5yf2b9/03v/h8NSX4NdnP3B73s/7r/49l5CRAl0fhEvH+PPR0yfWH//fPv/7p+fQozCHBJ/PnP9/P3+1XdmEyYlyV88x749fvv8CeOXP4zMDEys3zn+MTGzcv5m+MbCLcjMxvTt9+fv375f//3tz7fnjAzCzP8+fGf8xfpA4B8zw9+fj1heSP5me8Pwi/0fx38uBrY/jGJ/Pv1n/C32Q/Af20eBX28+/fz/9z/jl59cAky/nzG9k/wvw8fKy6/Cr/ZB7Cfj58+87KwvJH5e+fmB89+/Lz+ePX32jv8//407H7avvsvHzKFoKMejxMQmw/WH5+c/ji8C33+wcbH8evrq013Bn99eMDEy/OTl/Mn/BrS7g+ED+8v/3zhEZTg0W6KCTf2tJ7hH6vb7Mv9m6N/xaNrGzYyfuflZGF8KfH904cjkrUf+PebgYPjBKCr7n+0nx++vHG/5mLjY/jP/5mX5yiT7/8191Sev7r1k+c+tIvTi5eeP7O9+PeV8zszC+Osv70fGjzJvOLk5v3/6+5dH5NPPn8+uP2FhZPjzm/Eby6dnb16+UmLm+8nG80f805/bN+R+MD38d43tz9uv9wS45Fn+/d/45cuKDcf+PH3+9+dPRiZRDk4Gjj9sX9k52L8zfpSW+v31Ny/n369fGLl5hFn/fmP+K8DM8ocNdI7hny/vHrIx/mLik2cAnS3GDbrPkeErEwPb7++MH/48ZfzHxs7E+vMn0//ff9k/MajK/tUxc/nO+uLHr8e//7L8/vvx7W82xn8/mH9ICYmq/vj5ivs3z18Ghv8f2bj+/XvF+ds33qbawfAfF+vXp08ZPrF9efnj2JN7d2+/fvGJ5+G7hz8YmP/85WZh+yn0QeE/xwem35ygjivoVsR/vz7/4hDl/Q/qX3z7//PPf27mv7/+Mr1n/s3K+JeDh+Pp3x//X/1iFuFk5fj1h4fx7w+250J/Pz1j4uT7z8HJ/ElWSJBFRP7rx1t836S//bn//4PYDx4OQT5pQbY/jD/EBTmZWd4zs/76+vkr62emXzz/H/5/8oXjjdBP4Z3/7hz7+e7f+y+3Pn1gZmESes7A81T43IuLQqxyH34++vzz17fvoEvYf338/P/l378v/t/jecX25z+HCPMnxg+fmDj+fP8PusuUi+3v378crNK/GX79+fWd+T/bH6aPAu++Pv30cfvh819evvnH8uWX7Ie/P3hAh4+yfPv1g+X/P/b/f9/94+L4/+ntn19/P33+9IvtNQNos9Nr5m9Mn1h+c7NwMzC84/gq+vfvawZWHkb2v+wqwioewkISDI/Z/7Lyc/9k+vv/PYP2X/Evv39de/JOT133H8Pfq49fiDEyf7jx8ur7x9/1vjBxcsvJsnMpynGwCn+58/DO5T8/vl9nAM23sP9lYeD/J8nIwfibg/M7qxw7zy9xVdEbP57e+vae6xfLWv+syvb070LKezY9LN21+9r5m8unHp61+9G/D7+Yv/L8Zvny98vn3z/Zvv38/O/v9+8fvzN8/P1R5O+7t28Yfj97f/vvs/efuFlZv/G+e83Ie/fD438/3vEoi31//c2RUevPC0bW/wI/335kff+c14r/y+ePPDzsnxnY+ZlZeL6wszAwK/NwarJrqX9l4WX7IvyH5dnPL4+/3xb68t3zN8vTry+uX3/A+pP5LzvLT0YOLo4PDEy8f/7+5f/2/72iAtvHr2wcXF++fv3x8z0Hn9Dnv3fYmHl+/vzJyMj//tdTtn8//vz5ys757/+Pn7+YuX/9+f6P6Sc3sxoX1z+mH79+/f34+8//v9//M7Aya3B9VbYy/cmk9OfD23efv//5+YuVjek/Fwfvv59yYqKsTCx/QRvTmb7wseZ5mrrLin5jfvPw2x3GH8/f3n944sHlPw8V3734+uf/bzZmwe8/xP/8+fyPj4VV8Bczq8Jf5ndMbLwMf7+y/2f9y87O9P0XKxPDH2amfz+4We7/+fv3HRMz/282drbPX36zcDOLMDD/+Pb9+xcWlud/2fh/MDz7zS/6k5uF/cX7zwzff35/++cHL486E8sbAbY/r5nfs/+W4GS+942Ll+Pvj8/fP/1kZ/j7n4P130t2pq8P/0kzin1h+c3IwWosrCXLzsolIPD724/XcjyM3yTeSL8Q4NH4+vbKH04VZQV5VXk+ARlmATaB3///fX7/ie0Cw+sHH5nff7r769tTxufM33+8eP3k36/fLN9+/WH4/Yfh36cvvxl+fLvx7smHz18en//z8etrjr+8DL/4mT9L/vj28T/HT0ZmNkbmT3+EP/1n+/Pnza9/3Nz/njH8+MXw981HBvmv3xnfMvz8zfzly2eur+w/Bb5xf/v7h/cP40cuaR45MxkzMcU7X34bfpP8/Ov/baYX0r842TgEvrH/UZdWWftu3zP+L866Wgx/f597/Izt0X+u3+xsnEL3hRh+s739df/Pi9Of/n3695eV+T/Hj5//GBi4Xv/7yfD35xeGj0x8fIyh+mo/RX/M2XR1xdkLz289+cHGF+FnZN9iw86qfGvN845t1y49fP+X9TcbI9t/jm//ZYREpZg4VH58Z+f6xcbA/P33f2aGT7d+fv/Ay8D2+efHzx+O/9138xDnZ05hLg5Rbl5RJm4+Ni4WTo5HjE+Z2H9/YfzDwP7xl7yQ4B3u39Kf5dWkGJiZ/v5nZ/vwh/njDylGdkclbR5pQQVp8dc8fxhZWPe/f3ON8xMTN2uKid7h168e33/G+OP+z68ffrNI8LJ/ZBb4/o2Ng4uB45mYBuffl99//Xv/68f//385fov+/svEysb+8dNLpn8yv/58+8n06ffvv38YXvOy/mdiYPjN9JuJ8ct7hudMHPwcvBJMjH9//uP8/urv599vbXjEeJT5f7z+/46RQ5dXjp2V6duH9+8//Lj/7xsPB9Ov/7wsUmyV3s5O9vIff37k+fJL6PX/D5+Ytl99wvD+HyvD73ds7Oxfv3/j/vqT6R0HO/u3/wysX39zMr1m/M/z4++vf3///WHkYP73+eevP/9ZudgZOH6zvvj1l4H9v+wfzhds33h+Cr/7/e8122dxhp/fWVh+/v3PwvTrOyu/JAuCUbvYAAAGc0lEQVTjR+bXH978/8vy99Prj2wM7FycHxnZuX4IiwvxiHHz/PwqoCzM+IvxNwfPz4/fuP9+YeXj/P+bjeX/718sH5hEBZUF3r19zvaH7xfPh7cPfv1n+3P/HRMzM//376yCPxh/KmiI8Cd4yPz99YX5r+Cntx82HXvy8dd1hi9yb559Y5P9zmHB+Ev0N/tvnis8f8xfffwjJcT8/Qnnb/YTz34Ifjn+j1Gz89xFboY/f/hZfv8TYPr25c/Xr8yMf7/9es3xh+PvHwbO/wJ/fn76x/KX4cdLxq+MLMwcTP/4/778xfn3908utr/fP3D+5vzF/Pffv3+Mv7+ysfL/+8Yi+/P9S16+v29Bg6zMXKyGnLofP775y/H+Hxvnsf93WHnl+J/fO/Wc+QXzPTEeoX/s31nvsX6Ue8LNJijw+ePDl4//f/7DzMH3D3Rg0i8ONjam7wx/v/B8Z3wpxPFDyVyfl5Xj74dXTLf/n9jwhEnlX5QE138e0UkBzpuvcjes3sz08qmCmuRnBcmX7z5xMPMLaTGJiAv4/FDY/P/cs0cCDD++s/xh+M30h5Hr/bdvsn+Z3jG9+/jkNofQh/csFswvP377+ZNB9M8rARb+T5zcb24+fvfxO4eMDP/dXz94f3J+kHr07YEIl/DvX88Z+QVYlNlFOEXX/T1s9NHo7Pttf7l5WJ7IqYn83X7vrq44fyAH77Vnf7ZsvhvErS4myvmLA7zw+L/Qr4/vmPh5GAX+PXkioS778dkr0e9fvrJzcDP+//nn71+mfwyMPz+ws7Ax/v/8l42Xl03p/79fTCxsAozs37+8Y+NT/vHtMwvDCy4e8Z/ff4LOVvv9i5X5u5eh+vQr7ySZ3v5m+f71B4cQx3vm/9wsXxhf/X76479UnIMN679PZ29/f3775UfGByyfhN4z8P/9/eobtyrD96t/WZS/8r7i/szEKMj0+9kHXgb+b1w/mP5L8v1+9pmN5f+P/wzMf//+/8r4m/vX/0+MP1mZBHlYvzH8Zn7x/4sQ4/83TG/4/zMyf2N7xf5P9McPBjZGxv9Mv/6/+cPEwsDEwPOTl52V5fN/dnZhTs4H714LS4j++fCBjZvx7eNXPJKKP36/EvnJ9EmW++u9b29YvnH+/sbC+JdLiJXxK8Ovjy9e/eTnfSXzWeIVlyjPzwdvf34U+6PyQviJwhemy2///v0369yHd/IsEo+u3ZP/zfpPWoCJ8f2bL0zvfr//80/QVdrgo8Atrr/czJwMTIw/P/9k4xL6/OmeKhf/2gvfLfjfczLz/Pj2hOMHGyvXq89c7Kw/vv/l4GX5qc/E/pbh6+f3rF9Zf/37zfeR5bsoI+e/Hz8/MzOyM/xh+cvJx/jzGyen+M+Hz/5w/Gf6w8wo8fPfB85vPz6fOfGB/de//3qczJz/BZmYP/98yiMp/vHr2/N/7wnwssoyMt56+/Pupec8Epzsyny/JF7+uMjMzSnMyfrj3lGBv29u/uPk+v/15z/WH9y/uP7z/WD6zPST+Q8Pv5i8tqjoL+YfLF84WX4z/X36+cXvcw+evxDkSnGTUuSXjihz+WrC2l08j+/tb3FFTjYrkR+fnjOLcfJxMZ5gfCXLZf6L9+qHu38/f//J8fP//z9yPzlusnxX+MZyl+uV0flfz3RvC798wsH4981p/neaP0Wevhfk+fVLRJZbkp/zLwsr9zfGP/JvZH7JP//zRoFT4dq/Z4z3RE5Jn9b/p/L94yOBvyayvBzPXt9590ZI4t9XNjbGG8Jy5nocP0TebH9+1/3LJ24ZLmYeAabf39h4+X/8/8Pzi/uXBsfrp7+Eub7/YGD7xfIbMFZm9r9/P7NxCv/8/ZWZ8R8Ph9S/X5///P/z4c9XHkbx/yxfONjEfvx4zs4h8p/p++fvf9g57v1n1Pr1+csn/keqIka21poXL5xi+vmdnfkPww+Zz//vszLL8bJyf2H4vPvQcabf/3nY/jD9Y2T+zv6O+aMQ50s+NoHPzB8Z/nN//fXgLzPzrz88/38y/WL6/v87xz9BLvbPz3+xfOVkVf7x8/O/f79APeXvDP84fv4HHcrCL8nx4/kPhp+/f3398ZeVm52F8RP7978//n9i5eH9//nrf8FPLN/YGRj//RPkFv3K8EJaXPT931+s///+evbj6d8vopw8L9/9YWR/8uo1Nzfn7z8/f/1l+8vMIPKR7bc0DwCc9hGeCNuF9gAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "label" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset_path already present! /Users/giocopp/Desktop/Uni/Hertie School/5th Semester/DL/DL-FinalProject/DL-Tutorial-giorgio-exploration/data\n", + "Train samples: 420\n", + "Val samples: 52\n", + "Test samples: 53\n" + ] + } + ], + "source": [ + "# Download dataset once per session\n", + "\n", + "if \"dataset_path\" not in globals():\n", + " dataset_path = snapshot_download(\n", + " repo_id=\"raphaelattias/overfitteam-geneva-satellite-images\",\n", + " repo_type=\"dataset\",\n", + " )\n", + " print(\"Dataset cached at:\", dataset_path)\n", + "else:\n", + " print(\"Dataset_path already present!\", dataset_path)\n", + "\n", + "\n", + "# Dataset class\n", + "class GenevaRooftopDataset(Dataset):\n", + " def __init__(self, split=\"train\", category=\"all\", transform=None, dataset_path=dataset_path):\n", + " \"\"\"\n", + " Args:\n", + " split (str): 'train', 'val', or 'test'\n", + " category (str): 'all', 'industrial', or 'residencial'\n", + " transform: Optional transform applied to images and labels\n", + " dataset_path (str): Path to the downloaded dataset\n", + "\n", + " \"\"\"\n", + " self.split = split\n", + " self.category = category\n", + " self.transform = transform\n", + "\n", + " self.image_dir = os.path.join(dataset_path, f\"{split}/images/{category}\")\n", + " self.label_dir = os.path.join(dataset_path, f\"{split}/labels/{category}\")\n", + "\n", + " self.images = sorted([f for f in os.listdir(self.image_dir) if f.endswith(\".png\")])\n", + "\n", + " def __len__(self):\n", + " return len(self.images)\n", + "\n", + " def __getitem__(self, idx):\n", + " img_name = self.images[idx]\n", + " label_name = img_name.replace(\".png\", \"_label.png\")\n", + "\n", + " image = Image.open(os.path.join(self.image_dir, img_name)).convert(\"RGB\")\n", + " label = Image.open(os.path.join(self.label_dir, label_name))\n", + "\n", + " if self.transform:\n", + " image = self.transform(image)\n", + " label = self.transform(label)\n", + "\n", + " return image, label\n", + "\n", + "\n", + "# Create datasets\n", + "train_dataset = GenevaRooftopDataset(split=\"train\", category=\"all\")\n", + "val_dataset = GenevaRooftopDataset(split=\"val\", category=\"all\")\n", + "test_dataset = GenevaRooftopDataset(split=\"test\", category=\"all\")\n", + "\n", + "print(f\"Train samples: {len(train_dataset)}\")\n", + "print(f\"Val samples: {len(val_dataset)}\")\n", + "print(f\"Test samples: {len(test_dataset)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Initial Exploration\n", + "\n", + "1. Confirming that the data structure matches the HF description\n", + "2. Visualize images and masks from the three categories\n", + "3. Basic statistics on pixel fraction coverage for the three categories" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Root: /Users/giocopp/Desktop/Uni/Hertie School/5th Semester/DL/DL-FinalProject/DL-Tutorial-giorgio-exploration/data\n", + "train | all -> images: 420, labels: 420\n", + "train | industrial -> images: 199, labels: 199\n", + "train | residencial -> images: 221, labels: 221\n", + "val | all -> images: 52, labels: 52\n", + "val | industrial -> images: 26, labels: 26\n", + "val | residencial -> images: 26, labels: 26\n", + "test | all -> images: 53, labels: 53\n", + "test | industrial -> images: 28, labels: 28\n", + "test | residencial -> images: 25, labels: 25\n" + ] + } + ], + "source": [ + "### Confirming that the data structure matches the HF description\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "dataset_root = Path(dataset_path)\n", + "\n", + "splits = [\"train\", \"val\", \"test\"]\n", + "categories = [\"all\", \"industrial\", \"residencial\"]\n", + "\n", + "print(\"Root:\", dataset_root)\n", + "for split in splits:\n", + " for cat in categories:\n", + " img_dir = dataset_root / split / \"images\" / cat\n", + " label_dir = dataset_root / split / \"labels\" / cat\n", + " n_imgs = len([f for f in img_dir.iterdir() if f.suffix == \".png\"])\n", + " n_labels = len([f for f in label_dir.iterdir() if f.suffix == \".png\"])\n", + " print(f\"{split:5s} | {cat:11s} -> images: {n_imgs:4d}, labels: {n_labels:4d}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Visualize images and masks from the three categories\n", + "\n", + "dataset_root = Path(dataset_path)\n", + "\n", + "\n", + "def show_random_samples(split=\"train\", category=\"all\", n=3):\n", + " img_dir = dataset_root / split / \"images\" / category\n", + " label_dir = dataset_root / split / \"labels\" / category\n", + "\n", + " image_files = sorted([f for f in img_dir.iterdir() if f.suffix == \".png\"])\n", + " if len(image_files) == 0:\n", + " raise ValueError(f\"No images found in {img_dir}\")\n", + "\n", + " chosen = random.sample(image_files, k=min(n, len(image_files)))\n", + "\n", + " plt.figure(figsize=(3 * n, 6))\n", + " for i, img_path in enumerate(chosen):\n", + " base = img_path.stem\n", + " label_path = label_dir / f\"{base}_label.png\"\n", + "\n", + " image = Image.open(img_path).convert(\"RGB\")\n", + " label = Image.open(label_path)\n", + "\n", + " plt.subplot(2, n, i + 1)\n", + " plt.imshow(image)\n", + " plt.axis(\"off\")\n", + " plt.title(f\"{split}/{category}\\n{img_path.name}\", fontsize=6)\n", + "\n", + " plt.subplot(2, n, n + i + 1)\n", + " plt.imshow(label)\n", + " plt.axis(\"off\")\n", + " plt.title(\"Mask\", fontsize=6)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "# Now this works:\n", + "show_random_samples(split=\"train\", category=\"all\", n=3)\n", + "show_random_samples(split=\"train\", category=\"industrial\", n=3)\n", + "show_random_samples(split=\"train\", category=\"residencial\", n=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Rooftop pixel fraction stats for train/all (n=100):\n", + " mean : 0.148\n", + " median : 0.134\n", + " min : 0.007\n", + " max : 0.603\n", + "----------------------------------------\n", + "\n", + "Rooftop pixel fraction stats for train/industrial (n=100):\n", + " mean : 0.204\n", + " median : 0.158\n", + " min : 0.001\n", + " max : 0.972\n", + "----------------------------------------\n", + "\n", + "Rooftop pixel fraction stats for train/residencial (n=100):\n", + " mean : 0.125\n", + " median : 0.122\n", + " min : 0.004\n", + " max : 0.347\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "### Basic statistics on pixel fraction coverage for the three categories\n", + "\n", + "import numpy as np\n", + "\n", + "\n", + "def compute_basic_stats(split=\"train\", category=\"all\", max_images=100):\n", + " img_dir = dataset_root / split / \"images\" / category\n", + " label_dir = dataset_root / split / \"labels\" / category\n", + "\n", + " image_files = sorted([f for f in img_dir.iterdir() if f.suffix == \".png\"])\n", + " if len(image_files) == 0:\n", + " raise ValueError(f\"No images found in {img_dir}\")\n", + "\n", + " image_files = image_files[:max_images]\n", + "\n", + " sizes = []\n", + " rooftop_fracs = []\n", + "\n", + " for img_path in image_files:\n", + " base = img_path.stem\n", + " label_path = label_dir / f\"{base}_label.png\"\n", + "\n", + " image = Image.open(img_path).convert(\"RGB\")\n", + " label = Image.open(label_path)\n", + "\n", + " sizes.append(image.size) # (width, height)\n", + "\n", + " # Convert mask to numpy, assume rooftop pixels are non-zero\n", + " m = np.array(label)\n", + " rooftop_frac = (m > 0).mean()\n", + " rooftop_fracs.append(rooftop_frac)\n", + "\n", + " # still computed, but not printed repeatedly\n", + " widths, heights = zip(*sizes, strict=False)\n", + "\n", + " rooftop_fracs = np.array(rooftop_fracs)\n", + " n_images = len(image_files)\n", + "\n", + " mean_rf = rooftop_fracs.mean()\n", + " median_rf = np.median(rooftop_fracs)\n", + " min_rf = rooftop_fracs.min()\n", + " max_rf = rooftop_fracs.max()\n", + "\n", + " print()\n", + " print(f\"Rooftop pixel fraction stats for {split}/{category} (n={n_images}):\")\n", + " print(f\" mean : {mean_rf:.3f}\")\n", + " print(f\" median : {median_rf:.3f}\")\n", + " print(f\" min : {min_rf:.3f}\")\n", + " print(f\" max : {max_rf:.3f}\")\n", + " print(\"-\" * 40)\n", + "\n", + " return {\n", + " \"sizes\": sizes,\n", + " \"rooftop_fracs\": rooftop_fracs,\n", + " }\n", + "\n", + "\n", + "_ = compute_basic_stats(\"train\", \"all\")\n", + "_ = compute_basic_stats(\"train\", \"industrial\")\n", + "_ = compute_basic_stats(\"train\", \"residencial\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Comment:** Industrial images contain substantially more rooftop area (and some almost entirely rooftop) than residential images, which show lower and less variable rooftop coverage. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Geo-reference Exploration\n", + "\n", + "4. Check grid reference. \n", + "\n", + " Considering a filename: `DOP25_LV03_1301_11_2015_1_15_497500.0_119062.5.png`, we have \n", + " - `DOP25` – product / dataset name (likely β€œdigital orthophoto 25 cm” or similar).\n", + " - `LV03` – Swiss national coordinate system CH1903 / LV03 (old Swiss grid). \n", + " - `1301` – map sheet number: Swisstopo national topographic map 1:25 000, sheet 1301 β€œGenΓ¨ve”. \n", + " - `11` – a sub-grid / tile index inside that sheet (your dataset uses 1301_11, 1301_13, 1301_31, etc. as examples).\n", + " - `2015` – year of the imagery.\n", + " - `1` / `15` – campaign / flight / tiling parameters (ignore).\n", + " - `497500.0` / `119062.5` – LV03 coordinates (eastings / northings in meters) of the tile (centre or corner).\n", + "\n", + " Gird reference `1301_11` reads as: \"which Swisstopo map sheet (1301 = GenΓ¨ve) and which sub-tile (11) the patch comes from\". \n", + " _Rationale_: We could for example train on some grids and test on others to simulate domain shift within Geneva\n", + "\n", + "5. Print images on a map grouped by grid reference. \n", + " Use OMS to plot" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== TRAIN ===\n", + "category | total | 1301_11 | 1301_13 | 1301_31\n", + "-------------------------------------------------------------\n", + "all | 420 | 295 (70.2%) | 76 (18.1%) | 49 (11.7%)\n", + "industrial | 199 | 117 (58.8%) | 62 (31.2%) | 20 (10.1%)\n", + "residencial | 221 | 178 (80.5%) | 14 (6.3%) | 29 (13.1%)\n", + "\n", + "=== VAL ===\n", + "category | total | 1301_11 | 1301_13 | 1301_31\n", + "-------------------------------------------------------------\n", + "all | 52 | 35 (67.3%) | 10 (19.2%) | 7 (13.5%)\n", + "industrial | 26 | 16 (61.5%) | 5 (19.2%) | 5 (19.2%)\n", + "residencial | 26 | 19 (73.1%) | 5 (19.2%) | 2 (7.7%)\n", + "\n", + "=== TEST ===\n", + "category | total | 1301_11 | 1301_13 | 1301_31\n", + "-------------------------------------------------------------\n", + "all | 53 | 34 (64.2%) | 16 (30.2%) | 3 (5.7%)\n", + "industrial | 28 | 18 (64.3%) | 10 (35.7%) | -\n", + "residencial | 25 | 16 (64.0%) | 6 (24.0%) | 3 (12.0%)\n" + ] + } + ], + "source": [ + "### Counting images per grid and category\n", + "\n", + "from pathlib import Path\n", + "from collections import Counter\n", + "\n", + "dataset_path = Path(dataset_path) # make sure it's a Path\n", + "\n", + "\n", + "def parse_grid_from_name(path: Path):\n", + " parts = path.stem.split(\"_\")\n", + " sheet, subgrid = parts[2], parts[3] # 1301, 11\n", + " return f\"{sheet}_{subgrid}\"\n", + "\n", + "\n", + "splits = [\"train\", \"val\", \"test\"]\n", + "categories = [\"all\", \"industrial\", \"residencial\"]\n", + "\n", + "for split in splits:\n", + " # First pass: collect grids for this split to know all columns\n", + " split_cat_files = {}\n", + " split_cat_grids = {}\n", + " all_grids = set()\n", + "\n", + " for cat in categories:\n", + " img_dir = dataset_path / split / \"images\" / cat\n", + " files = sorted(img_dir.glob(\"*.png\"))\n", + " if not files:\n", + " continue\n", + " grids = [parse_grid_from_name(f) for f in files]\n", + " split_cat_files[cat] = files\n", + " split_cat_grids[cat] = grids\n", + " all_grids.update(grids)\n", + "\n", + " if not split_cat_files:\n", + " continue\n", + "\n", + " grid_ids = sorted(all_grids)\n", + "\n", + " # Print header\n", + " print(f\"\\n=== {split.upper()} ===\")\n", + " header = \"category | total | \" + \" | \".join(f\"{gid:>11}\" for gid in grid_ids)\n", + " print(header)\n", + " print(\"-\" * len(header))\n", + "\n", + " # Rows per category\n", + " for cat in categories:\n", + " if cat not in split_cat_files:\n", + " continue\n", + " files = split_cat_files[cat]\n", + " total = len(files)\n", + " counts = Counter(split_cat_grids[cat])\n", + "\n", + " cells = []\n", + " for gid in grid_ids:\n", + " n = counts.get(gid, 0)\n", + " if n == 0:\n", + " cell = \"-\"\n", + " else:\n", + " pct = n / total * 100\n", + " cell = f\"{n} ({pct:.1f}%)\"\n", + " cells.append(f\"{cell:>11}\")\n", + "\n", + " row = f\"{cat:<11} | {total:5d} | \" + \" | \".join(cells)\n", + " print(row)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: pyproj in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (3.7.2)\n", + "Requirement already satisfied: folium in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (0.20.0)\n", + "Requirement already satisfied: certifi in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from pyproj) (2025.11.12)\n", + "Requirement already satisfied: branca>=0.6.0 in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from folium) (0.8.2)\n", + "Requirement already satisfied: jinja2>=2.9 in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from folium) (3.1.6)\n", + "Requirement already satisfied: numpy in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from folium) (2.3.5)\n", + "Requirement already satisfied: requests in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from folium) (2.32.5)\n", + "Requirement already satisfied: xyzservices in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from folium) (2025.11.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from jinja2>=2.9->folium) (3.0.3)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from requests->folium) (3.4.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from requests->folium) (3.11)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages (from requests->folium) (2.5.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "### Mapping image locations by grid\n", + "\n", + "%pip install pyproj folium\n", + "\n", + "from pathlib import Path\n", + "from collections import defaultdict\n", + "from pyproj import Transformer\n", + "\n", + "dataset_path = Path(dataset_path)\n", + "\n", + "# LV03 (CH1903) -> WGS84\n", + "transformer = Transformer.from_crs(\"EPSG:21781\", \"EPSG:4326\", always_xy=True)\n", + "\n", + "\n", + "def parse_from_name(path: Path):\n", + " # Example: DOP25_LV03_1301_11_2015_1_15_497500.0_119062.5.png\n", + " parts = path.stem.split(\"_\")\n", + " sheet = parts[2] # \"1301\"\n", + " subgrid = parts[3] # \"11\"\n", + " year = int(parts[4]) # 2015\n", + " e = float(parts[-2]) # LV03 easting\n", + " n = float(parts[-1]) # LV03 northing\n", + " grid_id = f\"{sheet}_{subgrid}\"\n", + " return grid_id, year, e, n\n", + "\n", + "\n", + "split = \"train\" # change here to \"val\" or \"test\" as needed\n", + "category = \"all\" # change here to \"industrial\" or \"residencial\" as needed\n", + "img_dir = dataset_path / split / \"images\" / category\n", + "\n", + "grid_points = defaultdict(list) # grid_id -> list of (lat, lon)\n", + "\n", + "for f in sorted(img_dir.glob(\"*.png\")):\n", + " grid_id, year, e, n = parse_from_name(f)\n", + " lon, lat = transformer.transform(e, n) # LV03 -> WGS84\n", + " grid_points[grid_id].append((lat, lon))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Visualizing image locations on a map\n", + "\n", + "import folium\n", + "import itertools\n", + "\n", + "# 1) Compute map center\n", + "all_points = [pt for pts in grid_points.values() for pt in pts]\n", + "lats = [p[0] for p in all_points]\n", + "lons = [p[1] for p in all_points]\n", + "\n", + "center_lat = float(np.mean(lats))\n", + "center_lon = float(np.mean(lons))\n", + "\n", + "# 2) Assign one color per grid\n", + "color_cycle = itertools.cycle([\"red\", \"blue\", \"green\"])\n", + "grid_colors = {gid: next(color_cycle) for gid in sorted(grid_points.keys())}\n", + "\n", + "# 3) Create map and add points\n", + "m = folium.Map(location=[center_lat, center_lon], zoom_start=12)\n", + "\n", + "for grid_id, pts in grid_points.items():\n", + " color = grid_colors[grid_id]\n", + " for lat, lon in pts:\n", + " folium.CircleMarker(\n", + " location=(lat, lon),\n", + " radius=2,\n", + " popup=f\"Grid: {grid_id}\",\n", + " color=color,\n", + " opacity=0.8,\n", + " fill=True,\n", + " fill_color=color,\n", + " fill_opacity=0.2,\n", + " ).add_to(m)\n", + "\n", + "# 4) Add legend (simple HTML overlay)\n", + "legend_items = \"\"\n", + "for gid, color in grid_colors.items():\n", + " legend_items += f\"\"\"\n", + "
\n", + " \n", + " {gid}\n", + "
\n", + " \"\"\"\n", + "\n", + "legend_html = f\"\"\"\n", + "
\n", + " Grids
\n", + " {legend_items}\n", + "
\n", + "\"\"\"\n", + "\n", + "m.get_root().html.add_child(folium.Element(legend_html))\n", + "\n", + "m" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.14" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "002c3b704a86437c8966b319145cd7dd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0030257589974d19806602fa8f069b74": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "003362c408b64379bb71616ad7c04899": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_af794ef1d4024cceb47c6ab47b97c401", + "IPY_MODEL_145c8224d12b46d0b65e43ee7254b089", + "IPY_MODEL_00531125985944b0aacf117ea9dcaa89" + ], + "layout": "IPY_MODEL_2be2407b59cb450e8aebf923edf11023" + } + }, + "004c3ad6f09f4642841722a3b861e5bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "00531125985944b0aacf117ea9dcaa89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8d3d960df0eb4b1eb455eae26548c342", + "placeholder": "​", + "style": "IPY_MODEL_88912c85187c47aba7d3ec34cecfbf98", + "value": " 1.57k/1.57k [00:00<00:00, 11.4kB/s]" + } + }, + "005569397ad54617ae5e062961f8c116": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "005de857d9ff405dab7274b6ffc00f30": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0063a8f61e4a4025a9d38d7d9460b072": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "00706d646ba94dfa938ff34425cea35c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "007782fdcc4c446c838fa8771901bbbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0085da39506a489b84622f338a6b47af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5db2af8856d24c369b5ae2b7ff093d71", + "IPY_MODEL_dd73fbfe76504370b6f322147daa0755", + "IPY_MODEL_b40faf9b18b44ad5b4a6e4a2be38cf39" + ], + "layout": "IPY_MODEL_40e77116db5f41eb9d5986ab01662d8d" + } + }, + "008cb9c73b744d22b81fbaabb0f14071": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0095a0022efc4efa92033e5191fc01f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "00bfd137590144d3a2e9bafe30a55eeb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "00d224de54ed423ba3268968af72db6f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "00da453262364c31a59934f3a4881b34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_95df8b1a73ef4e99b5be78a3321e3933", + "placeholder": "​", + "style": "IPY_MODEL_c47096409ac24697b860571df8cbffc0", + "value": " 1.96k/1.96k [00:00<00:00, 9.69kB/s]" + } + }, + "00e1088676374c2386aff9b6da6f96e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "00e59fce5b5047b3b1cc7065590a794f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "00e5eb4d09714403b20db7d0d10f55e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9a24f57e72e54eeabd3c4345e800dbd7", + "IPY_MODEL_ccdc1916eb784768a4d81f6821d5f356", + "IPY_MODEL_0cae1ef6c4fb402a8d2ba6fba3b73f6d" + ], + "layout": "IPY_MODEL_cb7a6b4c465d43f4b26ee95741aed6df" + } + }, + "00ebae6a81c34bda877cf759e378cffb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d3b5967279e8497b9edc9012143c424c", + "IPY_MODEL_540ad1dc2d7a41a0a72381a3634c0594", + "IPY_MODEL_8118225760b24198af5dd8001990f1e9" + ], + "layout": "IPY_MODEL_875658097d5d4205a59538b3e16d5399" + } + }, + "00ef050defa1483bb2522e09e3924ffa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "00f52edb1cdc4b68baaa48e06a4c3fbe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_01b9fb783a1f4c668147f2980af07c78", + "max": 1256, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1ca49bde612e478eaa82e8083d272a04", + "value": 1256 + } + }, + "00f6151d3e634541ac4e84994eebe4ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "00fcf6c0e76b4de2a9a0e1246ebc4aa4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0104c6ba97754a46a99fe06a6e6f88bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "011af9b4345b4b608ab10c97d50f8fe7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01217a770ebe45698a87ec62dc01bed6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0125c239fc174223acec4bb677d868b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3681ca130c1d4c969d94c1874099b944", + "placeholder": "​", + "style": "IPY_MODEL_4e7f0c1a2ff6404492e8cf2d1471400e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "012989338b0d45288ac27e53b7cc6e5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_18078e7cc7b54250be52fa79fae811c9", + "placeholder": "​", + "style": "IPY_MODEL_261436aaa85d4f5ea2c6350b9604e924", + "value": " 147k/147k [00:00<00:00, 269kB/s]" + } + }, + "013fee5e51da44c4b44083c7317efd5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_67a6f2ac9f3b48b68b612e72ab5d14f3", + "IPY_MODEL_993a96ddb18b47d99ca8dfa19a460d1d", + "IPY_MODEL_04a72a8fc8ab49a8838903ba4a916e73" + ], + "layout": "IPY_MODEL_c3da20fa05724f81bbe043b2017b27f2" + } + }, + "014b23a00e6f428491cba865604ff46a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_03fa70f685e9466fb771c8b0f72a90e3", + "placeholder": "​", + "style": "IPY_MODEL_0e7a7f3466064a498a00bfe4089d5034", + "value": " 1.42k/1.42k [00:00<00:00, 8.47kB/s]" + } + }, + "0159ef0c83c8492faed63dfab0178885": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_55b84cb718e14b8797a753264d5f268c", + "max": 2808, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8a07e2616513492f99936bf22f81c858", + "value": 2808 + } + }, + "015f71364eed4c439eff58a2b3c77a5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01833ad6271043878b2a8cf96417b294": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_700b95faeead4437b6ec909de4a0597d", + "placeholder": "​", + "style": "IPY_MODEL_70174b506ecb4c668217eb956d1050ad", + "value": " 3.03k/3.03k [00:00<00:00, 20.3kB/s]" + } + }, + "018a871845564735b153282edf24aae6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0191e9cf66524e679ba41c621e3b23ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc2d2f21f35a48cf9089003b9c3fa7ed", + "placeholder": "​", + "style": "IPY_MODEL_19b2c213f587434da6ed0ad09851f7c0", + "value": " 2.65k/2.65k [00:00<00:00, 11.2kB/s]" + } + }, + "01920f56af194167b7addc4cc5f16ca9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "019464bffe684dc5bf5942c99335f772": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "019c99d8eebe4453a0d5eebe2ed25251": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "01a18f4aa93d40d78fae30056d065ca8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01acd1de46584389bb49647fec272655": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c53d36886fa540799267425cb3be0342", + "IPY_MODEL_ebbd7cb8142b41eab30eb9344f9aa469", + "IPY_MODEL_e3b18e757a4840d3b7d05bf3dad82005" + ], + "layout": "IPY_MODEL_188d5eec440c470ca1b518c94af5ece6" + } + }, + "01b39090431c47728c0895ba7e80a649": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_68ef8a8eeba2484387a74919dfc9adfa", + "max": 2904, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0ab64d77996249689b83237ce2366743", + "value": 2904 + } + }, + "01b9fb783a1f4c668147f2980af07c78": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01d35f7f44cc47f7ab08b2f5de78615a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_81c3d8820f2b444e9b08708903100b01", + "placeholder": "​", + "style": "IPY_MODEL_3a9c0f9e5b2e49d5a3e1c47cff5e0379", + "value": " 6.14k/6.14k [00:00<00:00, 29.4kB/s]" + } + }, + "01d4f0ab0aee40938719db3e678a49a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01da0dab91e24917af98d06a45820b10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01e06310165f45428b5f62bd6c6a8498": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01e0b362822b4173a613a4922de2402e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_da7f060ebb7a4b94ab7863a902c8f51f", + "max": 2578, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cf58057d0a034c4490264ce8e98372ab", + "value": 2578 + } + }, + "01e2844fec8749afa63f69a5ad70f4cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cb699ef843914f58b7250ed8ba718de4", + "IPY_MODEL_e1d0c1807c7943b08ad663617f45fd3f", + "IPY_MODEL_a0c952f15010430391ab974b834065d4" + ], + "layout": "IPY_MODEL_bad5e9000b054c5081bb923fadd9af44" + } + }, + "01f1ef103de14fc68deb958f7f3e21af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "020af0b9760e446eb2cf88026e904b78": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "022e8c080ae44707a8d1c861c563f26d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02439dc915e34d6f9c0fc024d0a8278b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "025c383335b343aface1894db71fdc57": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "026fa19bec9e41c09b3e4b7202fb9598": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02981dbe4d3243d08fb6ca34eb671260": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02c711c28a0b4d379731bb0216da3e2e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "02e4d8b852ae4bb4a00de1a46b258d1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "02e96dd2652a402284a3be5e33ad65dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "02ef1c28e3184b04854ca41c744aabd3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02fcb0d88c904bb39dde59f4f2f6bce8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "02fddc077d224892bc1dd294702fcf2c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "03072f4675024e988eab2342861e3cbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0308a4d940154b7cabce8cf179abece9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0313e3f03b0a42a38edc3f7223f51d8f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "031f9158bbb34ccfa0b17eabf3148f92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_004c3ad6f09f4642841722a3b861e5bd", + "max": 145195, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_df43ab139ad4421bb62c16850c1b3a25", + "value": 145195 + } + }, + "032e070ca6814bcfb98057a3836d3367": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_422f41ff370d4a9ab794b58397ea92c3", + "placeholder": "​", + "style": "IPY_MODEL_189e82bbee224ca18f7d4f60a2bdcf52", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "03404444b2684883ad91197cae0c1e92": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "034789b74d524b518b02b3502f875ce7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "034974452b294b36b90dd6f91b3f24e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "03527945fbaa4eac8024974e837db79c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "035bb9cf6c53401ba859b9aff54e5cae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d994f55c7db846238861463b2201d3e5", + "IPY_MODEL_5c267aa714ea41b9ade28e6cdef257d3", + "IPY_MODEL_fc5fb2d941d14c649e6d8677c8909158" + ], + "layout": "IPY_MODEL_17654f6f239e444baace90d518590988" + } + }, + "0362ee79e32548d6be14f36c3f11274f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0371ac0d584041f6a8c33817983b2ed9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_14e7de05b7424a36a23fc22f6b813576", + "placeholder": "​", + "style": "IPY_MODEL_48a8de1f9f68483fbaa8ab876455726b", + "value": " 1.81k/1.81k [00:00<00:00, 13.9kB/s]" + } + }, + "03809375d4e44f7b929f26bbf5fdf3f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3156fc135ee340189777ae16e5cdb656", + "IPY_MODEL_3adb325de6364ab6b25561a3290bea6b", + "IPY_MODEL_9110669de8b34cf78ed177d32714a8a3" + ], + "layout": "IPY_MODEL_f698a453828b40fd8323626210a44cd4" + } + }, + "0386d706c5eb4c1495def5eca45c3acb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "038e761a75c04b119e571f9aa7d7b1e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_366e436d9aa64e25b04a107bd5125f36", + "placeholder": "​", + "style": "IPY_MODEL_ff2b4b4751e04c768d7c5476a7598c67", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "039855b66a2940768d4f30e8dab53238": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6cbcecdaa743493ab0f62a7dce605013", + "IPY_MODEL_41b23c3a80b24b7187ace9c0d6df4ba4", + "IPY_MODEL_11b4555a788346a18f28ba3a89283aae" + ], + "layout": "IPY_MODEL_cb94a5d2b2ab4830a641e0950c2f0552" + } + }, + "03a9bf516c23456c856e390a3d2f2346": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1f4996d0aeec4683b7dad52642d36ae9", + "placeholder": "​", + "style": "IPY_MODEL_7ffcd9a004df40d782c0833ce049e98b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "03ab3b738ec146db85d8099447383128": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8e26be38227840a0b5cd86a7d13acf2c", + "max": 143805, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_057f4e7d8cd341d59d97f5b89cbbab35", + "value": 143805 + } + }, + "03bd002936fd4d9cb2964f0583dc9eff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "03dad5930e994984a18f0aae3f726e46": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b01e73494fbe4c20898ec9aa777fd853", + "placeholder": "​", + "style": "IPY_MODEL_f39bbddb54594aeb8d62f8f596799676", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "03f2221e8b4041af8215197435c85852": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "03fa70f685e9466fb771c8b0f72a90e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04019b06fefa451c99c1304970ce900e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b32ff28415fd46ce8edfaabd1c87a650", + "placeholder": "​", + "style": "IPY_MODEL_e5e48480452444de8187bd97bec2a617", + "value": " 139k/139k [00:00<00:00, 566kB/s]" + } + }, + "04066639e531426fb56fc876268b7ec3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "040a25cd86284d1a9b4a61574521ebf8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0438f4a3c8ad4adca3ee475960851b1f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04506ff36d39464eb5be438bd2de848a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0454603b7a344ed68addabf5abb625a4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "045a4140f22c42b1bd2c5d5622f410fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04767c4bbf4b4db6ad37034f82128076": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4ed6ec091f6478fb4401c8c52281ddd", + "placeholder": "​", + "style": "IPY_MODEL_4e35bb7e2ce04ea9babae45250ffde82", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "047ecac8092e452f9906c0573861d4bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_944415f3735e412caf969fb9b8611ae9", + "max": 1744, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c93189251c7d4086b3f1a4cdb9f77e9b", + "value": 1744 + } + }, + "048c01d5b8a64e9694c7b892ddeb6204": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "049b194a0d9a4d62b255ca21fd00463d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_74ae97551d2846c7bead04dee684d507", + "placeholder": "​", + "style": "IPY_MODEL_d617ddbd4cde4902ab416968878981e6", + "value": " 1.81k/1.81k [00:00<00:00, 8.79kB/s]" + } + }, + "04a72a8fc8ab49a8838903ba4a916e73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_227300697194499aa06db0dc27cc0db3", + "placeholder": "​", + "style": "IPY_MODEL_e8f8dc14ba0642c3bdfff97218ac76e5", + "value": " 1.61k/1.61k [00:00<00:00, 6.94kB/s]" + } + }, + "04aca085ebe843999b2d90eb181b29c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04bafb219fe64766aaf5f02ad28f72ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6c184c1bcaaf4220999247e66598ef73", + "placeholder": "​", + "style": "IPY_MODEL_fcdc54cb6af6471ab777a25310540a6b", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "04bdbec5fdcb4498bda659cb05fbd24a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04c80c35f52248d3a67c3c598d410eca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "04cc3270885940dfb10e922884eb6f15": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04cfc37d1f8046c886fcaaa76771b046": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a8846ad7450e4d47b066f5edc49105f8", + "placeholder": "​", + "style": "IPY_MODEL_e5eab57d3616448590694bc7fe8a3695", + "value": " 1.78k/1.78k [00:00<00:00, 10.3kB/s]" + } + }, + "04d2d3f07fc445d78677acb438fa1177": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "04fdff7c0d5e49b0a097ce6a4024372d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f70c906f37664c3d88a02e40b6bc0bee", + "max": 2587, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e9b3ac1f93ad42b1aa80afc2b6e6c4b7", + "value": 2587 + } + }, + "050b959d20b245cbbbb71c1056b2756f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0512cef102804865b429053f277ba2de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "051a521b28bc41b39e8fcf3ab6abe8a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "051a96ee0c0f4d8bbdebd0918b7d44c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_61726f982d1246ef961de2221ae85a2f", + "placeholder": "​", + "style": "IPY_MODEL_8ea6c91ccb4e4849a363b05b5e91fe80", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "051ba026ddb64559b9b894268e7eef04": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "051f9dca91d346339d95c4e2502d8bf9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_85ef686511884d3e8c5135c9c9844de2", + "placeholder": "​", + "style": "IPY_MODEL_e9e2a7e4154947799318d08a5f291a2a", + "value": " 1.53k/1.53k [00:00<00:00, 6.96kB/s]" + } + }, + "0523abfa2b5a4d4da419691fad60511a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "05248401683e4177abff5876332b88f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_998491fe8cdd4f39bb205c515343e444", + "placeholder": "​", + "style": "IPY_MODEL_74fae3888be24e9f959e52c7cee24aae", + "value": " 144k/144k [00:00<00:00, 595kB/s]" + } + }, + "0525840a58984dd8a9bf6cd0e37f6dd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d3510d3e1b7a479facebb4e52ae9c544", + "IPY_MODEL_bf4552af87cc48c2b480d013e84d86d1", + "IPY_MODEL_1f23d0f776da4c399c6db8f2e49d1fd2" + ], + "layout": "IPY_MODEL_885e1857f08f469d8a591d6f24fb9920" + } + }, + "05578816a79f40519361ccc76c353cb2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0565994e84cd46ce85735c1639228023": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_552aae41509e4d64bbb4679151ffc0e5", + "placeholder": "​", + "style": "IPY_MODEL_b16ff13822834f5aa21035aac507df48", + "value": " 2.36k/2.36k [00:00<00:00, 9.84kB/s]" + } + }, + "05669233a6ae453ba704ca2975648ded": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_38c0bf9702f2438993608f6f3022b5c5", + "IPY_MODEL_86d29201a4184838af661a25111881a0", + "IPY_MODEL_b68a3780c1bc40dcb5344809bc1c6ef9" + ], + "layout": "IPY_MODEL_4cdca2e9575b4f3583eb78acb1245227" + } + }, + "0567b360036f458e978dc8d913f0a546": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "057f4e7d8cd341d59d97f5b89cbbab35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "05a8aae579e94d60b35928d5285ce5ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "05abdc63f4784bb99b8337ab761478da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bea9b9fa2c9e4f6bb87d6a3edabace91", + "placeholder": "​", + "style": "IPY_MODEL_b3af31b05d6e4c7993dc08198bc6d93d", + "value": " 2.47k/2.47k [00:00<00:00, 8.66kB/s]" + } + }, + "05be6a564f834314ac30e5454dc2690a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "05c10c40a95545178bdb1be0152a1ee8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "05d8142af9b54fef9f25c67abeefc4e2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "05f26ab0b7d94e6dabd18b30de0bc14b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06019b7a7e0c48f3997912aa998164b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "060567c01116429f845d44131e5e0e3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "061051fcc42843f48f3d30a962bcef1e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0627fd9b7490432e99c080cbebf8fc36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_53302c9ac6364cbcb45831053e0b1977", + "placeholder": "​", + "style": "IPY_MODEL_427af3db47264e92bd3e6bca39e52682", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "063148cdfac64123bbd11f1477b71e88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "063734ec216145b282d43a95a72bd28e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06430419cf2446e482d5010c2104df15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "064cad5e98144909ba85663166455af2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "065162b90e07484088f93160db7de67c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_83b3fa41047b45919e7c9b3dafdee7cb", + "IPY_MODEL_692c8b553ded4cdd95deb2b5fad6ffd9", + "IPY_MODEL_d7e7cacf1d9c4b098f3510eccbe34ce3" + ], + "layout": "IPY_MODEL_36c6f85037ac42fba9090f60a8c44c4d" + } + }, + "06738b4db47c4393b276e539c72ae21c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "068044c6658049d6b614b4e9a4bf7e04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_248c7cec7960455fbcfb94e69e88deec", + "max": 141818, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fb5d04eb75c84b0381741c88ad4103e3", + "value": 141818 + } + }, + "0686e7b221a84e889db129879f8bd10e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "069913d99a5e48d8b6d489b0a00b176b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "069e63a0a00a4016a7a4c9be0842e9ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06aca855e58f4047929d5c0264757ca3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_66580bcae2794ad3af71ccfc25e974cf", + "max": 1975, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_51d0821fc73041e58f8e8f5a2baeadc0", + "value": 1975 + } + }, + "06b8b132e39b48ce8aa20465ee070cd5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06e9776fe86b4b138775b57aa7bafb34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_559dbb13fa0c4727aec7c83fc6d54e24", + "max": 904, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_598842208be94e19aaf56e0def77adc3", + "value": 904 + } + }, + "06ed3ad4e9e442888d0a7b87008ffc46": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06f5f34c8fc443efb9a604f58bc573a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0700330a7fc34fdea9a6f70205ec654c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "070bfdc385f24cc59cc7d26422a3dda4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "070eaf624279493582e8e0c67497ac65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_60d77cf847da4c4e8c3dfc7a87e3e065", + "IPY_MODEL_f4dbd6ca71cf4346b2ec6db94169747d", + "IPY_MODEL_731b59a8996940a8a962df4c390e19ff" + ], + "layout": "IPY_MODEL_ce2d235e06e74c799c54ab59ab82d431" + } + }, + "07114fee192b436f94fc1e3f0d492867": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f8b104aed5d54ac18aa8bbd43898623c", + "IPY_MODEL_7b1668190e9a4e75ada8fc16cdd293e0", + "IPY_MODEL_84ab171e5a6d4f0d8f1f5881e6e6da00" + ], + "layout": "IPY_MODEL_2b138545a2eb4dfb915eef2c3b8130d4" + } + }, + "071156adb02b46268990bac4fadddb12": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "071c02b91f5442a0b88bdf1bd120d463": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cb51bbb510b7481e9d073979c8d88687", + "IPY_MODEL_3154bd527b164b8cb905f05394ee8655", + "IPY_MODEL_b3de576813b14de38f89db60e0c49cf1" + ], + "layout": "IPY_MODEL_3fc3166876f6451e9633fead2dd86f7b" + } + }, + "071d42de9043414ebfc3d7de9a5ac10c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "071d807d3a6e4527aeadb2e5d6811d0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f0891d3038814cd080c0216d81aad744", + "placeholder": "​", + "style": "IPY_MODEL_930032b5a81848cdb1a77b5bbd1a2186", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "071fdecd03cd40aaa13bc852216d1c63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "072e39c07eb64cbfa28f4ddd1995295f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0731b012f54242d6bc4aefbda0362e07": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0733bffe9df84cd2874ed56b5e95f00c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "074066ff916f493fb3aa744f10e87e0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a314a5ea984548d38b70e46ef4180430", + "max": 146781, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c1af3ffba23d45d49c4b1d9563438c33", + "value": 146781 + } + }, + "0743eccd4aae4c96a521e49a8ab9f1d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0758cdb097d54ca9a7974319a17a45ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_77b1480126cf4316a2f0319887ace0bb", + "IPY_MODEL_9ad1849928ae4f509957aeea0bcadcf5", + "IPY_MODEL_c3acc06aa55f4df3a770ecc55a306815" + ], + "layout": "IPY_MODEL_90e0bcdddf1a4e8fb6e23322df53c63f" + } + }, + "075bf93e35a14601be6ed1e99e61ed01": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0761c6749bf7420e8bbfb28a91264718": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07638bbb4a2b424ea8825dfbba3bfb21": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07873c74c46e4b74bd437c3bec1b5c94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee2acf4f69ba432687bf41aaea63926e", + "placeholder": "​", + "style": "IPY_MODEL_589d8542735d4b0694d02b38179e6aa1", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "0788a05015ec48e187263344f4c08ebd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07a3b2c7fb364350824c32fe5cb7147c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "07a85d77fc114188905d5fa8576ddcf5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07aba533e4024609870239294b62fe37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07acfa2b2e7f4666a0615272cae66dc5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07b49c5bfd0f4653bba8e0fedc791cba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a0e0b2a442ae454da39aadf9d84521cb", + "placeholder": "​", + "style": "IPY_MODEL_58dbf78446a4443ba1e6d0258d7d3748", + "value": " 749/749 [00:00<00:00, 3.25kB/s]" + } + }, + "07c4222ead264808aa9901e4c2718034": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c5fd885067e749d6aaf115899c68c793", + "placeholder": "​", + "style": "IPY_MODEL_3a1b00f468454982a5f029fe5934c264", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "07c669bb60a4409bbbce17cb7bcfbb8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "07ca10cf5a0b42ca88dc0d3ce46d55ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_85f2eb3466464f6db0ee8ca386a004dc", + "placeholder": "​", + "style": "IPY_MODEL_f04a49cc023b493181d3ee229709c060", + "value": " 141k/141k [00:00<00:00, 709kB/s]" + } + }, + "07ca791331914ca8a1e46afc02e6b679": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "07d71796e7084f71b733eb02e139014e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "07dea9075f054ff0afb4958aebe97d1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_12b4eb02c8774559b0383fb4d936a7c7", + "placeholder": "​", + "style": "IPY_MODEL_fe220fd83d7e4a9a915ed231225c49cd", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "07f6d54be05f4ce7b59db870d4b15199": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1e44bc70dffc40118fbcf51dcf7ba48a", + "placeholder": "​", + "style": "IPY_MODEL_bcd64c896f704b6db7ae5ce81f213223", + "value": " 2.17k/2.17k [00:00<00:00, 5.56kB/s]" + } + }, + "0815ab3de99c46a4af454f5b286a034c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0815f6b022ab4375aed98f6de7d2d767": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0825289871574ff7bd8271862bfde792": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_299dd21c667e4f7d84ca72906be667b1", + "max": 3842, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_44bfc32f842d492c906962924a18c50d", + "value": 3842 + } + }, + "082ba06713e748b8992c318d9af5ccc1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "083d21d8f8ab49d19de9b712263f23f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "084447f8d356434db4b0cbd0099e44f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0844ac7db5e94477b86f5ff0646e0aba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_22c8c8e0c6504ecaba18c813e860e2be", + "IPY_MODEL_daf01ac9d2e74a42b74ab8b4fa0a9a6d", + "IPY_MODEL_9bbb957167e2487985265160e2892ad5" + ], + "layout": "IPY_MODEL_12503587cab146b2a5d375a193a78d38" + } + }, + "085b775cf8964d27903e840694921b94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_084447f8d356434db4b0cbd0099e44f0", + "max": 2865, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_71a41e11038f414aa8e796a1a505a23a", + "value": 2865 + } + }, + "08630dfc9a3b4310962f41532aed871b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eeebb647760a450890df086a26ccf123", + "placeholder": "​", + "style": "IPY_MODEL_d442acd44f6d4fe695b5144915f6e41a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "087cdd1ae39f49b88d452fe2968e2f55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "089d7dcfd3df4e83897aa270236ae5a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08a23d09e6364e99a5b34f08cff9943c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08c1353aad6642549dedeaf9a4710bb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "08c4e01b75b24144b2e4eba0b2fac312": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "08c5b3a97e3a4e0ab16c68f24115b34d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3d7bca6bf5bd4bd38adb286b19d69cf0", + "IPY_MODEL_3e987e0a2cdf4426a9e15a1aae7126c6", + "IPY_MODEL_8a210801cbbf4c8db63916bb8729ee4f" + ], + "layout": "IPY_MODEL_8e1ff6a1061c45f387b2fa2bbe86b33e" + } + }, + "08d2d59b560c4e13a3665edeaa65ce8b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_34ac847199894936a75d67574df36ce8", + "placeholder": "​", + "style": "IPY_MODEL_498062ca219047c99de45455491e3bd9", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "08d4a2629caa425283be9c82d2613968": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08f0038d37d540808fbbd380f5aec88c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "08f018dc9e784e9f908b0c585767fd7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2a7eb8d4e95b48528646ab74dd448358", + "placeholder": "​", + "style": "IPY_MODEL_4cf02249f69942a584927d7b727097e5", + "value": " 2.86k/2.86k [00:00<00:00, 24.0kB/s]" + } + }, + "090d0f378cf143918de315adfc78c75c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "09128431238847cfb787706440b1240b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fefd503d970f484f89fff225fba28a8d", + "IPY_MODEL_67e527bb2d1b40c8bac71a426821fa9f", + "IPY_MODEL_add657d66b7c47ebb31d69c057a8401f" + ], + "layout": "IPY_MODEL_8f8d4b29a32044c89ea2757b1f6875e5" + } + }, + "0918d3b788bb422b8579f947c672dc7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "092cc02b3d4949f0a77a1f25d39a2369": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f44f37e0e4e42668cb2f2cf007d3808", + "placeholder": "​", + "style": "IPY_MODEL_a776dc42836a4f6894f89236d1dc8889", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "093075d9c4274308a92aee467d401b60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d7b03d0ff6734a8d8d8d425337c3d491", + "placeholder": "​", + "style": "IPY_MODEL_e2fea24941314289bdc3c66a188ca0e2", + "value": " 3.47k/3.47k [00:00<00:00, 8.18kB/s]" + } + }, + "0935bd51ad0a4a0bbfe7a61a56d32593": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "093fb0a30b084a49aebaaa8137f01b3d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0941faf66f5d4fa9975aa63d7ad926ea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "094aa79ed1674519b37d3d734040d332": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "094dfc60cf4a4985b7392a05e06bb345": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0951c52fb9bc482d9f32278438f9a809": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0975ea12ebf045ea9c83ab415385cd96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a444895d47384745a8849213a2b86340", + "placeholder": "​", + "style": "IPY_MODEL_e4427d91578342caa56c05aeaa0c03e1", + "value": " 1.33k/1.33k [00:00<00:00, 10.9kB/s]" + } + }, + "097b1cc7856645fcb3aea38ab440004a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "097f8e2bd8504bafbae7971e2c865b0d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0982afcebb63405386070a1801ad17f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_458ed26f9941417cad270fd10b0c0f27", + "IPY_MODEL_085b775cf8964d27903e840694921b94", + "IPY_MODEL_848a553dd3a84ab7934d7dece6ea405a" + ], + "layout": "IPY_MODEL_de46250f8aa84fc090ae3f37e32193d9" + } + }, + "0986ff4a73db4ee0b560a0596795b3f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7375ba19c24e4182883b1a2b50b839c3", + "placeholder": "​", + "style": "IPY_MODEL_a10d3852d2e24cb0b6e49e3778c778fe", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "098b2ca5306841e5b50396bbaf1ab89b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "098d4797b91f4cee9571f9fc4776fe43": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "09aa2168bd4c43828c16b2f0c5f4e20e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "09ab463826e8483a9bcc948551874cab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "09ae3b05cd50409bb371dc6dc04a40e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "09b298f530db476cbda39f7bad22e9b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "09baaba2eb8548bf8ad3f805164f0ee4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "09cc4db6708049a98134cdd3b4852114": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "09fefffa623b4198b98471932f175f06": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0a00d897c63b4e00b5f174c0e575e93c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0a0114ca8d52405284a8a89806466a4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0a0651ad413f44e4b029daa2442888ef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a0680602f5a403892c81b4ca60f4d9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5b166bfc400741a48a7ba9150d4e2ee8", + "placeholder": "​", + "style": "IPY_MODEL_4b68dd16cdab4d4ca0e4404cddf9324a", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "0a088438234448c8ba2430d8a9d1b2f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0a0e10f223bd48feb85fad4c833d6393": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a1dc02ec280423d938be5a2e409a2d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a26f814a17d47cb80d2d85d3e821879": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0a2805e5e95f44fdb4cbd60e5aecb4d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7e7716a4fa76472687038614cc2ceda4", + "placeholder": "​", + "style": "IPY_MODEL_9e49a3b6d992492c838ec42e5ea1628b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "0a29de0ab5de4c1fa8cca8a7ce6f857a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_239305e8ed50466b9396b7e7a6933799", + "placeholder": "​", + "style": "IPY_MODEL_c32129459ddf4a97951d6a96abcaf1b6", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "0a2d894bd10d429bb045be2b420e7b1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0a2d8cda00f244c5ba581047bafc3b1a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a2e203d639c49d7a7d30970f16601e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a3c589d48ec44e7b039c9d128cb5f2e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f1cde6976884c54ace9b2efe4e4417e", + "placeholder": "​", + "style": "IPY_MODEL_e97517d697a94bf8a09bdb05f5f5dda4", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "0a4148da43b14f52bd8d6c443ce5cc57": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a4e81744b0e456a8b081f8544091628": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0a4f51ed635845a9898bf10ce22dfeec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a51bcd8039f429b9003cd2804ed76ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a758b0c792d4abbaaa190f673cedc83": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0a76f93ef5fe46fc91004fcfc3a8ac9a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a7c93299ba34ceb9f41ec1612239460": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_14cf42fbff3c4123ad97e3982f16a845", + "max": 2935, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ebd3a064cbd744f19279e5432b882f14", + "value": 2935 + } + }, + "0aa85b4bcb3a497a81088e3d9e6228e5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0aadf6a6fdd746f0b3e0946f5ab17a5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_445e2f3aa760445891dc4132f609e157", + "IPY_MODEL_87be05c24a0a407baec681b4b06d52fa", + "IPY_MODEL_3394fd0798f44cca8b62515ced46abc5" + ], + "layout": "IPY_MODEL_aff81aa125fd40a687b62b3552df3bf5" + } + }, + "0aaf118326a644979ff7e6e8545132ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0ab2247c1fa44c75b4a236fe836a020f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0ab64d77996249689b83237ce2366743": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0ab86e7c5f27461ab6065478470c89f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0acee9b60d61423c83e1d067fc744fbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_061051fcc42843f48f3d30a962bcef1e", + "placeholder": "​", + "style": "IPY_MODEL_2131d2511b8043509da1fbf3a9556872", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "0ade16dbe20d4dcdaff69c7fd0acd5db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0ae24dc31ad349a684eacebd26f3fce9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_68a4c0234a7442359f589569f3c8c822", + "max": 3256, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b872846380484bf5adcba65d064be216", + "value": 3256 + } + }, + "0ae3a5c5bbf34b01bee72a287282e03b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0ae625615547449d93713980ea0d26e0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0ae6aa3db65c4901aa4962bfd724f12c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0ae82f6b26124a33a6e7f9b697e85825": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b1bdfac84564609821f9a30d87294ca": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b28dab9e4524929b1e0c5ecb2c761e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0b28f9b3410b46f2b7bed76ab92cb380": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b361d1126d24bb68dc9bdccd3789ff0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b3ec0d4e403446c88c4557f5fb59c45": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b3fb4a52d3f4d59a341bf9664c8b46b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_026fa19bec9e41c09b3e4b7202fb9598", + "max": 1647, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d56c8ec4fd58428fa7d0640dd5574dcc", + "value": 1647 + } + }, + "0b41cf7365494aec9691f3b28287c111": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_09ae3b05cd50409bb371dc6dc04a40e4", + "max": 2739, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7f80dd8cf30a4f1eb5f668085a390a2e", + "value": 2739 + } + }, + "0b4c065929384c33be9a8a3bd7f03019": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cabf215ae0474c86b210fc9ab717f296", + "max": 1353, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bcbd82c60b544100a19c14d41255a8c6", + "value": 1353 + } + }, + "0b4fd1a2eee54afdaa62ef4495d02137": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ffc5f1d015bb409abd270e4c2d3cfe77", + "placeholder": "​", + "style": "IPY_MODEL_0ade16dbe20d4dcdaff69c7fd0acd5db", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "0b560b2f81a04ee9b6d204d0a2524e4b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b57285b70364fd19c5bc75cc375134c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b5c6bbb95bd4296a41ce00bd4a8bfae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b67abd3eb6e430582ceceabdd86dabb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3c6229040f1d483d9fec28de0e1f9337", + "placeholder": "​", + "style": "IPY_MODEL_1472403254ec4065a0a8a4c765c3985c", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "0b6827a598444dacb37392623c9c6ef4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5194ad1797de40829f567754fcded046", + "placeholder": "​", + "style": "IPY_MODEL_7d4110a9d025478080705fbe531d000c", + "value": " 3.95k/3.95k [00:00<00:00, 23.4kB/s]" + } + }, + "0b69449a57794dff84989a346a4b2dcc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b72512a4e9c4266902c1b480e051e94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ab73d9a322824f27804616e239a44a11", + "max": 1880, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6854185cf0254ca5ba110e748b6d5352", + "value": 1880 + } + }, + "0b765fcabd734c32bd143725a2dfaccb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b375e07ef95441f48d0f468b0a52cfd2", + "max": 1412, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6f3b9bbdab4c43aa85593b3b6c33435c", + "value": 1412 + } + }, + "0b7833da81264265b0e6ebde6966bb9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0b7b6954eb444e4e873b7557868b7cf3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1e3bc4007a0f4f7fa18082efac627ad1", + "IPY_MODEL_c96066bfcbe043f4aa6eea66c6fff226", + "IPY_MODEL_372dbf911eb94d1ca3d52eb8a385a618" + ], + "layout": "IPY_MODEL_eeb0a452e95b42ae82086e37df8135d3" + } + }, + "0b8152697c8944d28f92e85015834c89": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b82ee4e0bc84f60afee0e9780b3e8fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0bbccdcfa1564d4c9171d5a66ce78cf0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_28803969096c458bb330b971708a9681", + "IPY_MODEL_0f426fa2535541ba9748d99e38df2c76", + "IPY_MODEL_de977a60a54c457f9c0571746835654f" + ], + "layout": "IPY_MODEL_2afadcf768fd482b938ee69009aee2e6" + } + }, + "0bd10570e877416c928ef0b410339709": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0bd45c0dd70d4332bc6e7645f63579df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_228cc3e96022456693b94cdd57106f67", + "max": 2070, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_57e6ed5deadf46c88babc6923f132ed2", + "value": 2070 + } + }, + "0be218cc22f24797a903f6513f3515fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0be7e5412b9e4db38d42374ddb4242f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0bf18abaec334454908115bfb2e74598": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_210428211d3c445db2b1ac0c66099080", + "IPY_MODEL_0e98e8cb024b46fd8795a800fb6b1ccb", + "IPY_MODEL_4aec46ffadd64cdda130c62554995386" + ], + "layout": "IPY_MODEL_15802ded0a0a46deb2ce7a18da1c71d5" + } + }, + "0c062c9209b3493481d875593e313aab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c15df6db08a49cfbb3dc59768f29a1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a90fbf9b912746f5a5b355ca1b1e3df7", + "placeholder": "​", + "style": "IPY_MODEL_d09389a2ecf041d3818238008e80215c", + "value": " 919/919 [00:00<00:00, 3.41kB/s]" + } + }, + "0c2134cbd50a4077bc5d8336d8dc679e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0c3a8637560d463eb45c4e510b2052aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0c400069812d48b38dc2a46a96bc8912": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c4a2c3408b84fce9b91c46d2dd7cb55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_54c86ecc473e4a6fb78909c75484c839", + "placeholder": "​", + "style": "IPY_MODEL_189557900c884cc59e6f70ef4e130c5c", + "value": " 6.15k/6.15k [00:00<00:00, 91.2kB/s]" + } + }, + "0c4b11d322354a4f89c2115b42097369": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ca7166c73ced440faf99617cf0e288d7", + "IPY_MODEL_a4b55b325ee24c75aea7384f9df449a6", + "IPY_MODEL_ebe1c9cb8a844ffc94ec25127479d342" + ], + "layout": "IPY_MODEL_e4bbfa84904b4dccb152adfaf04abb6a" + } + }, + "0c6a6ee568b4471ea1ce0e78aa92524d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6cb8e4d58c844b7d85e69e4fcf3d1946", + "max": 149757, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c7da89e613fb4b08a96238ac7aa0574a", + "value": 149757 + } + }, + "0c7e75e018784c2d9c5da1e6ee12397c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c872c1b095a43ba9cf18798081c5e73": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c893dcbdb1f4c4191674d5d44cb3fa4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d1334f08bbfb4d9da2dcc4a1188c8107", + "IPY_MODEL_d18243d711ea476d96d6dd3a0cf4bf5d", + "IPY_MODEL_b8e6afffc605482eb8af694e4b371be0" + ], + "layout": "IPY_MODEL_d37c1e8b356e498288ea1638232abd34" + } + }, + "0c9f93b2f4c648a6991c13a57bc4039e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_561f284d964d43c3aa7e388ddb1cce7d", + "IPY_MODEL_aaafa314fb264461bc58badc3036ff96", + "IPY_MODEL_6b671e4e4cf9409b96c7562c8f03640b" + ], + "layout": "IPY_MODEL_9053690348744db2bf88247f691c98b4" + } + }, + "0ca56b824786473aa532868c7719ec43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ccc45185b7344187b888110d97de25a7", + "placeholder": "​", + "style": "IPY_MODEL_fd27abddf5b5474d9d42e344bdc3662d", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "0cae1ef6c4fb402a8d2ba6fba3b73f6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_970f443709e44aa28a1d5a77fdf1b899", + "placeholder": "​", + "style": "IPY_MODEL_8acd64de9f7347eb8baa795235657a13", + "value": " 2.72k/2.72k [00:00<00:00, 16.2kB/s]" + } + }, + "0cafc9fcf7f0421fbe68ac75c7aacc25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_acd62fa8fcfe4b31a004e7ca0b017010", + "placeholder": "​", + "style": "IPY_MODEL_beb18ab72b1f4fdf88a3c0f15372a095", + "value": " 2.64k/2.64k [00:00<00:00, 22.6kB/s]" + } + }, + "0cbe98782cf54922a9425511ba0f7731": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0ccfb9cd8bb54d18b443e630faaee20b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_40d0a3430d0440139379dd15774dca3a", + "placeholder": "​", + "style": "IPY_MODEL_ada008125a0145019360af60b92487bb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "0cdbd6eda4034b06811392400932e792": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c43cca7c76384876a5e4255135bc7309", + "IPY_MODEL_1ff6502727b143849e7a0c1a416c9b13", + "IPY_MODEL_547a6a12e14e49438962cb744497ecb1" + ], + "layout": "IPY_MODEL_072e39c07eb64cbfa28f4ddd1995295f" + } + }, + "0cdbef85e23548f6a14dcae3383fac5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7deac3978f9741efbf36f85fbdf4e826", + "placeholder": "​", + "style": "IPY_MODEL_3fcd8066b683446f8b21c3832f555263", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "0ce6fd1c1f25467b984c088051d3d931": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d31136a544f4388988a76018dd3e9d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_025c383335b343aface1894db71fdc57", + "max": 2874, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e366d9f7283042cd96ca1a3b6ff84ecd", + "value": 2874 + } + }, + "0d318e10d5494e019f0fd4f8a999a6c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0d31b5066db74913a1fae6418c7870ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d433f0edf6749d6b429bfe0159c102b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0d6357c0f4f44adf93325a0d33a1529f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d6931cb5d2243868481fde8b693ecf3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d6cdec2141847af9474c851722bb25e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d703ef4aa7e494caa8bc42640c2d2e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0b67abd3eb6e430582ceceabdd86dabb", + "IPY_MODEL_61c64f03c26f48d3b1ca396894a50ece", + "IPY_MODEL_49d472638569444db78910487fddfded" + ], + "layout": "IPY_MODEL_4451266e134749aeb3752ce2246b8150" + } + }, + "0d858a82056242ac88066e51f61412cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3cc63c3c0eb1436186160006bf636bd9", + "IPY_MODEL_13b082d9aea44e0c990c897adcc5aaf9", + "IPY_MODEL_76a1964c0bdf477b87110c978e359b86" + ], + "layout": "IPY_MODEL_2fb9038e268f41c8ba35f105dca72309" + } + }, + "0d9be92e4a9c4524a6b74c50f062682d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0db3f74843da49fe87da0ad618c53a73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0db5982ec4d44eada3de6fdf05095910": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0dc0094cdad8426baff11ff5c6868d80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0dc293aebcd94b9b8c139d423f8434ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d77b230b79784fe7b3b858ce417d6c43", + "placeholder": "​", + "style": "IPY_MODEL_5cb8b15352064f5087c8154db96f6fc5", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "0dcd26a514844fa78a47552600bcfa6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0dd49b92d5bd4d82abcf3b5a573c1647": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0ddd7a197be540ca9deee0e78c5280e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_30e4d22a693b40d1a8b8262fd31b2718", + "max": 2269, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f63dd9f0693b4c3890cc8af1d7cbe611", + "value": 2269 + } + }, + "0dec35999a1e48cb8428cd89171a32b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0e04a1ea78c246a292251b87ba8d11f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0e05d7461b5349619232f69025f58a3e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0e10b704d4e24c69afa22206d2269cb1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0e1a574cc50945578197bb9a7b9f6bb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bf1da7da12a84906a211045165dcf641", + "placeholder": "​", + "style": "IPY_MODEL_af833213000441949d3c3e99ec6982d6", + "value": " 1.77k/1.77k [00:00<00:00, 8.92kB/s]" + } + }, + "0e205daeabf4421283d231b5e8e7314c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4db82deb62e457a8d225049e5ddb48e", + "placeholder": "​", + "style": "IPY_MODEL_b8737489d8bf41779ec2c10d17476192", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "0e2653aebae1428492ab4661dd9a5d11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c7e2d8f0ece94a9b93a85029d8689f51", + "placeholder": "​", + "style": "IPY_MODEL_2ec4fa3ec68242d69e69a07ffb6f527e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "0e333c09461147429a9610175d0e8f77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0e39742b92974e33bba83bb16a45eb13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_774efbfcdc6147b78e2b23fbdcf34e6d", + "max": 2412, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b8970f220949466cbda6ba58f3ce9a4e", + "value": 2412 + } + }, + "0e42111fad5f4fb88e0dc07d0524c913": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0e5716410bff4292bbf21905d99b2b2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0e5bcf035b224643b237ba34f243e065": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0e7a7f3466064a498a00bfe4089d5034": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0e95c3761b8840668724be7bde6c09d7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0e96c529407f47f0ad1bea298aa17134": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0e97bec3fbb949a78e5fd14a4a2b2f3e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0e98e8cb024b46fd8795a800fb6b1ccb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2988dcc1d98e4ebeb367ca142ba064ad", + "max": 2479, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a131026f28854ddca8951192787cd616", + "value": 2479 + } + }, + "0ea4cb35f9174a9ab6bdaed9e7a01367": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0ea681e43d314298bf4a5fa120c98f85": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0eae6c5d58e54a27a328c725098c65f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0eb4ccfef406472c9898fcc1979aa57a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0eb70c65fef8419db2400ad08715b935": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b9c4dc4a33554a3cad92316dd2864fb7", + "IPY_MODEL_35c6ab0410c645c28736de1d29fc16a6", + "IPY_MODEL_34920cf0c26e4b78a71545ae3f7cc340" + ], + "layout": "IPY_MODEL_c61c7f0f97854497a3cdc76f673b0abc" + } + }, + "0eb7304b3f7a4e9ead2fcb1cb183c600": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_84a8e3bb3afb417da2266a5acf21a07d", + "placeholder": "​", + "style": "IPY_MODEL_61ea10528fff4f95ac45aad9c8ef2ab3", + "value": " 2.66k/2.66k [00:00<00:00, 12.9kB/s]" + } + }, + "0eb79f52b1814046b567f54e454cc012": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0ec1363205944daaade0169825e91867": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0ed3ae60cc954708bf88bd76d397cee9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_293506a06a244a86be39a22bff78ff07", + "IPY_MODEL_3253d01a37d646ce813a9fb3e8775100", + "IPY_MODEL_463c794b03064b32922fea1059001aba" + ], + "layout": "IPY_MODEL_c22d593ce97b4728b4fce67f2001c843" + } + }, + "0edea77ff5534d8e9bfcac42849de83a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0ee81b8fa98a42a9911811f5963f0b2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a33024c999394aaeaa9606297e74fbdb", + "placeholder": "​", + "style": "IPY_MODEL_4815b4dbfa124ffc82df4812dd651af2", + "value": " 1.44k/1.44k [00:00<00:00, 5.30kB/s]" + } + }, + "0f01a3d5deb9433dbd2b5e9c6d64ab10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f0310b0cc084950a043d8d9a8cc7a99": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0f03d5df239a4ad780f7b9b8a3118022": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f0971148317474d93754e266132e330": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_58eaa8b87c0c4847b2146129e3afeeab", + "placeholder": "​", + "style": "IPY_MODEL_719196d77688488eacac1beda20f3599", + "value": " 2.49k/2.49k [00:00<00:00, 10.2kB/s]" + } + }, + "0f1cde6976884c54ace9b2efe4e4417e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f1d7c1436bb40868973cc524d52e86f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0f281b8ffb0d4dac9ffbfa69dc1c2f92": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f3b8678e9fd41aa8c981936cd629aa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ce432f32652c404395d10836b9f912be", + "max": 1966, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b14026892058453092e6eb49a8a3df3f", + "value": 1966 + } + }, + "0f3c5dda7dc045cdb89cbc6cfc6a5da0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0f426fa2535541ba9748d99e38df2c76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_df67fe085e81460e9e2100737fe88cdd", + "max": 1972, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_84fe0444fef7453aa487d1d8f0904a6f", + "value": 1972 + } + }, + "0f484ff05e67430ea2599095c7c69d33": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f48c2a29cad34418aa460a7633d013d3", + "placeholder": "​", + "style": "IPY_MODEL_b2411e11c17f496c8deb29fb6f1b9c0a", + "value": " 1.67k/1.67k [00:00<00:00, 10.5kB/s]" + } + }, + "0f49c1123a1247e5838b0b36650cfda3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0f4e8f3409ff4575b4c43efb19cfba49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0f510408c02d4fe0bff8021f784e5d4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0e205daeabf4421283d231b5e8e7314c", + "IPY_MODEL_d444597519ee48f4adc99e2328c76217", + "IPY_MODEL_e45d579a66ac45e3a2aa148505547d67" + ], + "layout": "IPY_MODEL_ca245600186e4f7baced971a91a17503" + } + }, + "0f59c6d92cc540d3b0ab49fe06d8621d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_119f6a60986a47ba9f86f623f22ef4bf", + "max": 1949, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6e58fe07cba347c0812794de7b878763", + "value": 1949 + } + }, + "0f5c5243a1b641d5a28f342d1baefb0a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f5d7ee51df8416a9e94eacb5a4da942": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0f5f10031fd54f1c8ce448bcc2fe4eb4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f653fcd0581498b928579986ce149cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f73cbb8687747b0bd12ad3402b3b2f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fbba43b5593e489999e08f5231122a8c", + "placeholder": "​", + "style": "IPY_MODEL_dc3cee8db6854af38e650ae8c38eea5f", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "0f86006b72f3443b9ba7b9a3d18fc74a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0f8a73eee95d4d209b9dea011727b9ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0f9e8972ae124a11837ef540cc6de22b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dd33d6238c2e4ee2bebfe51aba511025", + "max": 143236, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_aa415c2663114618852bac94947dfce3", + "value": 143236 + } + }, + "0fa532abf4c6418aa422001bee99fbc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0fbe58ee92dd44dbbdc534a453768424": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8db7f1ac326c4123b2f4255c78f73c4a", + "max": 1772, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_acc624f8d2204bbda0fb948f3853a7f9", + "value": 1772 + } + }, + "0fc5af4772ea481d9f153e5d9eae0b10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_21916b2d71384c46b423c9bb6cf34bec", + "placeholder": "​", + "style": "IPY_MODEL_f8cb9c39d1fd4de189d90ad505b954f5", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "0fdd8411c5274f16919cd307d3a653f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a09b706f3e934d8a92a5be02dd23fd34", + "max": 2119, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3bb0934a776f41b3b32ea8170213e051", + "value": 2119 + } + }, + "0fe5b14c29624c7e96084a1f2f2ee72e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0ff66b03ec674e8388fb6a204ebacb82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "101dbafaab884bcbb83129e49a53c160": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "101f5e1bc7fc4018a36cf1e108fb5bdb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_23ba1666ae38442cb11fd8022bd1b48a", + "max": 992, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d6199c19fadb446bba3d7ede3aa916b7", + "value": 992 + } + }, + "10207ff778bb4b8d9ab448538709f927": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1021545f24ee4fa4af45d0fa7842a180": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1036a13bdac94bdbb81e9374587edc4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_704d230e2af34a03b1c7aee793eb997b", + "max": 2215, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5656ef8608c74fea88b10cdb6fd314b8", + "value": 2215 + } + }, + "1056a54931dc40a1b8eab8b2c6af5ec7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "105c2bfb3f314ddcb5b4e5cb6a4b0a7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "10743d2fb01246c5ae963e829eb63880": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5fdf892b21ae402d864a8adda7972043", + "placeholder": "​", + "style": "IPY_MODEL_dc928f6a9ddf4dbb9255eda2b18144e6", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "10909b1acbf0474ca073fb1e8a2b49c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "109512ebc3ad4c9dbb724ef645ecd77a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "109ee823b2bd4d1ab8c112b1f2e3d473": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "10aef2e50ea14b6cad0c93ef3df29de2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "10b2746ab7f3400399ebd520e9aba90e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "10b53a03e27a43faa87a3179a7a87689": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cff76d4a2fa64f0bae9c0e04ea38a3b4", + "placeholder": "​", + "style": "IPY_MODEL_3e77dbdd86a24679b4a65d9c8fd63991", + "value": " 1.21k/1.21k [00:00<00:00, 6.11kB/s]" + } + }, + "10b7bb96090f4a8897deef932cc093ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bd1c9137a75642f0aa01b71916b27fd5", + "placeholder": "​", + "style": "IPY_MODEL_0386d706c5eb4c1495def5eca45c3acb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "10c5c73c40004cd7a58c333bbc766664": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e97c56b91f6149bdb05e62e84339ce5a", + "placeholder": "​", + "style": "IPY_MODEL_4b1cfb3bb70f42a8996cce192644dc38", + "value": " 2.39k/2.39k [00:00<00:00, 14.7kB/s]" + } + }, + "10d1fd7a7a4b4d1795d010d8f634dbb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "10ebb9cf3be643fdbe714a64e6537f49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4d1be009ab2e4b18bf17a9642ee3d4a4", + "placeholder": "​", + "style": "IPY_MODEL_eca14a541519463abb7f48abd7f3b8c2", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1121fcd8821e4ff1ab73683cd46c9612": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6bb8b5b7020840039debfac598e7fc35", + "placeholder": "​", + "style": "IPY_MODEL_7a8e58d904bb48959b2e3b00415456ce", + "value": " 3.34k/3.34k [00:00<00:00, 13.9kB/s]" + } + }, + "1131e84fe0004cbfa7cfe64314bd9004": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e7c2408884f848c9913ca35ffd48cf7f", + "placeholder": "​", + "style": "IPY_MODEL_10aef2e50ea14b6cad0c93ef3df29de2", + "value": " 141k/141k [00:00<00:00, 542kB/s]" + } + }, + "1133b3dc7ba249689b6e8a4e4b1ada68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "114febdcf73243419cae836aff9fdf44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_53941c06ca054c509612e4ea19bcf482", + "max": 1343, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_effb4783513640ba880117ed01e7580c", + "value": 1343 + } + }, + "1150292ed1c44625b488009ed067757f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00f6151d3e634541ac4e84994eebe4ee", + "placeholder": "​", + "style": "IPY_MODEL_c2e1c1049c1c421fb53eb8579a1a8b65", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1151736d2cc443d29e0273c235d31c0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1489ac155a6c4c92aff34b6791764278", + "placeholder": "​", + "style": "IPY_MODEL_488237b969c444a08f688d762b8a250b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1167e344ea7a4b7084687ce3afd3de79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1168e2427bc14e88958109c1ed52f670": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1190cd1e352b45168cc4a6266199a747": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1197ff507e5941cb9fd625dcce4ed06d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "119f6a60986a47ba9f86f623f22ef4bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "11a89851f2814f939dafc786864b03ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_88a2ee38266d4319a2e3128cf79d631a", + "placeholder": "​", + "style": "IPY_MODEL_6dabd8be9b5847d8a41f0aa702c3b5df", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "11a9d9113d2e43a98cae2ad95c72d599": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "11b4555a788346a18f28ba3a89283aae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_72c4de84ccb444e099e565c4e7748966", + "placeholder": "​", + "style": "IPY_MODEL_d35eeedebbf442f1a8be699bbc580b1e", + "value": " 2.50k/2.50k [00:00<00:00, 16.5kB/s]" + } + }, + "11b5b02234be4ba4858f565c60a9f2ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_52c29c1702314464854df32e1275ef4e", + "placeholder": "​", + "style": "IPY_MODEL_07c669bb60a4409bbbce17cb7bcfbb8d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "11b858c20ef745fd848b690f2320d7f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "11ba7b7efdd3418aaa64f206fc389b23": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "11c7b381cd894e79995f13fa6cf76d7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_432797a1540943b48a97b84f56e9bf44", + "IPY_MODEL_30a8dc26cc414d32a9fc900292c42eca", + "IPY_MODEL_bd7fa21e95b24b0abb2de38b9cfe2147" + ], + "layout": "IPY_MODEL_a6b6f0bef64543b68d54ee2d2f4509e0" + } + }, + "11ca189002434c3dbe4cf56bed9bb0f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "11d6112c3ec0470d9fba057b696eca0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "11fb437ea7a348e3806227efee163215": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "11fda33510f74bac9477b39b4da897be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1205bcac7db14f589d0f0f84f431d57f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "12069b24e9e64035b993c37027e66dfb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1213abe4af5149f0945438a5c63b91c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_669e706285404711bec00c22cf9556c7", + "placeholder": "​", + "style": "IPY_MODEL_d4a89c25b37a4de387641810dcb7591a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1222ead3296d4b179310eedb18af3163": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6acd4bcb16694114abfa46daecead818", + "IPY_MODEL_22d1ba8ccb184f04b8f7abca0f06774f", + "IPY_MODEL_5f594aac86b0448eb55e761563dc49c0" + ], + "layout": "IPY_MODEL_e82dd83767e847f5b901783347ab41d7" + } + }, + "12437814a1674176ac1f7e1cf584d0f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fdf833d51a10422788b22bf921656411", + "placeholder": "​", + "style": "IPY_MODEL_fa4d286277b442a7b0b805e3124e2f6b", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "12503587cab146b2a5d375a193a78d38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1258857563f24c4a86e32a9abdc6c74c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "125cd155d4fe4ad694bb5c6b193b8150": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1265e8ec483b4ce794eb4fa8a2aea0eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "127419a2127748848b6c38586e727b20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1274b9aff60c42e3a28ba1baa2e1c578": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fa1b490e4f094a95a07bb8f44c25b571", + "IPY_MODEL_a1dd76cc36d545088586749d13143a29", + "IPY_MODEL_7022b61d959e4d189909e2b3a96fb137" + ], + "layout": "IPY_MODEL_4b367ca9302f49859576409fb923098a" + } + }, + "1284b5aacbc74790b657221764e66bae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0a2d8cda00f244c5ba581047bafc3b1a", + "placeholder": "​", + "style": "IPY_MODEL_4530ebf0cfb343dfb8807e79a1370104", + "value": " 1.93k/1.93k [00:00<00:00, 8.74kB/s]" + } + }, + "128ea1432b694fbe9b826a6dab00d0e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "129b9e0eed9d4830839a9408270fd2b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b8af11e195b9497d863249d47b9eb8a9", + "IPY_MODEL_92da075d497d4d2ab5a3e65e8827d0d2", + "IPY_MODEL_e172e595c3294d1bb65bb2eb0b25408a" + ], + "layout": "IPY_MODEL_064cad5e98144909ba85663166455af2" + } + }, + "12af3a22e7e64264bed1c2925e5586b2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "12b4eb02c8774559b0383fb4d936a7c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "12ccd7b3b7054a8a9ba9451b867dce52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "12cdf1fe8a7e479f9d8afa07fe809134": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_72034c1d74ca4f2ea9f917e89b8ee29d", + "placeholder": "​", + "style": "IPY_MODEL_ee23de0d853648d2a3122ef92558b104", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "12df2841a8d74d82bbf8dfc5e5ae2373": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b29ca17e19ff4ed1ad78fb2528c05904", + "IPY_MODEL_332351dfd9e34ce7af174390cdcd4413", + "IPY_MODEL_701aa12891bd45de8c6cd5334520802f" + ], + "layout": "IPY_MODEL_a69c29227c5f4f9b922a8ed902f00f47" + } + }, + "12e61a84edbe405698ed3cfc5278a82f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "12ee8921cec14375b5a3157ca0d5413e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "12f8b0118927459595775fc000312541": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_69cb12a78b174f058be252eecad40cef", + "max": 2008, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1c357cb0488545ddb93f3d6c45d7a822", + "value": 2008 + } + }, + "130dadd434d947008469179455a94781": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "131fdc5d0ec348e1b222be6f98d9b2a9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1323a713484e48dc8da42263c60c7ee6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_491461674dc94bc0a28434c3a30d28a5", + "placeholder": "​", + "style": "IPY_MODEL_993372b0e77c4d5996ab1dc3218857d7", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "132f3b17199f4a8a8c320fdff7873429": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ad82021080b4c33a74440bcfce0e5d9", + "placeholder": "​", + "style": "IPY_MODEL_64a341220f434f41b7203ee4595be3b8", + "value": " 2.23k/2.23k [00:00<00:00, 10.3kB/s]" + } + }, + "1346179a1ad04b24870eb0623c996cdc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1356d4185789407aa4138d6b8d625466": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "135bb8cbb38f4cf7b41ad5715de4c7a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "13604e4f8f5a460ba70a99b935057b95": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "136aa1aad3e34b7b9c9a8ce8042cf7aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f07553620a324a6dbd92405f6807d52a", + "placeholder": "​", + "style": "IPY_MODEL_34fa9e32df16450e9de6a0014778b54c", + "value": " 2.90k/2.90k [00:00<00:00, 25.4kB/s]" + } + }, + "137617cb49ba46e7b697c71a8e132ee3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "13794a28c987439cb8660c6ec8ade023": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8aef7f2a0a7147dd82b2ca98f70f40d3", + "max": 5067, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0b28dab9e4524929b1e0c5ecb2c761e2", + "value": 5067 + } + }, + "137e16da1d8b4bdda7aa29193c4f2ac9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_03a9bf516c23456c856e390a3d2f2346", + "IPY_MODEL_60e6d5dcd6564ef48c407766cf667830", + "IPY_MODEL_c6b83f48af614a1c89f335ba38c0cd1f" + ], + "layout": "IPY_MODEL_d32f7fa974234068a016255aa1b7d2e3" + } + }, + "13b082d9aea44e0c990c897adcc5aaf9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3241b47c4f574eacb60a9ee090ddc1b7", + "max": 2495, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3cf8b50f1ff141d3a33983b03ae404af", + "value": 2495 + } + }, + "13b276d614724ba185ab0bb24cafdfaa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "13b2e6e825cb4d6cb448da961ab9065d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "13daf77dd23247029be70610bc06b5a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3e6d484070e34a6bae48c9b35afbc1a6", + "placeholder": "​", + "style": "IPY_MODEL_bf7e5b696bc54f51bd5d4879d87be432", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "13dd97ef61df4984aae9166930188d99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "13e5efd6f0e445a59fddf182d4d72a98": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "13e761ff03d24deeafe189f1757d47b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "13f32eed7e2a46a7ac6e614d70b206cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "13f5b779c23742248487685ffb09dd0d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "13f92be324c84b88ba77922276ddc494": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_204ac1cf8c8d4488a53ab257ff35b753", + "IPY_MODEL_2f9c7e33374a4e1b93ab203d20608b19", + "IPY_MODEL_f54ca68f48754cd194e8469fdc87a2eb" + ], + "layout": "IPY_MODEL_9ccc4edc19344872bbf0d77415708ece" + } + }, + "1429edb117e54a6d8e397cd39f7513f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c896042118f547d3b78107822160ca18", + "max": 828, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c407f4fe5cb14426a78d480f28e66a30", + "value": 828 + } + }, + "143078f0183a44f3993c7eb5ce7ce681": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "143e0041cf3d48f890e90b50b5297e06": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "143e765c26004f658b5d464c3d3e9921": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1444416034bc4dfc96ba544e3f78289d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_52415785310242ddbbf9899312bae9fd", + "placeholder": "​", + "style": "IPY_MODEL_4664e6b94ce147c3ae9397fb0ad01bb8", + "value": " 2.08k/2.08k [00:00<00:00, 12.1kB/s]" + } + }, + "144785230792473c9c554d49ef18f9aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1450d40db4af4d488b81459e6c2360f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "145c8224d12b46d0b65e43ee7254b089": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5b4fc8e711b54ce8a15db688ac073b47", + "max": 1567, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_395e1f5c1082417db3afb144014658ca", + "value": 1567 + } + }, + "1472403254ec4065a0a8a4c765c3985c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1472edf3dad74f6eaa0ffa096fc3a0dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f5308b1ff3c3419f84cbac4c447e55da", + "placeholder": "​", + "style": "IPY_MODEL_3e889266d1224890bce49fdb6be85da6", + "value": " 3.50k/3.50k [00:00<00:00, 28.5kB/s]" + } + }, + "147a7657c3f048588b2d4631400a55d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1489ac155a6c4c92aff34b6791764278": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "149008619f9048d28074923f49f774f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_06019b7a7e0c48f3997912aa998164b7", + "placeholder": "​", + "style": "IPY_MODEL_d9c144c0790a4b7086db1ee6ceade9f6", + "value": " 1.29k/1.29k [00:00<00:00, 7.14kB/s]" + } + }, + "14a42757da5b45948a5c6e85402a9db1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4a62991c53b04417b7678474125910db", + "placeholder": "​", + "style": "IPY_MODEL_c13202aff8274856ab4128fb35913902", + "value": " 2.05k/2.05k [00:00<00:00, 12.8kB/s]" + } + }, + "14ca03fd5e804516bde00684081b02b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1c9a30096d3a41919e58c316bf4af7c3", + "placeholder": "​", + "style": "IPY_MODEL_70addfc07f454d249c15447ad13db71d", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "14cf42fbff3c4123ad97e3982f16a845": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "14e7de05b7424a36a23fc22f6b813576": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1504f362ab144a02b5e1e07e6735ad62": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15129b72af6f478b8a9fa9fcb59e260f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1513fcd1969e41ef981b1acae79d455a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "151975a70b48460e9af40de42e9691fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_446b0c1198984fefa9a87b9125db0eed", + "IPY_MODEL_2e9337c241b046a0b0f4825fbbc07312", + "IPY_MODEL_58960f6d58ca401f9fbf0022834ebca2" + ], + "layout": "IPY_MODEL_b386370360cf4e33892b687862608dc5" + } + }, + "151f64e20fcc4a5aa97553c7b130a0fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_42672b3c0f8247448ac860710a225182", + "placeholder": "​", + "style": "IPY_MODEL_f8e7daf0ce894b609d96160cd69adaee", + "value": " 3.21k/3.21k [00:00<00:00, 11.9kB/s]" + } + }, + "15237c243bca4bb1b0fea2016877c179": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9b2f5dd8af524000ad6e6d6935964843", + "IPY_MODEL_988cdc08b067469687b839de53768ed9", + "IPY_MODEL_56cf9162213543fd826e6490f2715b55" + ], + "layout": "IPY_MODEL_071156adb02b46268990bac4fadddb12" + } + }, + "152618c004e54089a605f86130596e75": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1532359c4bce4b1dacfc6c206e72c7df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_35e92d1331af4da5911c58eca55e71f4", + "IPY_MODEL_6f72aa18ae484be6a4f4cc93ac8123c1", + "IPY_MODEL_307aa3d7469f4112a18a050aaff066d0" + ], + "layout": "IPY_MODEL_8bab65c6e2de4b3cb93e2bc2c25376fb" + } + }, + "155b6ec3988542b8a7519f8d1e61d872": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1562f27b68cd42ca9de808b2fb09e35a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af956ff21ece42d9ba3ca201e8e4e1f6", + "max": 142394, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_371f3e47232049b7aa0e251147937e0a", + "value": 142394 + } + }, + "1573ae8c072c40debe60dddb242e6e0c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15802ded0a0a46deb2ce7a18da1c71d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15890efcfa6f4152aaa38b0cc7d0955e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15a0239776044901806298b96dd1bb4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15af0b11c94344bea7cd65520dead630": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15c967b450e6497da41f07464ad7c2d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15ca26be4e51449298677cd34c3d04e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "15e0b1e61c7f4e909720e17ac922323a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3ed1656afacb47d49e602e14014b2ece", + "IPY_MODEL_c27879d218a442eeb220673c712fe1f4", + "IPY_MODEL_23f921be849b480b8a42a2aefe882b1a" + ], + "layout": "IPY_MODEL_48e1275a0d0d42cebe755d9c85856dd5" + } + }, + "15e1df0c562642a8bf05b7f069d8e1c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15f2d48096af45d9b769a50b6a4ab578": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_04bdbec5fdcb4498bda659cb05fbd24a", + "placeholder": "​", + "style": "IPY_MODEL_ded490d1955e47f1ad33ad1b7e7cf040", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "15f3c8c9d0634cff9fb524b35a7db11b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "15fc0dba4399437da310cd1e3c4effea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1600f0ef839a4afb9795fd90db1f4966": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "161bd046dd85409d93ed0a8fff1f168e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "162337d9099f466ca8077337d83de14f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1629020a95e84495bae6c9142567cd8d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "164bc9614d1542429336585bf1a086ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "16535ed1523e41ad853db8ff797686c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dd4195136b5541ad88597b0646225451", + "IPY_MODEL_bf8bb047f98a44ac8f7f8b29fe678b94", + "IPY_MODEL_e06d35e258c94370afda04b30f73b37e" + ], + "layout": "IPY_MODEL_586a169b1e26477ca3436e64d4655cce" + } + }, + "1664d1b53e7a406994b08d212d6c2d65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9309ddc565b74b7ea4f42e3a0d10f8b9", + "IPY_MODEL_866156662e8c4e5ea1280dabe82b15ed", + "IPY_MODEL_449cbedae32848f7bd4816cadf7e239a" + ], + "layout": "IPY_MODEL_859ba95884ea4a9fb84ffb3297c6d469" + } + }, + "166ac2fa0a5a4af4a7ad576316b72b44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "167f1d0bd1ec47b7b1d6cad6d471367b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_df85c2cab46649aa9604ba9fa519898e", + "max": 3467, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_354034acff074fac9b59985826d15ddf", + "value": 3467 + } + }, + "168b2ab93ab64e9d910022d359efd6f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "168e69bd264d4d47b02623d7d603ec20": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "168fb84d31404ff8b9453eec2d433ab8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1695a8ceff2f45a899d790db9ee45d13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a5956154ff91463cbde07384c7e43058", + "IPY_MODEL_6a68a47f0a804afb94f08bb02c2ae5cd", + "IPY_MODEL_773cb45aa3d641028a8e020327a3e4f2" + ], + "layout": "IPY_MODEL_f2553af5de8e410bbe53954fc27dfd1d" + } + }, + "169f532de4454314980248c84dd4ebee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ef1aaa1881004639b50da1cf8daecd95", + "IPY_MODEL_622a054f26ad4326a022394e4a1cb320", + "IPY_MODEL_291fcc822e0340c4af9d1f586be1274a" + ], + "layout": "IPY_MODEL_bb6a8c5460ef476695a8780e2b192a7c" + } + }, + "16aaad1013fc42d38ea88e9417609e69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "16bf4027fba243b289c11ed0d42a7557": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f5aa88edd79445a598c0fc8aabba7651", + "placeholder": "​", + "style": "IPY_MODEL_316fe2d241c044caa4e2e978aa6f59e2", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "16c06221474144558cd8fcd720d4f16d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "16cddd0e52ec463a9c28f3c6caaf11ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9dc6b6678ce1419fb7366f4ff34640cb", + "placeholder": "​", + "style": "IPY_MODEL_4520f46071cb43d38220df54fa127854", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "16d011a3997849e6afb3b60608a48c52": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "16f686da39b84b35bfd4eb5601faee9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1710fbb5299c4ccabf20efeb00fd3b59": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "171f254249ec40f7b8cb4de1c32606df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_93050188a11f4ff5b3e49b76eadca644", + "placeholder": "​", + "style": "IPY_MODEL_c33e0db529044578b14c8d10b9c4190d", + "value": " 2.74k/2.74k [00:00<00:00, 14.6kB/s]" + } + }, + "17207df0a55c43d08c88a74cad9aba26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "172187140d824835b1d9343535fa9b45": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1729d2469d8d4ec4b4afc1f00f4aab59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_19b977bbb57d4ced8684b3dd1b34602c", + "IPY_MODEL_6a11ef18fea54b06b02c6049a184bf36", + "IPY_MODEL_820af612da554b1fb67ba4a8fd4ee363" + ], + "layout": "IPY_MODEL_45325b2f82924062a06cc466dbae1bc2" + } + }, + "173c288bdf474f009f225ec2443a19e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1745bf56de50436c8b967695ac34b12b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "174895fbc5ed4a8594014e02e43ad201": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "17654f6f239e444baace90d518590988": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17706829472b436abc5db5d28e1b6f70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_51d3d5979ec44113b9f1563604897bb7", + "placeholder": "​", + "style": "IPY_MODEL_91c19999fa2e4e9c952d6be7d01f1cee", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "178bfac7e854437d8180a5c8b599e82f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "179185ebed5e426db0ef217d45a1ad58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f3906a1dbb5e431e97503b2ca5ef8d7a", + "IPY_MODEL_ddc7cbba56c149d585eace18855f7347", + "IPY_MODEL_ba3266b8748540ed81f8789130cc0ef4" + ], + "layout": "IPY_MODEL_0a1dc02ec280423d938be5a2e409a2d3" + } + }, + "17ad1cec7f0f4b15a07270714a498c84": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17b5c2a69426414f82b0242dd7c77682": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5257cbd151e44e9cb55198567a6c96f9", + "IPY_MODEL_74d722d07c1a4392831f6108512ddd1f", + "IPY_MODEL_c4fb51361c464b91afa99862397b8a84" + ], + "layout": "IPY_MODEL_7e0eb9be09ce433f837fcba97f4185c8" + } + }, + "17c24ef4d2594af08c19c82562fb676d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "17c8ab8a55554848a08aa16a35aa8aba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17c968d33c684743af7f6ad264c02682": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af0e3f638b6b4296ae310f94952f98d6", + "placeholder": "​", + "style": "IPY_MODEL_b2518b296c494e1281101c951c40e287", + "value": " 3.07k/3.07k [00:00<00:00, 17.7kB/s]" + } + }, + "17c9e85782bf4df78838a42ccfdc0163": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6d05945f9329453dba40f89f53fd4f20", + "placeholder": "​", + "style": "IPY_MODEL_713e5ea5e2e64d478a76386f5c76e35a", + "value": " 828/828 [00:00<00:00, 4.72kB/s]" + } + }, + "17dc18f9df7b44cc8ca4268fe0d958d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "17efbbd811f24622aaf16d0225536d6a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17f1ffc7a70146ed87363cfdd6251a61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_48abf6ccd35b40cc864a130cc7319711", + "max": 146745, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5f6422fab2004f1aa7857881fcd59870", + "value": 146745 + } + }, + "18035eda3f2f4264b8b5cd46f79eb79b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0dbac81fdad4671be34490bcf3b7892", + "max": 1127, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3e92a26398ec4455aca9b0582f275870", + "value": 1127 + } + }, + "18078e7cc7b54250be52fa79fae811c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "180d4216ba8e45d18bd2992f8b4b2957": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "18141f19282a484387bfa2c5877399bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b1bdfac84564609821f9a30d87294ca", + "max": 2472, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e8a44564aa1c4cd6af0f6058254d6667", + "value": 2472 + } + }, + "1817f29dc58c498b96b01382775f4dec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d9ff27b011c34b7086f48c9cf1a47ae7", + "placeholder": "​", + "style": "IPY_MODEL_1a7d40406e82403db770ee2b4c8a3149", + "value": " 1.98k/1.98k [00:00<00:00, 8.72kB/s]" + } + }, + "181ffc76250948e6afbfae10abe3159c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ccae6fa6959941388bebe42ec4987923", + "placeholder": "​", + "style": "IPY_MODEL_296e23a7b8574a1f9e49ce837a53ea08", + "value": " 2.00k/2.00k [00:00<00:00, 16.1kB/s]" + } + }, + "182c69c4fbc842349bbb54212d22033a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "184b9199c3e74a8896bde4ebc07324dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1852414688ce4ef8a4bec722b997c37d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "18595fd9954b4515aeebed5676dc8c0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4304f9af8d3649aea09b46f502bf951c", + "IPY_MODEL_edf3d942345f4a368ad868fb823a44d4", + "IPY_MODEL_7d378f6252e24554bc0c33568a1bf8f9" + ], + "layout": "IPY_MODEL_9347e69e3db5460280382522c42dd0a8" + } + }, + "1859810ca5284bde9b5162a4faf76634": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1859be5fef9c4f11abf26e57c6e3b710": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9670537237f241c7962a9aab6245f14d", + "placeholder": "​", + "style": "IPY_MODEL_5248bc41f0694f979651acf033c7a49e", + "value": " 1.47k/1.47k [00:00<00:00, 8.14kB/s]" + } + }, + "186801289b12436696301865bf167622": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_68f73f8a86994b88a3def122a968636c", + "max": 147525, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_96c1faf31d984ee197eda3e902c2baf3", + "value": 147525 + } + }, + "1876670c15e6444eb791d3401bd74a15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "188ad615368d4677849f42daced9e3a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9b35b88e594a42d19e6156ae10b238ae", + "max": 848, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6626d0660152408b9c12bdaee01ee315", + "value": 848 + } + }, + "188d5eec440c470ca1b518c94af5ece6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "18929b9d2aed483cb99a48411c60f82d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_71fc8a0fd75a45739abe0b8eed824e6e", + "placeholder": "​", + "style": "IPY_MODEL_509c1d827e164f1f982bd8459962dcb2", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "189557900c884cc59e6f70ef4e130c5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "189e82bbee224ca18f7d4f60a2bdcf52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "18b00497179a4eadbbf1fea82b9db639": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "18b5bd8a862f405e8bcf24aedb392da4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "18b60689bdb84dc2aea50492d923d644": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "18bd3db6b9cf4363bbfd10cdec2e5259": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "18be3174c0e44705b83174ac52dafffb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "18c8eabe5ed94f4eb22141e3b05511ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3c6e7ddd65224aa0969d719ebc60f3f4", + "IPY_MODEL_1d399347ba3247b597351398378c0d19", + "IPY_MODEL_21799f0f39d34522acc27b72df96b964" + ], + "layout": "IPY_MODEL_abf547dd8692420bb1d0cd7971fe1eb0" + } + }, + "18cb0128789242268bb1dc399cb8f39d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "18cb15ddfb524b1d82011977eb6b25ac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "18ff23700ce44ed9b132db20359bbf58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_931b5b63d409473689d92965a864b157", + "placeholder": "​", + "style": "IPY_MODEL_1b183b4fe59a4f09ac8f6f61e3d65c0f", + "value": " 137k/137k [00:00<00:00, 596kB/s]" + } + }, + "190e699a19634ebeb05acd72c55f8e55": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "191aa3ef665f496b8f1b32eb2b6e4e46": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a3853bdaebd5464e85e242b9b6b5ccf6", + "IPY_MODEL_24f3302b2b30419ebf69fed24d3e79e7", + "IPY_MODEL_8ce735e81260444cbc63ee33fab47e58" + ], + "layout": "IPY_MODEL_d917ca86776d4f92ac6b30f89472053d" + } + }, + "191d5a5733ba40a7b932a301768e0336": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "19264cf15774460a9e568ed86f0d0df9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1936402d787f42ebac4f2cfecb33c345": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0ae82f6b26124a33a6e7f9b697e85825", + "placeholder": "​", + "style": "IPY_MODEL_3446c3fd1d034cc8b3ffeb5a879e0078", + "value": " 2.59k/2.59k [00:00<00:00, 8.53kB/s]" + } + }, + "193a614f1f67400e873422ff4ff963af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_50824fc74063400180b04681afc1a2e2", + "placeholder": "​", + "style": "IPY_MODEL_0eb79f52b1814046b567f54e454cc012", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "19442892a2a24e019e97a630bd07b500": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_df13bfae0238476481f11e406bdc6735", + "placeholder": "​", + "style": "IPY_MODEL_f2ddef131b6c48279ad2bed01eeb720a", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "1948097dafc94717a5a080d42d943143": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e5720ff0080842629652d5b37c19c210", + "placeholder": "​", + "style": "IPY_MODEL_f960434ab2f844319e42a6d20725d047", + "value": " 4.08k/4.08k [00:00<00:00, 18.1kB/s]" + } + }, + "1951e266951b42dab47e48d5b3acd69a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1969d59825aa4c298883f22e1ccdcd54": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1971cc6837c14c72a39f79b89489c4d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d161dd30c81049958a9a7eba84f4634f", + "IPY_MODEL_d06840deb3eb4c219b464a10500579bb", + "IPY_MODEL_f5a3567ad21940098ae0aaa85257ef69" + ], + "layout": "IPY_MODEL_f1559b378b6f4268a85e4a9e26a0ab43" + } + }, + "1971ea9ace2a4a70a042241a7b874ba5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "197701851a114dcca2368d1d30142058": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_95bc1c65857c4de79df508645dd27d87", + "max": 1677, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0095a0022efc4efa92033e5191fc01f9", + "value": 1677 + } + }, + "19770cec16a44727b2ae0e4fed9d89d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0815ab3de99c46a4af454f5b286a034c", + "max": 144162, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_64d23ec43c0b497c87d60233668562fd", + "value": 144162 + } + }, + "1977fbabe9b245d1bb57bae987318226": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1986123b93a141e0add404d38c708c32": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "19ae31b26f9a48e7b8f2bd5881e1cc08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6035f9361f5e4918b99456187855f866", + "placeholder": "​", + "style": "IPY_MODEL_dfdb3b6302974060ad31c2429fce326c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "19b1eed1066f45b78fe217c00042ff18": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "19b2c213f587434da6ed0ad09851f7c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "19b4d44e46974b9698e21682a4dd6b4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad415056e5904fe9b99866a0e2a47a8a", + "placeholder": "​", + "style": "IPY_MODEL_0935bd51ad0a4a0bbfe7a61a56d32593", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "19b977bbb57d4ced8684b3dd1b34602c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_afd313075fd446e7bfec4507dd73c6bb", + "placeholder": "​", + "style": "IPY_MODEL_863eff68f497414d8578abab6406e091", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "19ba9f6d11d946ebb33dfb36164046d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "19df1c2c06fc4c1d8a001567ef94e5f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3ba21107188641608cf81000cb3ce904", + "placeholder": "​", + "style": "IPY_MODEL_3f396cb574704e9caf317c1d87f86b16", + "value": " 2.84k/2.84k [00:00<00:00, 17.0kB/s]" + } + }, + "19ef9ae517984a28805e00970adac821": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "19efeb4e0643415d8d2d18e95bde47cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "19ff2ff1334e44ac89257e7bef886a09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1a19174cdb59426baa88d9a11d68ab9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1a1ca77db6314949ac8792e6a71eda73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_db705faa34174449846e14481434f3f4", + "IPY_MODEL_3331f960e2554a58a8c4c821e3830b81", + "IPY_MODEL_0f484ff05e67430ea2599095c7c69d33" + ], + "layout": "IPY_MODEL_d429fd2732ae4a73a27d895af5be480b" + } + }, + "1a25de056f994d519b4809c9e9e32ea4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ac2820685566401ba284d8c2a8dcebda", + "placeholder": "​", + "style": "IPY_MODEL_6246fe98bc5c4ee1893bffa2da59952a", + "value": " 150k/150k [00:00<00:00, 273kB/s]" + } + }, + "1a426fc388744824b68d86e594ae2eed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8d25b7b7ffeb489abd96561529e3a418", + "placeholder": "​", + "style": "IPY_MODEL_1168e2427bc14e88958109c1ed52f670", + "value": " 145k/145k [00:00<00:00, 860kB/s]" + } + }, + "1a4b0175d8114e8b9681dfb32e3f00ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1a4b66e9f9b34380883550c3be934133": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1a4d05c332974d63b2a69fe8d56277d0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1a5827b00aa542d8bdde30e86b93985a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f66f0cf11eb34ed4ab361829596bfaab", + "placeholder": "​", + "style": "IPY_MODEL_d6f31f58b4a446299159c27299535d80", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1a5e0d59bf9440de850f5172318bf211": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1a668557e98b4ab192e59d3d222d5a3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0761c6749bf7420e8bbfb28a91264718", + "placeholder": "​", + "style": "IPY_MODEL_54778e0df56145f384e54002ef13eb91", + "value": " 143k/143k [00:00<00:00, 273kB/s]" + } + }, + "1a77494c97514fc1b3257cb94b0b232b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ae295e86738f4ab4a9b02bd83a2f4ea7", + "IPY_MODEL_e3a35774b3a740d2b0dd60583151701d", + "IPY_MODEL_0eb7304b3f7a4e9ead2fcb1cb183c600" + ], + "layout": "IPY_MODEL_1ad0b6384a6247ce990f947a3589fc29" + } + }, + "1a797afdf1f74896bd33c40cbe441067": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1a7d40406e82403db770ee2b4c8a3149": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1a801289b0434eb1b06bc61a81b01fd0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1a874a393e83489aa884fbd330edc439": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1a9657a0da9b422e8f7e18ef9863d50c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1a9afe25ab384aaca232705bef1cac1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_46411ee55f5141eaa5d50cb4e604deec", + "max": 154099, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_28a5475ef0b74555b083d323ff72e5e9", + "value": 154099 + } + }, + "1aad7f7677694575bcc3f7d96d9eae2f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_82ea5220b8a9474fae3847658cdbf0fc", + "placeholder": "​", + "style": "IPY_MODEL_7f3cab2aee9843a4b4744854af545c70", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1aaf1fe5016446d9bfa5f4b43c4ea403": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ab5547c72cb41909b180e198caf0c88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f31c7939eacd4de5ab66955e912330a5", + "max": 1476, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e6022f88fa4448c0997df7763c8acfa8", + "value": 1476 + } + }, + "1ac996908628418296ed0355e057c64b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ad0b6384a6247ce990f947a3589fc29": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1af2fa67eba649d7abaf974d3a0b4dd5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b02421447534ae79697cb6516c8b736": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b050707f15f4df895bd846e5a839a72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0cdbef85e23548f6a14dcae3383fac5e", + "IPY_MODEL_583081c0998841f6a384f9beb2a3e378", + "IPY_MODEL_aab87333150b4a13b4f4976120892b32" + ], + "layout": "IPY_MODEL_15fc0dba4399437da310cd1e3c4effea" + } + }, + "1b079b07d53f4c1a92c9512bf528abfc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b0d8a8dc81a4a1bb4cb83c99c73227d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b183b4fe59a4f09ac8f6f61e3d65c0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1b2668e9821c490b861eb6eeaf82cf53": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1b39feb14db748738813873a4f3ffa76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b43041a3dad440da8478d98cc9e6608": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_343300d2ace44d4b90f69af11c885fb7", + "placeholder": "​", + "style": "IPY_MODEL_38f69dc5f2474b2597cbf01f7224004f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1b6581e9a5c345cbb52c54929a61195c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5ec3c49f74004fe097c2fd9a89d9ea7f", + "IPY_MODEL_67eb952d05184ed58a518d8e401506b8", + "IPY_MODEL_b2294a87202f4b0c8ec80385ec750f76" + ], + "layout": "IPY_MODEL_95410020c6004486b5fe6963052c7dab" + } + }, + "1b6b89c758e641c7ada67398f9f2fa1e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b75029cb87941459e0b9c532adf2c53": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b76fce471b74aa0bcf6f18d0aa89452": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1b883b1d5cad40088cfc6e23b95a1f8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1b8a81e93ec24f01af48a45806afd28b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ba649fc9050416cbaf70de0671d6beb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1ba9f609cea24bb49ae3cd94bf21cbc4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e14684c133e647ae811911cf5451c8e2", + "max": 140412, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dd739f90e2ee4fc9891ca9ee0a19c527", + "value": 140412 + } + }, + "1baca642e3944d6a879ba493aea7a7fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1bd3229ae14d419096a5cbb502785f18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1bd850e09ddb42909db8a543199c2c42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_24724ce1fe4c4e5eb536af1a52ea1941", + "IPY_MODEL_e72696eb834343099b1d5c6ed3e05731", + "IPY_MODEL_edff3bf033ab45679e518f942fe86864" + ], + "layout": "IPY_MODEL_356e5e0a07da487f81a2e27824b952be" + } + }, + "1bdd99e3b58045c084364746ef289167": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1bfb222f761b4d71927644b318f1efbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1c02e93af68b411d9d90b808c6751bfd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3b4592d1740c4f688ec60461f3eb554d", + "IPY_MODEL_b13285316c7d41b8ac878682dc6b931d", + "IPY_MODEL_262998e0a6704ca684bccb852f9911f9" + ], + "layout": "IPY_MODEL_04cc3270885940dfb10e922884eb6f15" + } + }, + "1c13b2ff48344f0d825633a75164e203": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1c357cb0488545ddb93f3d6c45d7a822": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1c4f014dc69d4a68a136a9a0d144fe84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_904d740c4dfe411ab0e26dd0626bdec3", + "placeholder": "​", + "style": "IPY_MODEL_0a758b0c792d4abbaaa190f673cedc83", + "value": " 2.34k/2.34k [00:00<00:00, 9.48kB/s]" + } + }, + "1c65c6222e6c4910a65332ffb1545664": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c6a3c9c81f84623a64b82b412993f6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1c6ec1b2d26a412d938a397097504b8c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c71c68b4c204f57b87120cf36d3ea97": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c727d8ce8be4c88bf78b82f35ee95c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c772da0a2bc41029891217c08d55a61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c9857915e6a4326880ea40d63330531": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c9a30096d3a41919e58c316bf4af7c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ca405bf5b0c4021814623f5afd1267e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ca49bde612e478eaa82e8083d272a04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1ca5008e1b22475398ba03f370cb6323": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1cc03e61e64c4eb8b0eb13be9f3d23ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1cc41f3588c7494387fa0295c2c8f215": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1cc663e9cbea48968f817ee138913749": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ccb1eb2c476405084193ff4e4bf3ddb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ce9f315fe80443f885e321ea4dddaf3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1cea2e1fee5e4cefb70f1c229962b807": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e35b7707727b4fffb4d13d18ab748357", + "max": 992, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4efd74963c6c4f3289cdb624eb8db5ac", + "value": 992 + } + }, + "1ceec0263e8c442e86a360e2d563020d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1cef7843877747958ce01ec9a8aab266": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_34d71ca3f5a545b7bd7aa1fb76f64204", + "placeholder": "​", + "style": "IPY_MODEL_8974b5fc546e4decac98cc96c725a61e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1d0af88c5075491db5fe80b138786121": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ada08ba6373145498b6bc7a641a734f5", + "IPY_MODEL_7bc765db15904bf3968fd26a6406a7e5", + "IPY_MODEL_b8bd0e490e5a40a38c82d110eef54114" + ], + "layout": "IPY_MODEL_3729ec65a3e24fc5acaf34612f06d71c" + } + }, + "1d19c60b557f4a23b9dcb99b6de630d2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1d1b145fd5ee4894865ba15bc1791845": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1d1c9a3f25b441649f29dba0b11600fa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1d238feb6b474cfc9a2c5466dda8a5a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c86c380eb83b4f0ab6dbc4df2a084705", + "IPY_MODEL_c9cb89bf13334051902c98a1e74fff5b", + "IPY_MODEL_419a05be39c84520a7bd3cb856dbe28e" + ], + "layout": "IPY_MODEL_d452c3340473448688d6d4c35ab4d1ee" + } + }, + "1d399347ba3247b597351398378c0d19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a29469a4b1a54828870846bbc67109c2", + "max": 2173, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_688a569079d84de2a565d460aee7f7af", + "value": 2173 + } + }, + "1d3b2c1332464e9b9939b117217fce88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_43d81de4a66c43948e94f9195006c777", + "IPY_MODEL_be781b23cd414a2baa88313779bc0fe5", + "IPY_MODEL_4581cae484c245c186b0694261cd3f4c" + ], + "layout": "IPY_MODEL_c83a643bbce24ea89a4a47a3f404cd9c" + } + }, + "1d49491520d649fd9b4329b50a883a4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1d51041c854549db9164ec1ba218fbb6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f678dda9b217428c9d8edc1544fb3f64", + "max": 2493, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4541129a747047d88d0588528f9c0554", + "value": 2493 + } + }, + "1d6cfd2f959e49389c9c3bf31e12c156": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1d703ecd11ab4b6bacdc74794ae8ba52": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1d7227fe8203445cabbc49ae74e7c933": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a3fac1bc03f74425b8a7d322d7fe7ba0", + "placeholder": "​", + "style": "IPY_MODEL_716739fcb3284bac8c1f32ce224e6e0b", + "value": " 148k/148k [00:00<00:00, 916kB/s]" + } + }, + "1d8379c3c5de4eb1a361209a7a30d2a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1d87355cc14940b591b3bedcc45490fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1db39b5176cf46988e19138fee1deb80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc9c520f5d994af1b4181992f9922f0d", + "placeholder": "​", + "style": "IPY_MODEL_2d40b96af29c40e4a626986312431924", + "value": " 1.80k/1.80k [00:00<00:00, 11.7kB/s]" + } + }, + "1dbf03ee74a34a46919100ccc3fa0b9e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1dd431ea9a8e4e0db1394cb15a8b045b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1de914bafa57494d987805fbff744a9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c1dffdddd1ec4c0bb33835bf345033d5", + "max": 161076, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fa1f526fce074357a8305a57cfe09d3d", + "value": 161076 + } + }, + "1deba361256048eca68d3f6993e5aa1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1df8c1126c9d4449a1e501d393e0dafe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eabbecf8c78b4723b3da51ad57e3de60", + "IPY_MODEL_dbae04d9f1a14342b7c9dfaada36b596", + "IPY_MODEL_e30a0d7a3c3b406ea73df5aebd70d515" + ], + "layout": "IPY_MODEL_0c400069812d48b38dc2a46a96bc8912" + } + }, + "1e2bcb1369484f479a6137ff1c34973e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1e3bc4007a0f4f7fa18082efac627ad1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_519952bda1ba4799ab476b6d46e4d96b", + "placeholder": "​", + "style": "IPY_MODEL_1f112e407f5e4622bf7908657319fd63", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1e44bc70dffc40118fbcf51dcf7ba48a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1e8616f90c5f40d68f7182ad8749c88e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1eb226bbf34d416cba8c94796cb54307": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b6557df1ca5047d08b2fd07072128f80", + "IPY_MODEL_58af369c59f24725af8cd304a56dacec", + "IPY_MODEL_47ef6b3a4f5549e5ad3aef59a0791d20" + ], + "layout": "IPY_MODEL_7d7df712f8184a4eb6d096d75a4467bc" + } + }, + "1ec37d32d52c479181427d8c49a91e67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b079b07d53f4c1a92c9512bf528abfc", + "max": 146518, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eef9a886afc6429fa4d16df7d40145e3", + "value": 146518 + } + }, + "1ed57112248c415091fe143741855b9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1eea6d3d3df94c50889c031338f47207": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1efae3f086e849ef8a308dc87cd2d4f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1efc618189184858a00fd07aec166260": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f021bbf007f4d25864567f4b3fae7f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f112e407f5e4622bf7908657319fd63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1f1d8ce3c5da46b3997b5d5e3546ab5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f23d0f776da4c399c6db8f2e49d1fd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4c3fe1a3cdb4c1eaf96880e22504529", + "placeholder": "​", + "style": "IPY_MODEL_b1400e96809a4cf9baeb3a2584db7303", + "value": " 2.65k/2.65k [00:00<00:00, 13.0kB/s]" + } + }, + "1f2e99d798464f65b9805574daf292a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f3071ec2fe94beebd2160cc73b8211e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f3be65e2d014cedb87d1bf264b37735": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d7b6642466ea4eaca7b640885879b6b7", + "max": 2402, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7f24ab9dda5e4f0ea37f4c02fe55705c", + "value": 2402 + } + }, + "1f3fdb74456441db87b9bc9a8e60f2b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f435fbe53dd4da18204f1f046bd2e34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fbcf9446ad504687b14417f0b52db9ef", + "placeholder": "​", + "style": "IPY_MODEL_5e828fcef95f46918b0e09a5711c6851", + "value": " 3.04k/3.04k [00:00<00:00, 15.1kB/s]" + } + }, + "1f4996d0aeec4683b7dad52642d36ae9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f503a1126d943c38befc19c57788f70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_128ea1432b694fbe9b826a6dab00d0e7", + "max": 142691, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_55071fc84042412dbe884a1efe8f5294", + "value": 142691 + } + }, + "1f5040d55fbc463f849a70cd35ddbb87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a4e8ed61f8a4d3182d605a0bed5345a", + "placeholder": "​", + "style": "IPY_MODEL_dbc92b7f013d43488e13e5748d168183", + "value": " 1.44k/1.44k [00:00<00:00, 6.11kB/s]" + } + }, + "1f70d96741cd457aa80bc2c9ebbbcb52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_69bf9eb558ed4dd59ebbefb518ca639b", + "IPY_MODEL_593bf7025dfb40fab8d831d4236da6af", + "IPY_MODEL_93dd0152ba1b49a38187659a7c97969e" + ], + "layout": "IPY_MODEL_1c65c6222e6c4910a65332ffb1545664" + } + }, + "1f752fc10f104cdbbe5bc2d5468cd124": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fa1387525a4046d783519975c4a874ab", + "placeholder": "​", + "style": "IPY_MODEL_b344060f72814dcf9699341cb9b876df", + "value": " 1.45k/1.45k [00:00<00:00, 7.47kB/s]" + } + }, + "1f7cabc393874db28399dbfa0f0826cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_74581f0a19d943dabebed3e31b5b7e8e", + "placeholder": "​", + "style": "IPY_MODEL_40885555589c4b24a538d360186dc2e0", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1f7eaa1a8d90453aad24d4f24ea6d441": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad423fc0f49f456d84d99bc7bac85e05", + "max": 145058, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6c4660e5a345437c9b1217b68d2aa5a7", + "value": 145058 + } + }, + "1f7f87884d554b29aef2d87b2a56174f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2f247ba83ad64e42a9418f62232851b3", + "IPY_MODEL_5605a8856d3a4e499c0b14be340ac9af", + "IPY_MODEL_0f0971148317474d93754e266132e330" + ], + "layout": "IPY_MODEL_6a9714548cda416cb3bf03ce0e8d644a" + } + }, + "1f88d7442ee94a37a6ddca1f0e50de7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a5e8ee836a64d52baeccefce0e671d1", + "placeholder": "​", + "style": "IPY_MODEL_63acb0700e6d46e6a37a8396ca51786c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1f90e28cf9e34d41b88d26288824d28f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eb47b66aba55493babfccf55eb9b4dde", + "IPY_MODEL_18035eda3f2f4264b8b5cd46f79eb79b", + "IPY_MODEL_dea15bf3041945059a2ad724f5c12019" + ], + "layout": "IPY_MODEL_4e4c459cf56a4ad095807134b72939a0" + } + }, + "1fb86c477e884eeeb1457d22adf04760": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_713afbd7a58743699024314c50961d3d", + "placeholder": "​", + "style": "IPY_MODEL_7ccb9fb06d9a4d5bb74f1a5a4ec7be24", + "value": " 147k/147k [00:00<00:00, 841kB/s]" + } + }, + "1fcd5324f12a40a78c9662df0c402876": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1fd33c20361c4ab9b4e284879d3cc979": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7798d8869ef942ccad0311cf2f022b72", + "placeholder": "​", + "style": "IPY_MODEL_4b60fba5cc9148c69d47f2a1d7524a7d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1fd598b71dc5470d884e21af866af101": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d70a783115c4448e9222d9eede0471b4", + "placeholder": "​", + "style": "IPY_MODEL_f3048685518f47bfb17bb6606c936824", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "1ff6502727b143849e7a0c1a416c9b13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5953e1de9db44528b8ccf03c1920ce6a", + "max": 125467, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ce0ba92e50384a2cb33e8cb3d2b3608d", + "value": 125467 + } + }, + "2001515cfab94120a22fa53694b657d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2028362fbd3e4b7290f69218dee78a84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "20301f0dca754f1e80cec7b5e66a3557": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2039e262be184e239d0f9cf62838aef1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "203d54926749455b95687e35d5ac915a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "204332fa93b54f75b1c2fcafbd018c1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2046754926644f97958db1e1d5ebdeb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "204ac1cf8c8d4488a53ab257ff35b753": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9b6d91413f104bc3b68c86af04a0880b", + "placeholder": "​", + "style": "IPY_MODEL_7e370774426f482dba58f3d81d7adcee", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "204f11e188804c84b60591c68de8f11e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "205af868eb174c52932e254eb14ab6a9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "206fb37080b844369ea9101e6725ef96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "20753fc316a4494f9efc887353fe01dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2edc5afecfb8419bacce3987b8edebde", + "IPY_MODEL_00f52edb1cdc4b68baaa48e06a4c3fbe", + "IPY_MODEL_abf2b07cc6974215ac4194d69ec29f73" + ], + "layout": "IPY_MODEL_89954df636ae41e9bc32cf356fb607a2" + } + }, + "208465f4d5484588a36785a08f0e5d5a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "20c32208286442a8b57a5f62e5b8a298": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8b61c77cc9de47f58ba10c675177d74a", + "IPY_MODEL_6cb2bfc731d14778a03bd03efe0b5603", + "IPY_MODEL_236b23882fb3471f9cfd61d966e8a498" + ], + "layout": "IPY_MODEL_455c7d9f38b94e18b5591c3de4273ddb" + } + }, + "20e2059f029741b7b4e1d7db0206dbc6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cd587eb0243b48ec8806f40e8140f228", + "placeholder": "​", + "style": "IPY_MODEL_5dcd5401e39a45e0bf6557a6e451ea97", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "20e2c11acec541e0bfadad723ef5538e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f3668041960548e3be37bda53d474e1d", + "max": 1664, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3157678fa08c4bb2a3845a1ae539513b", + "value": 1664 + } + }, + "20e7bc1516524ac69401c3be724c6203": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "20ead03340614820bc9f0ea85a8b4853": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "20ecf71d76ee4f47a5a35fc647a1fed1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "20ee3493aa4c472bab377d3413bd570d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "20f770537a364899aedcd499eb9c6b39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_62bcb65a18e34bfcb905638516a6814f", + "placeholder": "​", + "style": "IPY_MODEL_53ebe2556ea34a9898988935be6cc8e4", + "value": " 1.56k/1.56k [00:00<00:00, 5.78kB/s]" + } + }, + "2102840690c84d7485ce1f1861d7140b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "210428211d3c445db2b1ac0c66099080": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d8394b6239dc4907b335e7efeaa1fa94", + "placeholder": "​", + "style": "IPY_MODEL_7b8e56a985c34020a97d95bbe47b29e7", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "21153cb885c9417bb8b79ff1a9d36903": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2131d2511b8043509da1fbf3a9556872": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2132b6d5a15f4d89881cbb394bfe80c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21346775a5f6435292dac2208f5e671e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d3af9be9ad27414e8008f571cf3ebf79", + "IPY_MODEL_7a8b331f92414356a8468befbc33fe7e", + "IPY_MODEL_f58e60df0d2b41af8e406802b8f05315" + ], + "layout": "IPY_MODEL_8139937d055641c985b0bdef7cb90184" + } + }, + "213752daaeb64dadb6815b055933daf5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7673a121cd6f49ae823aa50f616037c4", + "max": 1219, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_81af0a726180435fa9f5d63316fedd8c", + "value": 1219 + } + }, + "21388718ee8747c1b7fe0e11f69b4e21": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21423cf0eb484026845330bfd1131a08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "215ac19920c54889850267b19856ea97": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "217208f6d4664e6ca769a7f3fc0fb92b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21799f0f39d34522acc27b72df96b964": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4347b65c5b80425c98cf6c458366453f", + "placeholder": "​", + "style": "IPY_MODEL_8e0ab8aea3e8496aa73ff342fc3cc022", + "value": " 2.17k/2.17k [00:00<00:00, 12.4kB/s]" + } + }, + "21916b2d71384c46b423c9bb6cf34bec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2191f4bf3d94490b83fd16472d19b276": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21a1a25c88b34190b87744ddf89c8e26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "21a3e1707154403c9e48b60244eecd51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21aa5d5853da440387073b9c229cde0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_897f7169ca494a33b0c60264da3d1ff5", + "placeholder": "​", + "style": "IPY_MODEL_730c1cd2bed54619b5dd17388afc63c1", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "21b759c31ecc4d0980d395966e2be711": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "21d7a5b016154a81aa8b9fef7caa117a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21e0554943e5403f981c592b6a89a3a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a0610584681b4044a8b79a1472030721", + "placeholder": "​", + "style": "IPY_MODEL_125cd155d4fe4ad694bb5c6b193b8150", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "21e7694cdc734562aecc6ac73955e729": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "21f2c779a2894f5fb14606b08562844e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "21fe88256687479f8f844383549d0f6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "220019f39ff74d9c96a99a111158308e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_51c836e2b8bf4711b49912fd9aadc1a2", + "IPY_MODEL_cb0a5ac17b95490bb2450a1a5308d06d", + "IPY_MODEL_7c7c32dd8a6e4ce38e89f8f9019784bc" + ], + "layout": "IPY_MODEL_0b8152697c8944d28f92e85015834c89" + } + }, + "22170890fd8548c7b041fa6eb2064cfc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "222b35b0fa3d49bdb6659fa8f542badc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22416e43c09f4592bbda3b851294837d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a01f48d3193e4b2ba415b3436dce50bc", + "placeholder": "​", + "style": "IPY_MODEL_a391903778f14836b8587e5a1266b06f", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "224554e16d534e8d97157f543856bce3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "226f9fb5d5d74a04b9afed400b71df41": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "227300697194499aa06db0dc27cc0db3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22782be099e14414a4c615a2ca47ebd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_473e873aa2664a9e959c2a5957d91c0b", + "placeholder": "​", + "style": "IPY_MODEL_73b42a3c1d374ac585572ed9c1c1fe67", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "2278a648e91d4162b9a4e8d801d01efe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b949d52f9bd84c6bba13a96a042a6543", + "max": 157483, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c31f162026164533bc4c5dd42b3520c6", + "value": 157483 + } + }, + "228024f1797a449a817ea434b4ee4161": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0686e7b221a84e889db129879f8bd10e", + "placeholder": "​", + "style": "IPY_MODEL_0ae3a5c5bbf34b01bee72a287282e03b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "228cc3e96022456693b94cdd57106f67": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2290d80a142043b5a37f751614e537f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "22958fba1e214d76b332fb8cfe5ae0f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "22b1cd4dceb24ee6bacfdaa6c427d395": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22c8c8e0c6504ecaba18c813e860e2be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_62e77d27e54a45559d94a0697fd3f1d5", + "placeholder": "​", + "style": "IPY_MODEL_4bd4d13f782348f7aaea0e8a91dca9f4", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "22d1ba8ccb184f04b8f7abca0f06774f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_47879564557d48cfb1e2446bebf7f73c", + "max": 1713, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_97520f36c0a84b128895d61c734f42d6", + "value": 1713 + } + }, + "22d30a0f11bf438b8f4242e907acdff4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2b80552eff5d42c8932f7d1cf38804e1", + "placeholder": "​", + "style": "IPY_MODEL_dac26fd01f2c48e2bfd34d29214215e7", + "value": " 1.74k/1.74k [00:00<00:00, 15.5kB/s]" + } + }, + "22d818eec14d4e45b42b15c560cda54e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fb3a02e2d3f44228bc74919b56aa40de", + "IPY_MODEL_600549f797bf40d8ac83c3142a2a6191", + "IPY_MODEL_07ca10cf5a0b42ca88dc0d3ce46d55ee" + ], + "layout": "IPY_MODEL_c1edc767a93c47b48c51de7126bf1cdb" + } + }, + "22e582d624024a988607b3b2c0e78b0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "22e9a5ab137a44c4ba4260af2eaf2456": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22fbd71bde084ef3b8390f1c6a4507f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "23136d404c6f4cb3851b3fa4c26d7629": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "232f2bccc92c4f6585bc42266da77268": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6c1a8d21a067412a8cdae54d4266abc7", + "placeholder": "​", + "style": "IPY_MODEL_0f5d7ee51df8416a9e94eacb5a4da942", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "233325cd10bc45b186a5da5ed59948f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2338c3c6b9fc4d09881d28ccf8c426d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "234524d3cf0740b28dc145d3be028832": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2348448b75f6437d93d495e21bb64b0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2348e17119bf4c71967511fc3f3f6319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dacf28a2f6494c47a9a5b648a4b5e4a4", + "IPY_MODEL_38b1be97320d42718013b01cb23eeaca", + "IPY_MODEL_10c5c73c40004cd7a58c333bbc766664" + ], + "layout": "IPY_MODEL_44d160da54544043b4cb84f3c2f2f2bc" + } + }, + "235fbbcff07547e69d008886af740541": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "236a2d0ab9cf4eafaa1eb35f54920bc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5099a8cafa0947c5b1d71cfddbab15ad", + "placeholder": "​", + "style": "IPY_MODEL_e83f527146a0408591691927b99520c6", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "236b23882fb3471f9cfd61d966e8a498": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4c0bc32bc12148269a011f77f6e13550", + "placeholder": "​", + "style": "IPY_MODEL_b7457a88b76c48378e7b7016fc4b4388", + "value": " 2.03k/2.03k [00:00<00:00, 10.3kB/s]" + } + }, + "2379a5060470449bb7b3681eed8a92a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "23890454a63d47b2877e51e80659c014": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_93b37eb9f7684200993c00b158e92730", + "placeholder": "​", + "style": "IPY_MODEL_c44cccd8e2ab45f19ad7d271401e06ac", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "238ed969e3f34d84b291509b0e269150": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "239305e8ed50466b9396b7e7a6933799": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "23b0258dd9854c84bf363e05f22d6567": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bea9a70017a549c48261a35048c2e74a", + "IPY_MODEL_af9c8e3dd888426ea6c8705f9d35ef07", + "IPY_MODEL_f12c4e03e810468492964a35f25f2515" + ], + "layout": "IPY_MODEL_ae0c636ce5ea4de695f2b0455dd7e841" + } + }, + "23ba1666ae38442cb11fd8022bd1b48a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "23cb8996ef78407faf318b59f23cd6bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "23d0e69c4d654e85b79b1c3f9a608c35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "23d3f91f8ba64200b8bcd9f1621161b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9cfef1500f8b4752a3f2a049cc8a2d8c", + "IPY_MODEL_5be2950297e84cfc9e4e5ee7da63f5fd", + "IPY_MODEL_f9eb045af5294adba20ca72060496c59" + ], + "layout": "IPY_MODEL_c66cf75f12cb441f8aeac6c020e3262c" + } + }, + "23f603d4756d4530ab09372808d2c321": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "23f921be849b480b8a42a2aefe882b1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_03f2221e8b4041af8215197435c85852", + "placeholder": "​", + "style": "IPY_MODEL_9ecc4238df784f46a898eb74fdcefdf1", + "value": " 3.32k/3.32k [00:00<00:00, 15.9kB/s]" + } + }, + "240477e06c1441d7a61d6a5ad7b98b87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2426b583ee0f4e0cb96746ae04b080fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c4e524db2e8643ed9a45bbcf4581672f", + "placeholder": "​", + "style": "IPY_MODEL_10d1fd7a7a4b4d1795d010d8f634dbb4", + "value": " 2.10k/2.10k [00:00<00:00, 11.7kB/s]" + } + }, + "2429d742d40f45df8c3118c31514043e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2456ae7542424529b01df033081cbbb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc297997dc2a440d898fedf9c1c1f4c1", + "placeholder": "​", + "style": "IPY_MODEL_a87d6689bd22494e850c3269d29e3a11", + "value": " 2.23k/2.23k [00:00<00:00, 7.98kB/s]" + } + }, + "245d507465944ceeb95afb891d1ff8cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_32b1f5256efc4a69ba0d2369bc9ae1c0", + "max": 2952, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2e6580af62ee4727b96358820337f214", + "value": 2952 + } + }, + "24695dcd13604715ab2baeb74e158a5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_daa82228c7da48a79184961f633b0ab8", + "IPY_MODEL_074066ff916f493fb3aa744f10e87e0f", + "IPY_MODEL_f6c7c1df0af44d24a02316e43032d47b" + ], + "layout": "IPY_MODEL_62493bfdafde4c2186cecd1ec6f3f5b0" + } + }, + "246eb3ff17c44107b4d71598e4acb14c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "24724ce1fe4c4e5eb536af1a52ea1941": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cf5a1406c5a34c1fa0925eef8de83c69", + "placeholder": "​", + "style": "IPY_MODEL_0a088438234448c8ba2430d8a9d1b2f5", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "248c7cec7960455fbcfb94e69e88deec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "248eb841009c48a6baed859e30300eea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "249d3a0665f1443196e646dfdfdc48dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c3fb3ca7a7ce4c5395593d2d94f945ba", + "IPY_MODEL_245d507465944ceeb95afb891d1ff8cc", + "IPY_MODEL_412d8e6e21e34e139fb45d1cfea8cd18" + ], + "layout": "IPY_MODEL_03527945fbaa4eac8024974e837db79c" + } + }, + "24b16f8b9028486f8e5d2f982601e296": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "24bf99fb79df437c8399b1aa8edaa9fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c5c8f9e3c2d943d0af713ef724e90071", + "placeholder": "​", + "style": "IPY_MODEL_765d7f46a8b9488f8452c31d479c7ca1", + "value": " 2.17k/2.17k [00:00<00:00, 12.9kB/s]" + } + }, + "24c337a4b0f8410ba5c611b53de75f73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_038e761a75c04b119e571f9aa7d7b1e7", + "IPY_MODEL_d7cef50cbc2d4858aba263fe99c11b78", + "IPY_MODEL_4037c7f093974bdea385342226793064" + ], + "layout": "IPY_MODEL_43a8b3b81135441d845b28c92453bf08" + } + }, + "24f0f03c9ed543f8817f7bcc76737caa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "24f3302b2b30419ebf69fed24d3e79e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b51203fe043e48dd9d19dc0aea097a22", + "max": 118256, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8e94e2cf6db841b5bd55719248731a1a", + "value": 118256 + } + }, + "25083ca6d2114e60a7a2d9538ba0a80d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_08d2d59b560c4e13a3665edeaa65ce8b", + "IPY_MODEL_d7d8f5e64dd14d3b89a4fddd50f4dffe", + "IPY_MODEL_e4b1dd2d8f1644cd99738d60d9e22d32" + ], + "layout": "IPY_MODEL_c65c28fd14a449beaf200db6a9e284c4" + } + }, + "251cc33a4ed745589cc1ab0fbf1540e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee80731d4ef444e6971fcc647e28a809", + "placeholder": "​", + "style": "IPY_MODEL_05be6a564f834314ac30e5454dc2690a", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "2524750d1a754f08bb9ae7ea72d5a50a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "252e41c728344c4a8a368dd8c20eea41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_52ce6cf47898479e8079d12233f34763", + "IPY_MODEL_6c1309b2c208414cbb0482fa3a56ff68", + "IPY_MODEL_1284b5aacbc74790b657221764e66bae" + ], + "layout": "IPY_MODEL_6ab7b7c911a04c5b884689a0f9773988" + } + }, + "2541543e8ae1449b98620347fd7923f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2546157dff3a4503b825f64793200857": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_69f78556ea2b4615b5d9db47314ef410", + "max": 2171, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e5d4b85ae3d4409ebaa4c84e6d9d14f4", + "value": 2171 + } + }, + "255bb54e03cf49bb8526993547250ad3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "256c4d61caa24ec5ae2c4331b930d3ca": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2586561289e94ae1b87882f4e2f6fb11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "258a51ea90d34181b25742cdb04de723": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_29cdeae328224f05ae4fdbc6f05818bb", + "IPY_MODEL_821e93e958634768aae2763d8a5fce79", + "IPY_MODEL_bb406c47f9244eea826f96adb5e959ec" + ], + "layout": "IPY_MODEL_e8d60fed2eab4483aff596f6285d6e76" + } + }, + "25abd36934d04ef990f2ae87a5836986": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "25ad35e0d7de4631bd96a86b901f5c7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "25afe5de45b7446b89cbe4d616509a70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "25b5a727e0b9458a91a4466d74524f0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c6a44d40f573407c85757f73ca5bcb99", + "max": 3498, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_642a30eef8694c109ae5327064e40b40", + "value": 3498 + } + }, + "25c1274f6b354d429aecdc4932b0ce03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "25c762810d8a4f3bb52115adfb09ecee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "25c9c21dfb6e41e7a1b28f1e1c527e25": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "25d04a4d720849f8872d7d20f286346d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_65be78903d3b4fcf8c93e84e83535d4b", + "IPY_MODEL_9b7da3897f5e452f8c0e397dac387eb0", + "IPY_MODEL_bceea450405f448d9d03347583fdeaf9" + ], + "layout": "IPY_MODEL_aa64366f87f946549b261e13af9bda5b" + } + }, + "25d7467bf6064adea76b248d4bb9ad63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fe05932be7df4f559a70b0bb7ca419b9", + "IPY_MODEL_ffc6c50175484c81a11758d517a89a43", + "IPY_MODEL_e382cb1542d4491084a9a20874d3179b" + ], + "layout": "IPY_MODEL_c6a1ed2fa5b04cfbb497c5729640fb9e" + } + }, + "25e1771a93b2496f89633e4f992400ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d75ddc5a511549d6b0bf969e54750bbe", + "IPY_MODEL_8dfeaef78f184301a846c173ea1e5ae5", + "IPY_MODEL_eea86e3f0b534635baba9658db8bd51e" + ], + "layout": "IPY_MODEL_2d199de80477409690e3aec0cb3fd844" + } + }, + "25f092ced93a4637a70ce526489efbcf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "25f1da87cc65484eac1de8d33546efd7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "260addfd294d493dad9b0f62dad21fe0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "261436aaa85d4f5ea2c6350b9604e924": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "26175bd407004f1684f00f22bf88106d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c97c47fcc62645689f51111088f9f246", + "placeholder": "​", + "style": "IPY_MODEL_94e5f646de364c7fbf1f30011f71ec73", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "26185367b97f436f9b19d0fafa61a509": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2625f886e94d4571bf0f0942f2d85424": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cb1474c42a1146589780c70eff7d59d9", + "IPY_MODEL_cbba9078289f4cf984823ccac354dd7f", + "IPY_MODEL_9f4d6179b4f1487c9a85c9486cfd5745" + ], + "layout": "IPY_MODEL_11ba7b7efdd3418aaa64f206fc389b23" + } + }, + "2627b23cf6fa4383a2f55400030e0469": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_864de426328f449f9d440610473c9f0d", + "max": 1423, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6712761cbdf14abfbdc27869c900ff45", + "value": 1423 + } + }, + "262998e0a6704ca684bccb852f9911f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1056a54931dc40a1b8eab8b2c6af5ec7", + "placeholder": "​", + "style": "IPY_MODEL_0743eccd4aae4c96a521e49a8ab9f1d8", + "value": " 3.06k/3.06k [00:00<00:00, 10.4kB/s]" + } + }, + "263e0d2931a64689a1677db3d1785b4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "26455656569c4e10a0d3e8dd010e88b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "26594f9b919f4c3898b6ddef330472b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fb3878f65a7a4da989d58663e3d5c178", + "max": 1990, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3ddf29c034ea498db65e3c0323e04190", + "value": 1990 + } + }, + "2677204dc7364e668c87a0a0aa6c0a48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "268a460f1cb545fba4d22ae97dc1f039": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "26a584921e64496f9598a6b1027fdecb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e5e8d132aef74190a397d6046e24f807", + "placeholder": "​", + "style": "IPY_MODEL_78f8f8f50bc549c187d7f727905bd0ee", + "value": " 2.02k/2.02k [00:00<00:00, 13.6kB/s]" + } + }, + "26c7581d5da64d13aa62cefbef8a560c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_69fe305116a94d62b2b4bf2d3558db89", + "placeholder": "​", + "style": "IPY_MODEL_09fefffa623b4198b98471932f175f06", + "value": " 142k/142k [00:00<00:00, 777kB/s]" + } + }, + "26d064797c7342a293e34d9f4db16e7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "26e5bfd2134d4cfaa63069ca47768f81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5f44c6d8638c4979b8a196310914cfa9", + "max": 813, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6adc0a1b5e0341a1b4e36167f1957bb5", + "value": 813 + } + }, + "26f39471e6094e90957d17ff47d6101d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_beeb71cc4ea14bd0a822a036b37a4592", + "IPY_MODEL_6d5464b8481b4ebfa359c8c0fd89ec2b", + "IPY_MODEL_af82a4e2020a4a4c944f0a88c71a0433" + ], + "layout": "IPY_MODEL_81e317c285f7442f90919a7041f5691c" + } + }, + "270125145064487a990ec12e37a6b64a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "27296e3b0b1f4d8a9be49178319e9461": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6083ecad55114e1db201d49d9dd3d55d", + "placeholder": "​", + "style": "IPY_MODEL_5917ccde34e64a7583eef034bf838514", + "value": " 145k/145k [00:00<00:00, 968kB/s]" + } + }, + "272cd7cff658450e89b5067cdddcb3da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2769fdc4a43a4eba8d4ae133d0b46eb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "277165ff490f47ed8f3fd4141fe92851": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2796be89dc2644ae951336383bd7375c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a57c1af83a44672b166142dacc14c80", + "placeholder": "​", + "style": "IPY_MODEL_8cbf41c3c168441f92930753e9d7e922", + "value": " 1.54k/1.54k [00:00<00:00, 4.87kB/s]" + } + }, + "27c3007cfb4547bfb507425a5fa5dccb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2541543e8ae1449b98620347fd7923f2", + "placeholder": "​", + "style": "IPY_MODEL_ed01f4a481444779a5dc8f1a4cca1884", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "27c6834bb12544cd96013e3ae766a6c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "27e898c8f35d40f983584e0c4b8fb3c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "27fd6bd65b3346eab033827d79bf7584": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "281836d326fc45ddbe37f5227e533596": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "282caa93353744cb9d452a3a900e05fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28332ee9c2a14cc6b7e3d06a7378ae86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2845816f34c34e0f8cd1b328379c8634": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ce939c5e58eb4a12b9be042028be662f", + "IPY_MODEL_c43417504dad41b59ed72863f5e3ce1c", + "IPY_MODEL_47edadbc5b424d5b940adb860b1b9127" + ], + "layout": "IPY_MODEL_e9e3cd93394140d1842bf085f21ff3f1" + } + }, + "285c100ca28442e3bfaf4257e3e31485": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1d1c9a3f25b441649f29dba0b11600fa", + "placeholder": "​", + "style": "IPY_MODEL_cf6594f705a84902b05d325f85b7a573", + "value": " 1.99k/1.99k [00:00<00:00, 13.6kB/s]" + } + }, + "2872c75496cb41b088cd8f30695fb958": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_75aab476b5ff4b678e58b68b69e5f399", + "IPY_MODEL_5a134710109142c88466cbff5e7d69ef", + "IPY_MODEL_33e77e5dd8d5480b90e63bf6b319ca0a" + ], + "layout": "IPY_MODEL_00e59fce5b5047b3b1cc7065590a794f" + } + }, + "2872f962b1f34aaeab3c4f8340c0ff37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "28803969096c458bb330b971708a9681": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ff0dd85bde946cbbf9a346c4881d3c7", + "placeholder": "​", + "style": "IPY_MODEL_9dd12d42367a437c98050be5f01aeb5b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "2888a56893d84eefbe1cf640d240987f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "289cd33a4f924a20b6d013d632d1eaa6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "28a5475ef0b74555b083d323ff72e5e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "28a72aabd82e4617b380656b5fc11098": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28b00af6d24846e4a096e0780f5bfd76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28b21116f2f64931a20aa3df2d7372fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28b8c374df66454db75cd09eea67fa58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "28c82199795d4e3cb94458bc755be269": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28c8e7ce9fce4f77a935f6d527a233b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28cff1f12a7b48fba1b397c8c5d790e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "28d2c547300a470b952a0d687e30b161": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "28d4f06514824374890bfe6ad5ecc238": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "28d6dbde2749437ba0259e849c66d287": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28d81097487e4f288a626fd55d7af6f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28faba92d74748c2b9c3f2f183c5e101": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07c4222ead264808aa9901e4c2718034", + "IPY_MODEL_5f202b6ca7c048a4ab80bc2c1b2c8926", + "IPY_MODEL_5458e701fffe4e898713c59d928a4f04" + ], + "layout": "IPY_MODEL_7eddeadb39604828ab0ddad1fbd2f898" + } + }, + "291f329979914138ac28966db3f86d96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_773f789cf8014daea99bc04480af5247", + "placeholder": "​", + "style": "IPY_MODEL_3c741bbb1d144348b91e7ce97fdcacdd", + "value": " 2.19k/2.19k [00:00<00:00, 8.68kB/s]" + } + }, + "291fcc822e0340c4af9d1f586be1274a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_28c8e7ce9fce4f77a935f6d527a233b4", + "placeholder": "​", + "style": "IPY_MODEL_dfd5bb3f58364dd7970832ae45ab562f", + "value": " 1.63k/1.63k [00:00<00:00, 4.14kB/s]" + } + }, + "2933367ca72a4b0bafb85d3e9d153f0d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0731b012f54242d6bc4aefbda0362e07", + "max": 147453, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_438162ac46a84020b8a7f767e9d62d57", + "value": 147453 + } + }, + "293506a06a244a86be39a22bff78ff07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3312c13374e14530a5d3f43d38795099", + "placeholder": "​", + "style": "IPY_MODEL_0b7833da81264265b0e6ebde6966bb9e", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "2938e42558d64c4d85e41c1882a36e5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dcb6a05f4be04268b4e1bee9ba3c1780", + "placeholder": "​", + "style": "IPY_MODEL_24b16f8b9028486f8e5d2f982601e296", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "2956a54be4104633a8e31e0717d24a2f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "29609c1b85d942fc9a498fa4ab8d253f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "296a2329da3644b396755e465d4bae36": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "296e23a7b8574a1f9e49ce837a53ea08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2988dcc1d98e4ebeb367ca142ba064ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "298b2f97984f4e7b9815fb28cb4bd710": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "299d61ee09e04510a8ee5bb0ae4067e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_66f463559b9f4a829c47d3765951d624", + "max": 2652, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0063a8f61e4a4025a9d38d7d9460b072", + "value": 2652 + } + }, + "299dd21c667e4f7d84ca72906be667b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "299ea521a72c4f24b396050875a89c56": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "29adad2c196f45d79ce2a32274886abb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4b8a8675a6604520a262873240ad1d60", + "max": 891, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f6e8e6b83f9e4bc18b53e5c4e1f36691", + "value": 891 + } + }, + "29bba9a06b15494faa64699494532786": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "29bc6cef0e314f9388488a0d8d80dd2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6b5b0628c7c24f39a92b834a9e9046fd", + "max": 2805, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a002ca2f07aa47a6aef7f377e5fe8096", + "value": 2805 + } + }, + "29cdeae328224f05ae4fdbc6f05818bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_04aca085ebe843999b2d90eb181b29c9", + "placeholder": "​", + "style": "IPY_MODEL_00bfd137590144d3a2e9bafe30a55eeb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "29d24d82f4d142eab48edf91dec2448e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "29fac2f593f9455da71d90deeee71e36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dcf58967aad74f3ea9f25ab3d8abfa4d", + "placeholder": "​", + "style": "IPY_MODEL_52d57b80d3ff47f1bb5f4990a4f93de8", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "2a1b0fbfba7549618db74000497c66db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1151736d2cc443d29e0273c235d31c0c", + "IPY_MODEL_46d3048072f048a081740281076b761e", + "IPY_MODEL_b3eea6ca7f894fa6a1f9aed4b8eafc28" + ], + "layout": "IPY_MODEL_25ad35e0d7de4631bd96a86b901f5c7b" + } + }, + "2a2338468356464eb094f2272e857e4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a776961052dd42cf9aa41b4109d0e46d", + "IPY_MODEL_b9ada14843f24b4aab07b939e54df6ed", + "IPY_MODEL_093075d9c4274308a92aee467d401b60" + ], + "layout": "IPY_MODEL_c794b72e895a4197ad4630b4a6305261" + } + }, + "2a37bd9d4a624bb3a3a4e21bc71cf9a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2a41fcc681b04b2e960e336fa30cfebc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b6d30f6b81314beba915cc21e19b28f5", + "placeholder": "​", + "style": "IPY_MODEL_090d0f378cf143918de315adfc78c75c", + "value": " 2.88k/2.88k [00:00<00:00, 14.2kB/s]" + } + }, + "2a4e4417154d4f42879a7b9a158f9a7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2a5dd19b4248459b98516d0391d58644": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_30d24d4ae9f644bf875967d2df03512c", + "placeholder": "​", + "style": "IPY_MODEL_7b7d5d969b5a47ebabbd99d1909f0514", + "value": " 6.15k/6.15k [00:00<00:00, 75.6kB/s]" + } + }, + "2a6297f554a84f84a6bb76207a71c36d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2a697f42d7dc4d799d73207053a19d61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2a6f40375d9f40b49ccf6c8f1e99d4ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3c1740a208574d3baf498bc397bf0559", + "placeholder": "​", + "style": "IPY_MODEL_0ab2247c1fa44c75b4a236fe836a020f", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "2a7eb8d4e95b48528646ab74dd448358": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2a99852fac134daba955d8cda133b856": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ab546d3f9ec4139886cc78517070ef8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ac0fb96071146a9a9b8e0b3dbe57904": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ac540072f4e46de8865569a704f309b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2adf073866e24f0193516874d72bf02f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1eea6d3d3df94c50889c031338f47207", + "placeholder": "​", + "style": "IPY_MODEL_7baa110b686f4f4194335195f8931353", + "value": " 2.27k/2.27k [00:00<00:00, 12.6kB/s]" + } + }, + "2ae1b09d289c46b4946b2bc37ef6be05": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2af502fc3c774f418576b1b40f0803e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2af7ca7d91ff444682052ce41a6e3390": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6219cb3db6ef48f8a99d377d22cf68ec", + "IPY_MODEL_db43107a7bb3438082df4ce7e54c1a62", + "IPY_MODEL_d76cecf652654375ba46be482773b6ea" + ], + "layout": "IPY_MODEL_0a2e203d639c49d7a7d30970f16601e7" + } + }, + "2af893d7e46746deaf99fce6da5ee518": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2afa67dbce3e4ac58f7d47601549b460": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_04066639e531426fb56fc876268b7ec3", + "max": 142975, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_09b298f530db476cbda39f7bad22e9b5", + "value": 142975 + } + }, + "2afadcf768fd482b938ee69009aee2e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b138545a2eb4dfb915eef2c3b8130d4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b32497264b1410a8e207b47dcb1d95d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b3ea498f2ec4e648d61eafb76f50e41": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b41f6d02f694126a90807604a3262c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b547c7b6b85460dbc49c5ab5f2e6a60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2b5b5c00904d432db4916690b376a532": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2b79dc19cd2c4d5ab6c94cdd776d78e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9b71b9e8b3bc483c811f60cb971de80b", + "placeholder": "​", + "style": "IPY_MODEL_4bfd8539254f40f1956ab57814a39744", + "value": " 2.10k/2.10k [00:00<00:00, 10.3kB/s]" + } + }, + "2b7d8a0d0f334394826d1324dd86e83f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b80552eff5d42c8932f7d1cf38804e1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b898ad3842f4aeb8171698f0a488725": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ac540072f4e46de8865569a704f309b", + "max": 2329, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c7b2862db4b54568b981e8d87b6605e3", + "value": 2329 + } + }, + "2b946063ab7e45adbc813a0adc85158f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ed1ffdbe74874c81b4310d92827b4cbe", + "max": 1559, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_00fcf6c0e76b4de2a9a0e1246ebc4aa4", + "value": 1559 + } + }, + "2ba5e5e3e3964daeb35a27705a016d8f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2bb85d0bc55240f49988f7d34de73756": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2bbda55da2554b4f8312f352e26eed7d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2bbed93524e44e99bc1aea543ee4bd59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2bc5245adcd24811b1811d4cf1837b28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d76e53b527c9492887746c7ccf775d39", + "max": 2187, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f3e38e591af24a2c900e53f282c79dd5", + "value": 2187 + } + }, + "2be2407b59cb450e8aebf923edf11023": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2bea452eace24fba8526daf57ad2c8e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2c1f1510193b42c0aa2fe4a9534d81da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2c36971ca51a4ebd8cca90cda9fdb92f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2c72551ff6a84c558573331440a578f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9205b5f40e5e4f9280e6bdbbef69e612", + "max": 4003, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_29d24d82f4d142eab48edf91dec2448e", + "value": 4003 + } + }, + "2c7ce897b627497297cc024eccd9d1de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2c816d19262b4357ab9c48a42395c0d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba81602624e34f989ec8fb6fa451f8f6", + "placeholder": "​", + "style": "IPY_MODEL_9abeed165220422ebacfa4de7edd6e1c", + "value": " 1.85k/1.85k [00:00<00:00, 11.9kB/s]" + } + }, + "2c91627643c44c3685d078dd213e9b9e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2c9c1d333b36434fa07beceb0ee238a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2cdb9a56c35e4118b6f16e9a2de6cead": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2cdfb68574614d6db795e6a6ac716cc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2cea35feb6ab40b68628dbb44ca0bebe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_edff2c7792244ad5a7d95170069833e6", + "IPY_MODEL_6e315f348e044584803c2a96b8ed5e88", + "IPY_MODEL_26c7581d5da64d13aa62cefbef8a560c" + ], + "layout": "IPY_MODEL_a6fa8c20b5cd47449e10cf0d88a9ad33" + } + }, + "2cfafa28af5b48809205e3921807e503": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d01c9607e73479188aeb5e2ea0a696e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2d0803c3b23848848b792485959860d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f2d9cf991e84dbeb7f3788dfa3dcb2c", + "placeholder": "​", + "style": "IPY_MODEL_65c31e42f09644e88304e949ff005195", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "2d0cc543083b4a72bebfe2f02a894397": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f8869e7046554c63b18662c11d0f48ed", + "IPY_MODEL_58e99695a6a044d58c236093fd336429", + "IPY_MODEL_0975ea12ebf045ea9c83ab415385cd96" + ], + "layout": "IPY_MODEL_750d9e6e23c844cfb4703c6dc124474d" + } + }, + "2d199de80477409690e3aec0cb3fd844": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d1a5f85f17d43fb87b2bc800509bc78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2d317ea33f824e04900d83e14046013c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_496132b56a4c44f4b4454e2a167906ae", + "placeholder": "​", + "style": "IPY_MODEL_94f46bdcb7914a8eaa79db54df980167", + "value": " 1.30k/1.30k [00:00<00:00, 4.85kB/s]" + } + }, + "2d40b96af29c40e4a626986312431924": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2d4253bbfd284d69b2ffc1f78abf6d93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d65710feb964e83817a1b9b762842de": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d8dc6fef40a4348a58158897fca6036": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d9d62e0fedc4bcdaa125402cff05beb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3306a773c79a4c088797c8f22ba957aa", + "max": 1563, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fb94a555a86c416589f920e0ccac5eaa", + "value": 1563 + } + }, + "2daa6b90a16342b7bb772fa5dddb0bb2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2db0a6ae9deb45a5aac16addc6c4266a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2db67eec0b454d27bd8735d48d5b0ca5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_786687e380f34f7bb4ce3d4b02f42c9b", + "placeholder": "​", + "style": "IPY_MODEL_7a99c9c0f0ae4e9e9413e0ee205a44c3", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "2dc505121965487093630a4be5d018c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3353fe2b36794a3cbfc0ff9536a931ce", + "IPY_MODEL_cb734c170b1547a38f5c33fb55f3c172", + "IPY_MODEL_5b339ba471ae4b5394df968905773080" + ], + "layout": "IPY_MODEL_76739e29d0f84bcc8e9ce68feed13dc0" + } + }, + "2de1a01f1593448baa036c0038da29e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2de7de1b8a914752b1c97a2bfb53e6f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_93bef73d1e72479392d09a6851573411", + "max": 1559, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_53ef3ff1ba6a48d4bdec7300669e98e2", + "value": 1559 + } + }, + "2e03abf588704310a3070ada7cbf6184": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fbae80a65d3843a08a02130cc6fe24a7", + "IPY_MODEL_c04d72b024404853b78a6f88f2a42f19", + "IPY_MODEL_61e8fac6a936465f88e16e504e701608" + ], + "layout": "IPY_MODEL_6b8c318a542544d183c9770aa8a1b57d" + } + }, + "2e1c49fe79664b75a6f8e080b5d8a68f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e4d2c29c561147668ed69e4a6bb49405", + "IPY_MODEL_2de7de1b8a914752b1c97a2bfb53e6f3", + "IPY_MODEL_84e401d1e07847ae9d139550f7852560" + ], + "layout": "IPY_MODEL_beed816c63764d22be2fd53a45dc039b" + } + }, + "2e2434101a9a4fc5a86b10b032225abb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2e5d71393af14089b17c91aa98befde1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e6580af62ee4727b96358820337f214": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2e6ab02d05b0443b9415efa72c062ef9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2e6ea7ad61f14f809867e5eb361cb599": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2e7ef0c7c9bd4440b798d275b0a3a99a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e86b2bc2538477f9d26628a74e8f2d8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e9337c241b046a0b0f4825fbbc07312": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a71b6719da294972b3939d1efa445a77", + "max": 970, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3af8e2ead8ef4bbd9918900c4812e974", + "value": 970 + } + }, + "2ea89892c44249e5b119d03c5b1fbf0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ead3577b8bd4b8d840acd89c1d180ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2eb123b83bec47a6bb97d9d2dff98f54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d1284fa44f114d7c85d3cb3ade21dabe", + "IPY_MODEL_8536b6c3bb3443fa8b8c5245489923df", + "IPY_MODEL_dd4f54b7d2b349018f0f57ccf6552c4d" + ], + "layout": "IPY_MODEL_5f795abac98042d483666cb15677d899" + } + }, + "2ec4fa3ec68242d69e69a07ffb6f527e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2ece4a4a4dfd4f838a78ec2f7d8c4ec8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4cbf7b34bc44d85a82bc4c3b52fd6fb", + "max": 1370, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_42e7067a658b4a608ad415db72bf2b64", + "value": 1370 + } + }, + "2ed3075fcb3b4488b67249ac8cf2973c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2edc5afecfb8419bacce3987b8edebde": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7fef0e8cb4ca459193463f078b96aa90", + "placeholder": "​", + "style": "IPY_MODEL_e3133c58668f455ba66f11b91065a250", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "2ee9236490b34d2b8a5341a8bfcdba0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2ee98abecc284970852f3d6b47005866": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ef1bf1c12f74d14a047effd50899693": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_07a85d77fc114188905d5fa8576ddcf5", + "placeholder": "​", + "style": "IPY_MODEL_488eddcb7e83443fb144aaade4da9993", + "value": " 3.38k/3.38k [00:00<00:00, 13.1kB/s]" + } + }, + "2efa4eda841145609701202580d7d092": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f027caad461464e809c92e22c3066c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dcfd39188f28408481579f4d77217fb2", + "max": 135392, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_36b89b9b4a8746cd959c66c973f42a35", + "value": 135392 + } + }, + "2f0b7953946742858fff8961bac868bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2f247ba83ad64e42a9418f62232851b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e2228a2757b149fba2ee743663d5ce7c", + "placeholder": "​", + "style": "IPY_MODEL_59fa4041a9a1428a87b0335971500494", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "2f28716184a14cfd8047c22aab9c7ba0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f295f94023c497f99b38f459b9b128b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f39ae23b418414faba5426738840f98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f51ed752616490692bc16349142cf1e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f608e2e50d54796a40b49873c628214": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2f6937a6146f498098f7097e88d6f0dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f697746d845482c9833b58d0bd2c2e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2f8ed28d5b4f476d9a5ccb04a96d62b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c0c64543d33b4c148925d71162600e44", + "max": 2953, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_69162d774b314276b2af6a0d7c4629d4", + "value": 2953 + } + }, + "2f932d6b4f10499ca7c2bfff0f38c4f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3b3e93e1b13249f29a0df92451703fb8", + "placeholder": "​", + "style": "IPY_MODEL_4fc26cc72f8d4814bb99e441859e0ebd", + "value": " 2.22k/2.22k [00:00<00:00, 13.8kB/s]" + } + }, + "2f97516aea3b429da88a0755b7f78d51": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a5bc081e479d4933a2e0c3f8b31095fd", + "IPY_MODEL_c7dcff06fa2f41edbc53d69e7f26b369", + "IPY_MODEL_40406212f0e54b448b140ad9bbcceb34" + ], + "layout": "IPY_MODEL_5bbf9d20d5184af5add18b48b71de85c" + } + }, + "2f9c7e33374a4e1b93ab203d20608b19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3158de407efc47c0a2ee740f89c60d14", + "max": 2047, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bbda0fb504b24aff98a806b32013f512", + "value": 2047 + } + }, + "2fa9e5073bc84216a2316823ef60ee1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_44f149fc1c9a428d9a174b30652540ac", + "IPY_MODEL_374327aab99d443d8891c779809e56a1", + "IPY_MODEL_954915abc01f40f2b79e9a2b19a101eb" + ], + "layout": "IPY_MODEL_c0b54bcb1dee482584d66e5a0e8e8e99" + } + }, + "2fab5ec9afa5401e86949055b4975532": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bf02cdc273034377b9036a0ae032084e", + "max": 3052, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_12e61a84edbe405698ed3cfc5278a82f", + "value": 3052 + } + }, + "2fb9038e268f41c8ba35f105dca72309": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2fbcca2b075540c88404ceb12a66f16a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2fcd8b40aae64e6bb77fad3ebc4977c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2fd0454e84584fe5b73f90adfca0b1b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2fe11668421548e7826fdda090bc611c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4187baa7916a487dadfae97e73e4dcf1", + "max": 3786, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f69e2da5892643538822f3fe2fc0b33f", + "value": 3786 + } + }, + "2fe87d9d3e394affab458e4ab11b857c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_42410217266044a59e67224fe86eec91", + "max": 935, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_331271a515b149c088a34046a75ecbb1", + "value": 935 + } + }, + "2ff0dd85bde946cbbf9a346c4881d3c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ff42df4b5e74285945d7a2db9631c92": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2fffeae3cc1849058fae93a3b26e6eb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "300c9f0edbbd4449b5c0cba786f43e4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3013fd4dbdaa4853863607e930c7d15b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "303251d376e94c3fb151b018e1dfcf00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_41bc97cebff84903ab97e1a33c1783e1", + "max": 2988, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ab5b65f87996409b88467b9484e14c82", + "value": 2988 + } + }, + "303ab718177d45c38a8bc94eb7642062": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "304776a9e5c74c65a396c3763beceb2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4809ef30ff6742ab85bcd224ff5debaa", + "placeholder": "​", + "style": "IPY_MODEL_7260f2ba12d345d1b35ae29b6c568a17", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "305965f954c243bb9ae0387fc91545bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "305c85559af84ac6b305cefa8f396f55": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "305ce59f87a043d79cea5b6d48a0a8b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "306052b12a474819bf59c39eb66572ef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "306e3b27f3cc4970bea29f1014f2be76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "306f884b5abc4b188102dff436a3668b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_834b5ef4d54d4c9c9084802ad8d63857", + "placeholder": "​", + "style": "IPY_MODEL_76e37ab3a5bd4f10a557f1d2cfaa9b5d", + "value": " 1.34k/1.34k [00:00<00:00, 5.80kB/s]" + } + }, + "307615d7141e455bbfb66d13fb310154": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "307aa3d7469f4112a18a050aaff066d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6bdcc8df24a344e19ff748a75b56a20b", + "placeholder": "​", + "style": "IPY_MODEL_ee26360c9c314a1abcf46756072d1596", + "value": " 145k/145k [00:00<00:00, 697kB/s]" + } + }, + "308a718700bc447ab3cbd7c15738c7c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "308c9ca0ae8e427e88ab81f3fd3bde52": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "309b0a3536d14acfb74cf87a90fa6adf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_61f32d8a4039447e979c54b2295550d7", + "placeholder": "​", + "style": "IPY_MODEL_0dcd26a514844fa78a47552600bcfa6b", + "value": " 143k/143k [00:00<00:00, 832kB/s]" + } + }, + "30a8dc26cc414d32a9fc900292c42eca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9173cee6a01b490ea02519f0e871df5f", + "max": 2454, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d71b1be9b7794ef8b9465cc02f44316c", + "value": 2454 + } + }, + "30a94d2fde1f422caddc3e9d5beed999": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "30b16fd52b694f609d81261744b885c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "30b5325eb02d43dbb5c99e253bdf450c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "30d19606a69c4abda846379b3bcc6aab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "30d24d4ae9f644bf875967d2df03512c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "30e35ed8d500492fbad1b84cb19c50a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_045a4140f22c42b1bd2c5d5622f410fe", + "max": 150113, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b5c0e68b7f5347338a5098b5121c7088", + "value": 150113 + } + }, + "30e4d22a693b40d1a8b8262fd31b2718": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "30eb693998e14aa6ba7f572d0c90aee8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_34c478dd7f9b4e0eac8c409e8d629e42", + "placeholder": "​", + "style": "IPY_MODEL_ba3d6a45b7d1447da5a7dd3008e6a78b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "30ed1855a669469d8fdfca95da2cdc5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "310398543ccb46eca6e441627b9039f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_011af9b4345b4b608ab10c97d50f8fe7", + "placeholder": "​", + "style": "IPY_MODEL_3bc953d0805d4d8aadf2f2aa6079ba2a", + "value": " 152k/152k [00:00<00:00, 710kB/s]" + } + }, + "310dc5b11cf641f29a6b917f6eb84473": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eaab736d30a04ba39cd46cc0a4b81e3e", + "IPY_MODEL_840d1ea506e04da582e0dc9440dbf887", + "IPY_MODEL_0cafc9fcf7f0421fbe68ac75c7aacc25" + ], + "layout": "IPY_MODEL_8af770be580b4f22a0e336618b74b2d2" + } + }, + "312e855fb1e84c598931d320294e9ee5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "313dcca04c6c4017a97fe4911fee5c79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_101dbafaab884bcbb83129e49a53c160", + "placeholder": "​", + "style": "IPY_MODEL_92a6d8efaa6f4884ac134bf478feb39d", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "314277095d02468cb3d0ca9b865c27fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3149417ba1154c2f8c8a88f76c2bcdf2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "31526e89cc614d5cb3e1dc81e4e49e75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_532fec3817fc4d36bc629d7dd7901aa8", + "placeholder": "​", + "style": "IPY_MODEL_c1883383a9cb4b9fa877803c398ead1f", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "3154bd527b164b8cb905f05394ee8655": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_de7aa6a765c54d18809a8a2b58c7e227", + "max": 978, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8c6b361a467b43309b04ea439aaca093", + "value": 978 + } + }, + "3156fc135ee340189777ae16e5cdb656": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e5a84fc09d3640f89cedad955b2d76b6", + "placeholder": "​", + "style": "IPY_MODEL_0512cef102804865b429053f277ba2de", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3157678fa08c4bb2a3845a1ae539513b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3158de407efc47c0a2ee740f89c60d14": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "315b8e7898e841ee8f3282047776acc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "315e1258904e48ac96cdd61ee5d0eb5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7eca41f469be4837b4495b3670d73085", + "IPY_MODEL_c7d3528c02ce4ff684151ede09caf8d5", + "IPY_MODEL_6cb592b93df649f7a4b674c15d79d040" + ], + "layout": "IPY_MODEL_c1b67442a2fa499c9c350c4ba4720b51" + } + }, + "316fe2d241c044caa4e2e978aa6f59e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "317e868ad8b24929a821ee591b79bff3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "31872f527cc24a54bb3e4a8a1dcfe1ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "318a3fe74f684821837b4ffeb21b498c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "318cb834d4734bb086fdc375530d1815": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7e81d47b4b98495b95f4a3ebf57041e5", + "IPY_MODEL_db89e8927d504b21a9a19be41d3c3df4", + "IPY_MODEL_990574d93c8647159e779d4d1e1707d8" + ], + "layout": "IPY_MODEL_435be3d913d44d76ac2e4bad9b098000" + } + }, + "319a0e64bf8546ebacb08e062804999e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "31bd8e508c594518863f5f95dc2da5ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "31c1fe29135a4952a932319fb1081d29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "31c9cc3339964c8dbef56067c6c4739f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "31df61ce9c8c46e3857e0e896827c7f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "31e06f03299e4050b505459494825ba5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_162337d9099f466ca8077337d83de14f", + "placeholder": "​", + "style": "IPY_MODEL_6791eb896e33449da6339f25b8cb53d3", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "31e10616feea4cf29a9778c20b25b83c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e1fe4b4a84664e30878421461de2c648", + "IPY_MODEL_f381ca2255e44a369fd910f66828870d", + "IPY_MODEL_dcd603d32ec64a018111d189002008d6" + ], + "layout": "IPY_MODEL_de34c19800154cb6b4ed11eaf33f65bd" + } + }, + "31e27e1ffad242d990950106aaad2fa2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "31ea8a97fb354507907fa43f89d4fcc4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "31f8516600844de38d00806d681ec637": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a0214609e2944bbb0ff139743ba59c1", + "placeholder": "​", + "style": "IPY_MODEL_d63cdad1d350479599cecd0c72944e0c", + "value": " 3.06k/3.06k [00:00<00:00, 8.20kB/s]" + } + }, + "31ffccf70010499d8118657557ccdbcd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3209b373f0644967a85a4bbe48121c8b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_47e262387932429fa15091c7d4b6e172", + "IPY_MODEL_e75700e91b904c1ba0b1bb99fb896fa5", + "IPY_MODEL_8bf3cca4f4764c768ae911906e6d9e70" + ], + "layout": "IPY_MODEL_b3dc6a8387214a01a06114794d703c9e" + } + }, + "320a2b54e114488f862226880aaa3556": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1af2fa67eba649d7abaf974d3a0b4dd5", + "placeholder": "​", + "style": "IPY_MODEL_e8a354322ca143f99e2f5f5b31433487", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "321d53e2bb8943a1915b5b1abddc37e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3222b784a177433a9381e4ef6076e1e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e46f30686e834ce6aad604bd011eda88", + "max": 2075, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9665eb39255048768c65539713c4ff7d", + "value": 2075 + } + }, + "322cba068b43445da720ab435e25a025": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a1b7c1fa4ee2409eb018358e0ce3403b", + "max": 1797, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3d1648b39fcd42c9abdab05591613688", + "value": 1797 + } + }, + "3241b47c4f574eacb60a9ee090ddc1b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "324bcce13f5243e9aeedb977e09a70e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3253d01a37d646ce813a9fb3e8775100": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2fbcca2b075540c88404ceb12a66f16a", + "max": 137798, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_536a47f5292d411c9ae5a32e0abf731e", + "value": 137798 + } + }, + "325d6ff893a24d28bb361732dd77e157": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3275d7968d50450382296ee73a829610": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9e7e37bee25549c3a78e377071c185ad", + "max": 1544, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_da2c53a00d6248208f9ad345e75aa150", + "value": 1544 + } + }, + "327c865e595c4115a458fe48fbad34d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b6246a96d8274da9a3059264071deed1", + "IPY_MODEL_f4e7a76de1084654a2b43e4261ab7d7e", + "IPY_MODEL_ba13901a13244c8c8ca5ab418b0ccd1d" + ], + "layout": "IPY_MODEL_359b94b5beeb433590f86163c61daf98" + } + }, + "327db7ee8da94e6ba7cb75147dad025a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3283ea2f3e2d41c4b049f90a407a2b33": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "32881cdffa414f62963d7160c150d64d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "328ea46ca111434ab75bfaa47b7849db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "32a7046f3a7e48838ba13459aacc5313": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9501dcf5ba7f468ba960d110073601a8", + "placeholder": "​", + "style": "IPY_MODEL_752e5e49a1264055bc6b9fe9724163a7", + "value": " 1.97k/1.97k [00:00<00:00, 13.5kB/s]" + } + }, + "32b1f5256efc4a69ba0d2369bc9ae1c0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "32b81290db4e490697d3e6fee9b14284": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "32e63d065fe242ab84dffb2b091cebc6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57e9b783d57c433ba4b60ba757f5b41b", + "placeholder": "​", + "style": "IPY_MODEL_9884f5c62dae4fe3848d6a39ef1bf8f7", + "value": " 3.90k/3.90k [00:00<00:00, 19.6kB/s]" + } + }, + "32f90de9b6784b668e2416863fe7d73a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_868073bddc93429caf7934743efe25c5", + "placeholder": "​", + "style": "IPY_MODEL_2db0a6ae9deb45a5aac16addc6c4266a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "33005ad7c95c4ae19d730511515ce3ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ab76df5b65164a41b1d4557f96256969", + "max": 1789, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_51adf2bb148849ddba8fa5846232bffe", + "value": 1789 + } + }, + "330677bb089b4de0a5e042b951a19530": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3306a773c79a4c088797c8f22ba957aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3307e51a65054c178d9fc1bf35674e5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f97c7271fb7a4a7395aec1ece6bd2ecd", + "placeholder": "​", + "style": "IPY_MODEL_66cbc290a945499f9b5c588a523e79a9", + "value": " 1.95k/1.95k [00:00<00:00, 9.51kB/s]" + } + }, + "330ebe837dc64bb0a375841a0ce3995a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3312178f4c0849989ae23210290b610e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9a60a37ca06647e2883e120a2bee3ab6", + "IPY_MODEL_4560318535144b798e48bd2b07d5028d", + "IPY_MODEL_f35925448f18409dae239d975b35428e" + ], + "layout": "IPY_MODEL_5ee09fac68214fcba29905f6879802b5" + } + }, + "331271a515b149c088a34046a75ecbb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3312c13374e14530a5d3f43d38795099": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "33186e4d4f8849bbb72359af05c470de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "332351dfd9e34ce7af174390cdcd4413": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c0eddbae201345169cc00e0f9ffb2a15", + "max": 1754, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_19efeb4e0643415d8d2d18e95bde47cc", + "value": 1754 + } + }, + "33300317fbb2487d858665390308900f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3b61e3222e664da8a07f3b40a062eb6c", + "placeholder": "​", + "style": "IPY_MODEL_2e6ea7ad61f14f809867e5eb361cb599", + "value": " 4.74k/4.74k [00:00<00:00, 23.4kB/s]" + } + }, + "3331a526ab3b41c3850e94e878412fb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5dde841620a94cb6a70a266a3068b09b", + "placeholder": "​", + "style": "IPY_MODEL_d1b4c13f70fb48ed9951c0ec1746e189", + "value": " 142k/142k [00:00<00:00, 859kB/s]" + } + }, + "3331f960e2554a58a8c4c821e3830b81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6edba4d41eb3486abef33582a691ca66", + "max": 1669, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_560a254824d54ef78445f527240bdaa1", + "value": 1669 + } + }, + "3333c904bc614fd58af32cea35e4eb5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3343fea86deb44bb99a99cdeadd2834b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3344ba7c5e1a465f85ce6970a0c26053": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3353fe2b36794a3cbfc0ff9536a931ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a2ffa1cfae24e9a9f83fc391b67a9b5", + "placeholder": "​", + "style": "IPY_MODEL_433e52b219bf4d158697d2c0db6889f4", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "33649289a7c849269c006483034e29d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_50a62198db294250b20fc4b8184d7541", + "placeholder": "​", + "style": "IPY_MODEL_4d6c716a52224ff689766ac016c5340e", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "336d8783dbee43a8a1719436ea5cfd98": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7cd8e9e55edd4721b4e64d4d130ab3c6", + "placeholder": "​", + "style": "IPY_MODEL_93c5915fe8f7422eae68f5d969b3b661", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "33774bf85fc34c58ab1863b9e4490aa9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "33790b43e6ee4bab8b98946fecc164d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0f73cbb8687747b0bd12ad3402b3b2f8", + "IPY_MODEL_01e0b362822b4173a613a4922de2402e", + "IPY_MODEL_9a7c4ee9306d4747af4634d9e6742116" + ], + "layout": "IPY_MODEL_8cc19ef478864f7cb5537361e7d6b595" + } + }, + "337acd01213c4f589388761ffc1e5dbc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "337c545ca77142dcaeb594986cd07e55": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "337f2d6c4c784b44b63e6c8083839a25": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "339047f777524df1aca522fbb12dad5d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3394fd0798f44cca8b62515ced46abc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d5431356f56241e5bf80fbc688c41f73", + "placeholder": "​", + "style": "IPY_MODEL_ae793e432d89407cb4d60d63dd71094d", + "value": " 3.46k/3.46k [00:00<00:00, 21.5kB/s]" + } + }, + "3396553af5314d76a23081b011211368": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "339b5448aedd451a8d8ad56f5235c622": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f460c4cabe8f4394bc32d4a4d4cdd503", + "max": 162219, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7ed025af4d5a419dbd5aebacd56e7c5f", + "value": 162219 + } + }, + "33ab172994714f3e951bc04a7c9bab38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "33b66c93090149d1bdd0ce822790c9d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_63bcd9cfb68f420dad3441141f0f7e16", + "placeholder": "​", + "style": "IPY_MODEL_789f81733f4f4df7bc784ec7485196c7", + "value": " 3.12k/3.12k [00:00<00:00, 15.7kB/s]" + } + }, + "33b98f31fc1b4af3afcbf8672d5117e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "33cb7fe4a48e496b85bb3c57382e205f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "33d9865edbd64042a3ad8e3ce0f38b92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e185024beecb45ecb18040e8510a74ff", + "IPY_MODEL_39e286f6b31e44c7a8f743e1991bc5b3", + "IPY_MODEL_04019b06fefa451c99c1304970ce900e" + ], + "layout": "IPY_MODEL_e53b38b077cc4915ad322576737bd316" + } + }, + "33dda4c88af7439fb4a0e9b6b2fe40e1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "33e48a7bfe2045daa8fc155ad02c745b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "33e77e5dd8d5480b90e63bf6b319ca0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cf714f31bf274847bbea87b92085aeff", + "placeholder": "​", + "style": "IPY_MODEL_4413cc7eb0d0488fa888cfa2ee3ce782", + "value": " 1.70k/1.70k [00:00<00:00, 7.21kB/s]" + } + }, + "33edb298f9604693a5bc2f607df99f18": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "33f0044773aa415dbfadc1810b030709": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_373651f783ee4e398997fcccff71432f", + "placeholder": "​", + "style": "IPY_MODEL_889ff6601e5049018f0c8dc30865e553", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "33ff7fe45e2a47329cb12ef9ac249df4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34019e82be8e4a329d4f4ca39a84c097": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4aedb5520fb44ad6a6e85eaa1440f59e", + "IPY_MODEL_b48f119dc0b447b697a4e125d7ce0b36", + "IPY_MODEL_9fc21c801323478f8ca9abb4e4b53702" + ], + "layout": "IPY_MODEL_20ecf71d76ee4f47a5a35fc647a1fed1" + } + }, + "3405f2201b76477e85098222c37a7631": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d24ca3cc2e3a4480bcafa2b1836947a3", + "placeholder": "​", + "style": "IPY_MODEL_9cbb5ddc1c944376a804104a984f1798", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "340d7811de76421a88b366c562567a30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "340f2d7564764d05a3187a42595701bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3411aa885bbe42ec9d08f48074be56fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3411f48b35124e35a0fdb043fed644ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_23f603d4756d4530ab09372808d2c321", + "placeholder": "​", + "style": "IPY_MODEL_6f3ad09c51804abd8c82ecfa0828bcb7", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "343300d2ace44d4b90f69af11c885fb7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3446c3fd1d034cc8b3ffeb5a879e0078": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3449ffecb5ea41a6ada24f0cc3b1eadd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_08630dfc9a3b4310962f41532aed871b", + "IPY_MODEL_9c96c6bffb7044cc83a35cd821bd84c3", + "IPY_MODEL_5b0913f2fadc4c71b8b3d9ad616404c8" + ], + "layout": "IPY_MODEL_b7cdc2cc94bf48adb73b4c6cfb34d046" + } + }, + "34561586d71645a9aa9d0d48fc7845b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3462c6e8ce7147be80ae364a4c2baae8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34650cf096c54f4d9fe62ee91189eac3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "347f78967020438f88c087f58c517084": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3482b2e3056741939e36b9a584849d41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1f7cabc393874db28399dbfa0f0826cd", + "IPY_MODEL_303251d376e94c3fb151b018e1dfcf00", + "IPY_MODEL_725860cfcdc8462b8381a373a2afabba" + ], + "layout": "IPY_MODEL_7ad5e26c5eae4c4ab10eb921297c75fa" + } + }, + "34920cf0c26e4b78a71545ae3f7cc340": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8e2daa3c5a3f4e579aa486bbf41da2af", + "placeholder": "​", + "style": "IPY_MODEL_f56402c312134ffd8354bff7a29a2767", + "value": " 2.54k/2.54k [00:00<00:00, 15.5kB/s]" + } + }, + "34944ff6bd5d4566b7896bd69012ceb1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "349facce7317406881291744c94e2ede": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "34a6b2bebea04eb78d48dcba0db0aeb0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4ec977da5f6424d9bfa8ad72d7f51e2", + "placeholder": "​", + "style": "IPY_MODEL_ee622b7999434b33aa45a3acb8b53c80", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "34ac847199894936a75d67574df36ce8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34be74f58bb44f6e8d43e58231b13410": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "34c3b2b0e3de46899dbd0c4845a545cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34c478dd7f9b4e0eac8c409e8d629e42": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34c692e1885f42978284204550f32a27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "34d3930e329045e99ef5946ade634191": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_712250b09e3241d6a3cfd19e7de50ca7", + "placeholder": "​", + "style": "IPY_MODEL_902cb54088a545a3a01bacff53cef592", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "34d71ca3f5a545b7bd7aa1fb76f64204": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34fa9e32df16450e9de6a0014778b54c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3511a3898e214442aed0aad677eafaa1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b96609c9a1484c6fa152eea60542a0bb", + "IPY_MODEL_fb2120d753174f9dbf31d6ab83e33310", + "IPY_MODEL_0c15df6db08a49cfbb3dc59768f29a1a" + ], + "layout": "IPY_MODEL_e6bdb25c4fa845b79b0cc3555be9caa6" + } + }, + "351e7b77502341989b3a2a5701864a8c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3532c2f5622b4a07b8fb8a9982fc51dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "354034acff074fac9b59985826d15ddf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "354fc524c99e422e924352cf4381e67b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6937878ef8e74d359a30a3ef9c42bb5b", + "placeholder": "​", + "style": "IPY_MODEL_667b72e9cde040a48c8c2efe3afffce6", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "355e507ab5b24a0baef6d306863b4ff6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "356e5e0a07da487f81a2e27824b952be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3573fe5ee5b5458d8012a482eeec2921": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "35960053b50a45a2901fa5fb534eb10c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ba5e5e3e3964daeb35a27705a016d8f", + "max": 1785, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bff84c29edf7421db8440f54b2ab7758", + "value": 1785 + } + }, + "3596f3fc3e4e4520bb77ca50c73a05db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3598c403c95a4677863b3de068705e95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_47864357e79a4c5682b7854d769919e7", + "placeholder": "​", + "style": "IPY_MODEL_c529cfdc7dad4dff811298bb138a8b97", + "value": " 2.27k/2.27k [00:00<00:00, 7.75kB/s]" + } + }, + "359b94b5beeb433590f86163c61daf98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35a3398182754026b9aa3628d9274699": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35ae88dafffe4c7aa944753177293dfd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35b0bebb6e964fec96b3b7d2c5273224": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "35c3383d0460405a85bba462748d9500": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35c57cb752c6483cb976829eb5f7cbd4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4310385bf54c4b6690336c7b5d9a832d", + "IPY_MODEL_d8713724803d4a6b850d2afceac5d3a8", + "IPY_MODEL_d46d0b45d75d42ae80fb0934df94839f" + ], + "layout": "IPY_MODEL_d466ff71e3284ed0ad4bb17e15d02f6c" + } + }, + "35c6ab0410c645c28736de1d29fc16a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f608595e3ca841b8a098f3851b225b7c", + "max": 2540, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0a2d894bd10d429bb045be2b420e7b1a", + "value": 2540 + } + }, + "35c910c4b7f84df8a77485cbab5016dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "35cb4a907ad94715820b0203e479ca84": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35cd36691ee1402eb35aec00b2119089": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f5a5c524ed754546b3ebd6c1f0e4ec84", + "max": 1889, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_94dfa312dc4e4016914715be97e96eba", + "value": 1889 + } + }, + "35d57dedc5bc4ae8934508afdddf6ea4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35e92d1331af4da5911c58eca55e71f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c7e90fd7f8a040888ba3b9d23a5d871f", + "placeholder": "​", + "style": "IPY_MODEL_74136606b4eb4ffcb008c76126920186", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "35ebecd771cc457785de57f51447bfe9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "35f4d899d0184802ba0f0f5106e029ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_476cabb54c374153b2ea2894f3b0537e", + "max": 2562, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0aaf118326a644979ff7e6e8545132ed", + "value": 2562 + } + }, + "35fe5d53193744b3aedf039ad424cfe8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3c1a0dac256744389d307ad3bafaa239", + "placeholder": "​", + "style": "IPY_MODEL_33774bf85fc34c58ab1863b9e4490aa9", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "36151590171d42adad3b2d4bf8257405": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ebe957db31004ad585f3562a047ecf57", + "placeholder": "​", + "style": "IPY_MODEL_3ce6c1e89de14e5da9c77d2b6951959e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3617e2497f04433ba523a3712f70d6d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2e7ef0c7c9bd4440b798d275b0a3a99a", + "placeholder": "​", + "style": "IPY_MODEL_61ed9b87ecb8447ca5f0dfa115bb7959", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "361cb9d02579466a879634e6e48cb166": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c6c75944dfa54067a9e441f8dd1094f0", + "placeholder": "​", + "style": "IPY_MODEL_41d3fe863acd4f8a94c5e31a351d9b4b", + "value": " 1.33k/1.33k [00:00<00:00, 7.08kB/s]" + } + }, + "3626969f7b9443a7944bfd0c8914865f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_234524d3cf0740b28dc145d3be028832", + "max": 2174, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2a37bd9d4a624bb3a3a4e21bc71cf9a8", + "value": 2174 + } + }, + "362b418191cb4ef39f48f158c37b5fbf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "362b9658a2f3422ba4c06833f75720ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_48393281aceb40f6a8828238da938975", + "placeholder": "​", + "style": "IPY_MODEL_94a2f68fa81a4fd89c739fdf581e9ae1", + "value": " 1.96k/1.96k [00:00<00:00, 9.84kB/s]" + } + }, + "36395b69afda455c9ff2a8657f3055db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3641147b07c84194beb19387c6367fc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5f8671ec39464a4eb30299dab61e2238", + "placeholder": "​", + "style": "IPY_MODEL_a5117978191f4af39346b7fa23bf0134", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "364f72a7e52144fca869ea16333285fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3654a9f4d1c94faaa26760ad8a3a7d70": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "365b057f59894c389413086bbb5f7b54": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "366b2659634249a1bbac4a6b3f08b536": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_92690e94b483488eb97cd09c4e281c75", + "max": 2111, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_435b1de4ae2e4156a1dae17237a2c366", + "value": 2111 + } + }, + "366e436d9aa64e25b04a107bd5125f36": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3674bf7d213148ce981bebe073794ae8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "367f0c5a38b64ea0b614bbe3ab980af2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3681ca130c1d4c969d94c1874099b944": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3690d1da40a641038177840ae59cc26c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "36974fcc3a144ee4af4e14a01debe248": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "36b89b9b4a8746cd959c66c973f42a35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "36c6f76b464d4d3093431ec484d8082c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "36c6f85037ac42fba9090f60a8c44c4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "36cb7e27b4064683ac864d593370b3f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2191f4bf3d94490b83fd16472d19b276", + "max": 1607, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_62da587b37d64390a11e1a9bc8485c02", + "value": 1607 + } + }, + "36f08cd351b84b09a97523210806c501": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "36f39723938d474ead365ebe84a8265f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "36fea20f190548158155512e23eafea5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c27ceab22e2e4983aed6df11096ed3a5", + "max": 2288, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_acd3e110bd194760be3740bc9bf4d30a", + "value": 2288 + } + }, + "3704e2768da445518ea06c00cee952d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "371365ea7cc842d7bcf4da790b57f7b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_05578816a79f40519361ccc76c353cb2", + "max": 2208, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e176b267c6dc49788610b090cb960c48", + "value": 2208 + } + }, + "371f3e47232049b7aa0e251147937e0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3723a056c809460493125ded54b79561": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1323a713484e48dc8da42263c60c7ee6", + "IPY_MODEL_bcf32df668804a8ea521169f30cfad42", + "IPY_MODEL_d3c30112a6404d3d923dd494370b9bae" + ], + "layout": "IPY_MODEL_0eae6c5d58e54a27a328c725098c65f0" + } + }, + "372705c704964458a65732e506cec9b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3729ec65a3e24fc5acaf34612f06d71c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "372bdf4c92534edc8747e44a1ff1b1b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "372dbf911eb94d1ca3d52eb8a385a618": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a653d5f9da5b4908959e54cdb4eb2b27", + "placeholder": "​", + "style": "IPY_MODEL_b35c07cc8db2420e866669e084bfbb90", + "value": " 2.89k/2.89k [00:00<00:00, 4.62kB/s]" + } + }, + "373651f783ee4e398997fcccff71432f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "373ae998d515477dabe1eb536dd58624": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a2cfcc6b864c4a4bb2a2b3247749bb3b", + "placeholder": "​", + "style": "IPY_MODEL_19ba9f6d11d946ebb33dfb36164046d6", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "374327aab99d443d8891c779809e56a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_131fdc5d0ec348e1b222be6f98d9b2a9", + "max": 143807, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fdbfbab8564e4fb9aaf0428f5f66c4fe", + "value": 143807 + } + }, + "3744de67f6f24029a7ee98b0001c291a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "374db19fe5784b4792a29bd3fade7c68": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3750564167db437983314aafc19e3cab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "37535a76ece84341ae1ea7fe8a275c5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_313dcca04c6c4017a97fe4911fee5c79", + "IPY_MODEL_cb687ea1b5d34f0da0e79667f19fe48d", + "IPY_MODEL_d7acf9e837e14fd5983814b71745ed42" + ], + "layout": "IPY_MODEL_a62f11e173bb4139892844e679b9d6d0" + } + }, + "3758377462934d0983bd5f942470da6b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "37681c6c9cfd49cda4d9e5abbcced7e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2102840690c84d7485ce1f1861d7140b", + "placeholder": "​", + "style": "IPY_MODEL_4269f86f3261473f95a603f9dcb73842", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "37802aff6cad42f1ae03a3a7e3651438": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3787d1bfb2224dd4b5d29797ab3aa34d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "378ac9f766304f1db7a4e317af318846": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3674bf7d213148ce981bebe073794ae8", + "max": 2248, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fa13ee081cac4b7397934e2eaf700454", + "value": 2248 + } + }, + "378de033c58042159b345c4607c5a517": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "37b529fdf4604b3bb69265f6c431590c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3744de67f6f24029a7ee98b0001c291a", + "placeholder": "​", + "style": "IPY_MODEL_5881eec743c74f0792b95ff8b320e1f2", + "value": " 2.67k/2.67k [00:00<00:00, 10.5kB/s]" + } + }, + "37e9729e3b66451ba840db503bbf6473": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3816848444ac495da15423c0dec2dc5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_032e070ca6814bcfb98057a3836d3367", + "IPY_MODEL_2afa67dbce3e4ac58f7d47601549b460", + "IPY_MODEL_309b0a3536d14acfb74cf87a90fa6adf" + ], + "layout": "IPY_MODEL_55e21b861d7247608a610e137463a422" + } + }, + "381cb587854145d6ac088146417f73a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d0801a77bfc548d2adef21577c4ed7a2", + "IPY_MODEL_2b898ad3842f4aeb8171698f0a488725", + "IPY_MODEL_a30c0dacab1742bdaedfcec9525a8756" + ], + "layout": "IPY_MODEL_6c4db91b5a1a4875b11a45176b685c48" + } + }, + "383acf4f7c4a4908bdafc74a2b403dd6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3840630d96794a4fbbb091fc060a3d0a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "38480dfc49e840d1be3e20bfaf5ac319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6e02425c18dc472ba88e45b83a55f49c", + "max": 139277, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6a82f5cfdf5f48b4820d4dafd35852f2", + "value": 139277 + } + }, + "3868bde5f3c549a8a60f03e5dfe2efac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_90cd7506a61a4c21939ca0c1c69a1183", + "max": 2196, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_edb3732fe7a94e63847aed0b8641dfcc", + "value": 2196 + } + }, + "386e73ba945444fdb39da9179eb187f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "38709d30d142487083fee9bdfd03db1e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "387d35969ed745c4b70abb3ffa436666": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "38845db0c07148ba90661f3de1d70d7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3889299440444a18a7af6685dfb477a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "388b455405814e65b650c2546ac76bee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6ade6295d471442990e5829b17c72391", + "max": 160805, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b3327e47019d4616a7ca85b202db7600", + "value": 160805 + } + }, + "388ff01ee5e046c19aa0dd442cca1fc2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "38a0464bda91420785ec93921e34f032": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "38b10a8402c34e779cbd0bf5553268d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_91eede4c63b74595b06a7cc58d6a9181", + "placeholder": "​", + "style": "IPY_MODEL_736ff172b3f548f490eb268865a583bf", + "value": " 3.54k/3.54k [00:00<00:00, 11.1kB/s]" + } + }, + "38b1be97320d42718013b01cb23eeaca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cecc508fc930433886c3c49af458b433", + "max": 2387, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a8bbd0940230432e9e219b79fb7396de", + "value": 2387 + } + }, + "38b7b2c285504eeb89492a4a0389f0d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "38ba350375884823a1b79aafdfc30231": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_56035103d77d448f8400c03365781e3b", + "placeholder": "​", + "style": "IPY_MODEL_0db5982ec4d44eada3de6fdf05095910", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "38bb4ffa11f34d56b1ea5d879a23661e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "38c0bf9702f2438993608f6f3022b5c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d3d5c2205dc742afba4054f2a1b68cd3", + "placeholder": "​", + "style": "IPY_MODEL_b867b656013046dc86058ad83c6f87db", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "38c97cbda4d1486798e8ec80f4966a53": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "38d74cf51e8e4f93b5b6d88550b38728": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "38f69dc5f2474b2597cbf01f7224004f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "38fbb462eef042389b1b7921de378fc7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_562db0431e8148d294bc54817cb9711d", + "IPY_MODEL_ece3bf641a844b2ab19d04c20e76d008", + "IPY_MODEL_ec4a24cc9e96499ebdda6efedacd7602" + ], + "layout": "IPY_MODEL_bb0f0cc855a546fc9b764d958f889139" + } + }, + "3905af4eb0cf49fa8fc3c392ea2574e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "39153594a3f6468285cea4346288f79f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3916a6b8aa084c40831ad8c6fa336623": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "391c54a5bae7440c973423caddfdeb5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_147a7657c3f048588b2d4631400a55d9", + "placeholder": "​", + "style": "IPY_MODEL_0c3a8637560d463eb45c4e510b2052aa", + "value": " 4.40k/4.40k [00:00<00:00, 30.2kB/s]" + } + }, + "39252eed697d4b549f3eb6bc0f728b04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aa44e35e8a8e4da881871ad03ecea5da", + "placeholder": "​", + "style": "IPY_MODEL_9744004389cc4a2cb492e6168676a884", + "value": " 2.21k/2.21k [00:00<00:00, 7.22kB/s]" + } + }, + "392a59640f174f03a63276ff53628b3e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3945e07b4af44a4bbd9ac01f6f893123": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "394d5976f0a544819dbc57a01ccf7565": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "395e1f5c1082417db3afb144014658ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "39730d854b854e67acad34c7d9255ffb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "397594d082d14bf5a4030aa2aa120ba8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "39815d0500b54a4f806c3a8316c0e146": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "398cccdf1e314eda8b1d85f57c7b1234": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba208cf7d95d4d63af1ad614769232ab", + "max": 1236, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e3e93b306ce24ac0b643e4bee5940beb", + "value": 1236 + } + }, + "3995119aa27a4afd8bb4e61c0335bf67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_61f73151493c42e2bdb8a22eeac26113", + "placeholder": "​", + "style": "IPY_MODEL_e622cc2cb6e84853beaaa86affcb90ea", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "399ab74da9084db1b7310fbfb3da8c47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "39bddc4d8feb42318076514caba500d8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "39d8decec2d74d47a8302db135bb1371": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9e7ca22e7ff84cdcb0f9ce37dba4de90", + "placeholder": "​", + "style": "IPY_MODEL_8727bc13b7ca420fac14bc4255481829", + "value": " 149k/149k [00:00<00:00, 905kB/s]" + } + }, + "39db5e49e7274883b8a9723f3c33eb9a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "39e286f6b31e44c7a8f743e1991bc5b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fe0e9a3bc0514942a94d6a045f3ee5df", + "max": 139293, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0e04a1ea78c246a292251b87ba8d11f4", + "value": 139293 + } + }, + "39f2d7aea74b4ec9b5b91cf234af9466": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a104820fa8c34948b1c7048704395e69", + "IPY_MODEL_eb7cd9beab8d4179a0a7e772cbadb8ba", + "IPY_MODEL_f61435ba4b0e475091ce0e7f1ebe9796" + ], + "layout": "IPY_MODEL_38b7b2c285504eeb89492a4a0389f0d9" + } + }, + "39f72699e81a44efb96064f8f6628afb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_098b2ca5306841e5b50396bbaf1ab89b", + "max": 2421, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8a17f26998804762921e766358b55801", + "value": 2421 + } + }, + "39fd8512ed4142aeaa89efab81aa7454": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "39fe556ea8534e82b66f16fddc97d496": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3a0214609e2944bbb0ff139743ba59c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a03db3e90844916982830428db3c1d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b0d8a8dc81a4a1bb4cb83c99c73227d", + "placeholder": "​", + "style": "IPY_MODEL_8ff47c556e5c40538a2a01d0fd058c75", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3a16cf127f8a45d8b08b57a520d63198": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7d5c30ef47f64f3dbe445261da651fb1", + "placeholder": "​", + "style": "IPY_MODEL_cbc364a8cd1a4e5c814a2db329c4c446", + "value": " 2.88k/2.88k [00:00<00:00, 11.0kB/s]" + } + }, + "3a1b00f468454982a5f029fe5934c264": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3a1c4dd3524e4010847595de751fa309": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3a1f4a99ea7746029dd41aa380af63bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f746019aac04ed5908a089217d33011", + "placeholder": "​", + "style": "IPY_MODEL_b033c21d550a40f78576fd05b472028a", + "value": " 2.17k/2.17k [00:00<00:00, 14.0kB/s]" + } + }, + "3a2b4bf19f6e47848ea4d3aa2f07fa04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3a327a4c7a074fd18e9435cbf3e698b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a37aca9113347878cca8e94cd730d2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a388d1540e149c18fb8b7e301d78cfd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3a03db3e90844916982830428db3c1d7", + "IPY_MODEL_b89ccbb8531b4284a473467e58831a2d", + "IPY_MODEL_a79555ae1d2a40ae8cc401c520aadd82" + ], + "layout": "IPY_MODEL_d648fd15283b47ff882c151408a5ded1" + } + }, + "3a38f39fa17b4321b2249daceff7126c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f93897132b4f433ca3778816f9fda4c2", + "IPY_MODEL_5dfd0790aa9f467aa63542a07dd14d1f", + "IPY_MODEL_68ee7ff864064c35bac36fa85cfc1008" + ], + "layout": "IPY_MODEL_9244be8f6d3d45779fba0c6320ead499" + } + }, + "3a3e25aea80746b294901f8fae180a73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ff6a0b4dd61942fd8ce77b8e80ed64f0", + "placeholder": "​", + "style": "IPY_MODEL_cb7ad53d65454658a5f3384dfa739efa", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3a4179e15b714d1d9e85a94de54123e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c6b67314d33d4f80be89b7d72ad56da9", + "IPY_MODEL_ae87cbbdf21042d9b1942439721e9f85", + "IPY_MODEL_be62e18e754a4de08d5f30f97cf79ae8" + ], + "layout": "IPY_MODEL_bd69e7c9e36f41509fed2f85da918473" + } + }, + "3a4e8ed61f8a4d3182d605a0bed5345a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a5e8ee836a64d52baeccefce0e671d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a6a009aebeb4453ac227e1ef20a04f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9522cd3f14a348eca5b861f6954049d5", + "placeholder": "​", + "style": "IPY_MODEL_2cdfb68574614d6db795e6a6ac716cc3", + "value": " 157k/157k [00:00<00:00, 733kB/s]" + } + }, + "3a6f58618fde4b2bb952575edcfa14a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a7c94a3461346919068da7d33276f81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4fd876a701994c2cad76d1e3a8723a6b", + "IPY_MODEL_89e30dcc57c14d09a6bf363daeee6d41", + "IPY_MODEL_8725f8993092465c98f68f1ed6c35122" + ], + "layout": "IPY_MODEL_4e73166287084a19928177986f59681f" + } + }, + "3a8d88912fdf4f28b543311626da3810": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fb79c300b960442e88a8912b4731323f", + "placeholder": "​", + "style": "IPY_MODEL_0fa532abf4c6418aa422001bee99fbc3", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3a9c0f9e5b2e49d5a3e1c47cff5e0379": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3aa6ea5c2f8a4873bc0a42e268549813": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3abdf9c136754718b56123d28460ee73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b4d6252f0c9b46179634422fe0e4f92f", + "placeholder": "​", + "style": "IPY_MODEL_330ebe837dc64bb0a375841a0ce3995a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3adb325de6364ab6b25561a3290bea6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cd0feecdb4224b43940eda034ca2693d", + "max": 2415, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8a0da96d80f945e0acfa2494111cf74c", + "value": 2415 + } + }, + "3aedc62ecff24e26ae6706c70d9c4366": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3af8e2ead8ef4bbd9918900c4812e974": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3af90075a92640fe81a5a2bcf2ffab15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3af9d3fc4ea4467b90da091b80e7ef87": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3afe333eadb84650b1db3f45a145025e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3b08028c582c41f09f65dd91cec0f877": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3b1b8b21e463468a818c0041472a189b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3b2267634e1f49228ca31c1891e2bb30": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3b3206f98a7a4a3aba34d29f86b09b6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2429d742d40f45df8c3118c31514043e", + "placeholder": "​", + "style": "IPY_MODEL_77424cf0da1941da96c94e0da10bb7b9", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3b3e93e1b13249f29a0df92451703fb8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3b4592d1740c4f688ec60461f3eb554d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0e10b704d4e24c69afa22206d2269cb1", + "placeholder": "​", + "style": "IPY_MODEL_e106745312074eef9791f25b06ef6b9a", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "3b4f37a47c634e6e83e25eacb9f47c5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3b5b1f01032d478cb49576d1fbe1692e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1190cd1e352b45168cc4a6266199a747", + "placeholder": "​", + "style": "IPY_MODEL_c492bc758cad447ea4f204d02fa2764c", + "value": " 150k/150k [00:00<00:00, 581kB/s]" + } + }, + "3b5b2674edf643858b1bcba5d5d5d9b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3b5e991e83f94bd59cc53d48a00bb520": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3b61e3222e664da8a07f3b40a062eb6c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3b66ca787dd04e7794ed906659c24682": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3b725cc2dbb648c59ab6d43723d7d72a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2c36971ca51a4ebd8cca90cda9fdb92f", + "placeholder": "​", + "style": "IPY_MODEL_a2a62b75ed5a4d8f9f64cb0b3c722330", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3b7b11f1e2dd4b0ea4ab33dae8cebfcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_328ea46ca111434ab75bfaa47b7849db", + "max": 4351, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cd232763b3134435b768f541be1c28f6", + "value": 4351 + } + }, + "3b86f82eebe84f059fb13475c7aa02cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_49cdcbc109f14801bd0d4793cdd69047", + "placeholder": "​", + "style": "IPY_MODEL_4432203603484e68861e825871e01246", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3b8c4949dad0431188a478f451076e62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_512e0b5fdd8849399c8166ab2908b12d", + "IPY_MODEL_6592d31649374d56aba0c1e7f221b0d7", + "IPY_MODEL_9c2a3b4445a3411ca1106a2bc133a364" + ], + "layout": "IPY_MODEL_f8f2b856620e4409ba3b743527e9dce0" + } + }, + "3b976ba713c54a4c9d95396cc00198c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cce9727cd4f74ff68aa2c89bf17400c2", + "placeholder": "​", + "style": "IPY_MODEL_bd7540c552e74a3d920a18b8405ccc9f", + "value": " 3.47k/3.47k [00:00<00:00, 19.3kB/s]" + } + }, + "3b9f2f92fde0408b8970b865781f493b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3ba21107188641608cf81000cb3ce904": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3bb0934a776f41b3b32ea8170213e051": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3bc953d0805d4d8aadf2f2aa6079ba2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3be6f93332f64d66a93e7023351748ed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3bef3638b78a4e4c9deefa497ddd17bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c10e3a7148d4e228a44e2d9bababccc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3c1740a208574d3baf498bc397bf0559": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c1a0dac256744389d307ad3bafaa239": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c1e7e5653264bd1b9e9608b3a297a37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d4bde992e9b74d1a9ceb388ef3304963", + "IPY_MODEL_a6a617c60ab24813b3c81ff5c614400a", + "IPY_MODEL_310398543ccb46eca6e441627b9039f6" + ], + "layout": "IPY_MODEL_130dadd434d947008469179455a94781" + } + }, + "3c42a9d7a6e04a71aca8fd6574f2f3fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_27c3007cfb4547bfb507425a5fa5dccb", + "IPY_MODEL_a22c4ef0796a4c00a064e3f69cb8781a", + "IPY_MODEL_049b194a0d9a4d62b255ca21fd00463d" + ], + "layout": "IPY_MODEL_574141be644f4a4ab0de97a6a51ea1f1" + } + }, + "3c529cd7e7dd42cb8d462395a7cece36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3c5302e0fe8e4ec79f3f5a60ceb9cc3a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_552cf365363242bfaeedc7a497f52b88", + "IPY_MODEL_a80bfa74ebf14d78a4442c40c4bcae87", + "IPY_MODEL_08f018dc9e784e9f908b0c585767fd7e" + ], + "layout": "IPY_MODEL_79e4a8e012d94076baeaf17dd16b1e33" + } + }, + "3c6229040f1d483d9fec28de0e1f9337": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c63aca96c664baf9ff352d9e0bb0139": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5ba077bb09f740e8ac81e18ed9dfb7df", + "placeholder": "​", + "style": "IPY_MODEL_8d258b81db9d4c06839d4bcebf54a798", + "value": " 2.20k/2.20k [00:00<00:00, 5.94kB/s]" + } + }, + "3c6e226c17f9479592f983fb45b19c64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c5fa37861f2749bd89b3a7f017fb92c2", + "placeholder": "​", + "style": "IPY_MODEL_1a874a393e83489aa884fbd330edc439", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3c6e7ddd65224aa0969d719ebc60f3f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d0f0804e62ce43ad933e87f71dea17d5", + "placeholder": "​", + "style": "IPY_MODEL_fb1dbc0bc9a54ca79932678ccca02aae", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "3c741bbb1d144348b91e7ce97fdcacdd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3c886ac0f39c496eadc3a52996bb0482": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1213abe4af5149f0945438a5c63b91c3", + "IPY_MODEL_9dd28dc9d46a4fb2ad803054dcfb2dd2", + "IPY_MODEL_7c38c9ba91d14de5b6cf14bd2b18dd85" + ], + "layout": "IPY_MODEL_b8fc580683c84d259506c346957ff2b5" + } + }, + "3c910693c7524495a05d21c7895c0a37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3d1a5fe609964e7388959f9ebe1b673c", + "IPY_MODEL_5a2351b2d9b7436d8419e75ae13a2acc", + "IPY_MODEL_f4f4532bbcbd450784b3c2e6103078f1" + ], + "layout": "IPY_MODEL_9268014e1fce4c98bba888080c7e99a5" + } + }, + "3c9a27611a2347da921c6ae1acbf9405": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3ca67f3cce984e6cbb5dc5080d23a65f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_417f801fb3b84746983276695bb410b2", + "placeholder": "​", + "style": "IPY_MODEL_9063970146f04b009bd90d2a7c29efa3", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "3cba1b5b02e24fdd9ced881f6ffef74b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3cc1f29405c4401193045f26ca4db796": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3cc63c3c0eb1436186160006bf636bd9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1d6cfd2f959e49389c9c3bf31e12c156", + "placeholder": "​", + "style": "IPY_MODEL_1951e266951b42dab47e48d5b3acd69a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3cd99dd16a2849f2b7dd67fcc0b23225": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3cda5b9f56c548bbaea1c140b87b8fd5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3ce6c1e89de14e5da9c77d2b6951959e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3cee7ed2b4384cb0addf1dc3278c388c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3cf8b50f1ff141d3a33983b03ae404af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3cf96e19b711479fb30825c5d9dfd72f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3cf9d743034a450eaba4fe072318163e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3cff5c7f37c94cb9bd741345bf3fa9e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e6675eeba2884c28b59c5ac7df485d15", + "max": 2003, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_34be74f58bb44f6e8d43e58231b13410", + "value": 2003 + } + }, + "3d1648b39fcd42c9abdab05591613688": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3d1a5fe609964e7388959f9ebe1b673c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_997a970cafb14a9f9280ad02b01a96dc", + "placeholder": "​", + "style": "IPY_MODEL_33186e4d4f8849bbb72359af05c470de", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3d1b46631fd0413f928d34e289a6bb51": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_da38efb4261d40898cc85eb703016446", + "IPY_MODEL_ad51e65ced884627afdd9a4605afb326", + "IPY_MODEL_361cb9d02579466a879634e6e48cb166" + ], + "layout": "IPY_MODEL_776074ec97de445ca95fb3e113dcf409" + } + }, + "3d20009577614074862310c09d308047": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_acc4a6fbc8e34b37aad2a027292e0bec", + "max": 6148, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_08f0038d37d540808fbbd380f5aec88c", + "value": 6148 + } + }, + "3d209a2165914c0a81a57729188a03c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3b86f82eebe84f059fb13475c7aa02cd", + "IPY_MODEL_06e9776fe86b4b138775b57aa7bafb34", + "IPY_MODEL_7ffbf7bd04e64d589053311aa5d80103" + ], + "layout": "IPY_MODEL_fad3ba6ce4b9462198315dbea3c822dc" + } + }, + "3d35648b2a06499a8790a771948b0221": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3d40d42b7a1e464cb38f88932b3c8631": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3d4152eec8214239bea0ac155727b7f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b7ed71970f0745e8bee51d4ae7fdeddf", + "placeholder": "​", + "style": "IPY_MODEL_607c6669961b4154bfdd7d9ce925095a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3d5264775fed441fa79e89314c8f1a90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_728437dce3cf498cb8f52e9cb0365b98", + "IPY_MODEL_e095ed89f7fc4fddbcb93194bfb713ee", + "IPY_MODEL_943d2c83b27b4005866a9031e87bd928" + ], + "layout": "IPY_MODEL_27e898c8f35d40f983584e0c4b8fb3c5" + } + }, + "3d74724a710a4a3cb80823384fcb8d6e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3d7bca6bf5bd4bd38adb286b19d69cf0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7dcd95c81ee9442cb12cb77ad36a13f1", + "placeholder": "​", + "style": "IPY_MODEL_b18fe007b08348899503b4288c504780", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "3d7bceeb5996498e8c6ee7278c0b289b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3d85d642b5074819af8ef0a7514ba7de": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3d8ac01bafe14f97b849828732223f7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_299ea521a72c4f24b396050875a89c56", + "placeholder": "​", + "style": "IPY_MODEL_d2a626b99e964bd6b3d57d3d96ae4a1e", + "value": " 144k/144k [00:00<00:00, 599kB/s]" + } + }, + "3d977bf927ba4a4098d3f5fe23c4ea87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b69449a57794dff84989a346a4b2dcc", + "max": 1333, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9ecf049840194fd094721e964c0e6664", + "value": 1333 + } + }, + "3db84acc212242c0a2d3eb39f96c9d63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3dbb39f8dc904d74b5913e0d8a80976a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3dccb2289f4145ccb9803fd49d1a8c9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3dd25e9e139a41b9b804f809b4f064ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3ddd4524bb95451c83865d08333b5a1d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3ddf29c034ea498db65e3c0323e04190": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3de1499e99174b0585a7edac4751d823": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7f5d5a7c4f6c43d2b3f2b16562c67062", + "placeholder": "​", + "style": "IPY_MODEL_39fe556ea8534e82b66f16fddc97d496", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "3e0eba212e214ae2b9e8e59bc970e5ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_44a4df6eef294ceeb11e82c708d2a238", + "placeholder": "​", + "style": "IPY_MODEL_fce5077ffbba426aad6a25f6141bc69f", + "value": " 141k/141k [00:00<00:00, 703kB/s]" + } + }, + "3e1253fe14da43299a07dd1094ab5ffc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3e37b53b17d04487b452b62c268e9979": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3e4be5ca63b5489998484831221d953f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3e602a40d27f48ba9fc6689923742dea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3e61998d14c340dabef443ff10ba49d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc1d164c9d2c4b02b1af8d05175635bb", + "placeholder": "​", + "style": "IPY_MODEL_0d433f0edf6749d6b429bfe0159c102b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3e669aca35d54873bc72b0a03f514c3d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e6760076b8f4807aa2fa110736f87d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a0f21a549b2b4ccd8e0e9cce98f23129", + "max": 1059, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1265e8ec483b4ce794eb4fa8a2aea0eb", + "value": 1059 + } + }, + "3e6d484070e34a6bae48c9b35afbc1a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e77dbdd86a24679b4a65d9c8fd63991": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3e7c2deced8f41e1bb94240c32a8ea92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3e889266d1224890bce49fdb6be85da6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3e92a26398ec4455aca9b0582f275870": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3e987e0a2cdf4426a9e15a1aae7126c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a08a9c1b38b84eb2a9e7ffe034c90a59", + "max": 147992, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ce31eb91e42d466086f152eafb08560d", + "value": 147992 + } + }, + "3e9e3190d2754c268baf0fd0ce521245": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3ec96a2b6c4a40be9ba0432314dd9314": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3ed1656afacb47d49e602e14014b2ece": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2fcd8b40aae64e6bb77fad3ebc4977c7", + "placeholder": "​", + "style": "IPY_MODEL_feaa44f6f997446f9180402f0177d39c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "3eef5fcf83624a07b31a234caba7c4ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3efa7873f5064a6b863496f7a63daf4f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f032263a7344db2b6f1b74ccee95183": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_11b5b02234be4ba4858f565c60a9f2ca", + "IPY_MODEL_9880088a9a5e42829a3d357fce101ecd", + "IPY_MODEL_49706f48424647b0b2d79494a3abdea1" + ], + "layout": "IPY_MODEL_94635859e324417a92d4441a8e2d4c71" + } + }, + "3f03e60a2dc84ae68fc1d19f7fd67cb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3f28a2e2d5e2426c86816aa1d63ab7e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3f2e2493844648bd8fcf032fddf98924": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3995119aa27a4afd8bb4e61c0335bf67", + "IPY_MODEL_378ac9f766304f1db7a4e317af318846", + "IPY_MODEL_557a033d3a7a4473ae810f516a89915f" + ], + "layout": "IPY_MODEL_2e5d71393af14089b17c91aa98befde1" + } + }, + "3f36246ab24e480288bcee274e655ce4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f396cb574704e9caf317c1d87f86b16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3f3989dbbf904374b281d4632ea267df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3532c2f5622b4a07b8fb8a9982fc51dc", + "placeholder": "​", + "style": "IPY_MODEL_4b926799fc4a4c5b80f41930b4f14465", + "value": " 1.54k/1.54k [00:00<00:00, 7.56kB/s]" + } + }, + "3f3f619ae72b489983b619a272824418": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f5afe8ccc3c4de1b6bdfaa0b33d4901": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f5b507fdea54d2b81c4b1758338772f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f75369bd7984d7181ccfaaa703f7fa5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3f821413b0444453b561a50544e07e7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3fb51e4e74ed46d19d5b9a2a76b70068": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a18f51de5b444c64992e4f0e2bb3d48f", + "placeholder": "​", + "style": "IPY_MODEL_90030fe712844075ab7a9a2f2857e549", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "3fbf874abd82450bae35274a5c4aa3a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_43c0f2fac526439c983ce429eecd9d06", + "IPY_MODEL_85c3326b3d774270a5186db473a6a8aa", + "IPY_MODEL_14a42757da5b45948a5c6e85402a9db1" + ], + "layout": "IPY_MODEL_6b9f3d6677564c91afbac76efdf9a5f5" + } + }, + "3fc3166876f6451e9633fead2dd86f7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3fc45aed4a044c33988ab8613c822cbe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a4242d64ed78443eb0f33279e0af25a5", + "max": 4445, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7e4f832a9866431a96cdfe890fc9001b", + "value": 4445 + } + }, + "3fcd8066b683446f8b21c3832f555263": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3ffd4325421a45d4b8a361f777955028": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7259b23bc3f44d1c9cb6fb5f058e18a0", + "IPY_MODEL_299d61ee09e04510a8ee5bb0ae4067e7", + "IPY_MODEL_0191e9cf66524e679ba41c621e3b23ee" + ], + "layout": "IPY_MODEL_8170957dd63145328a506f00f28a03fb" + } + }, + "4005a8b313494a668f7abf91c254c8a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4005e9724e824283a27cbe7a19e599b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "400b3b5681ae4f8c94c21955bfdaa569": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c90c5085c5ec4bd792350ccc070253c5", + "placeholder": "​", + "style": "IPY_MODEL_f53c28a5fee1480583cf449b51e140de", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "40153ee8435c4914b4bf840c54be19e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e396c1d14e2d4da397f6be080c10f5e6", + "max": 849, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7a81896a1540408fb81802d34af6d0a8", + "value": 849 + } + }, + "4021f023643043838e058af88aeef912": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4023303ec51340a2b3091d0db2692bf9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_71e2de7dd50d40b29dd44aa8e21bab44", + "IPY_MODEL_2f027caad461464e809c92e22c3066c5", + "IPY_MODEL_c244af504c334c6d9ffd7dd328000a9d" + ], + "layout": "IPY_MODEL_ac4fba3d3f7843bfabd35b89a357bc07" + } + }, + "4037c7f093974bdea385342226793064": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5951e601bf3b4e278d9ab6214c93af5b", + "placeholder": "​", + "style": "IPY_MODEL_ba8b5413098341bfb324c639a02e3f6c", + "value": " 1.34k/1.34k [00:00<00:00, 6.61kB/s]" + } + }, + "403b836d310e41039cb80c3d8cd77945": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bf408370c4f54f4d96f2e18437c20e71", + "placeholder": "​", + "style": "IPY_MODEL_a2d87c52c95d475b92d9c292f3878509", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "403d9ba1bd304003a252a52e485d5392": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "40406212f0e54b448b140ad9bbcceb34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f0af312c878849b39e962659b5e4c118", + "placeholder": "​", + "style": "IPY_MODEL_e50d56818d5247b59669c863efd2408a", + "value": " 1.63k/1.63k [00:00<00:00, 4.84kB/s]" + } + }, + "4055f6736f2a47458667b650315f1046": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4062817416f04e3297fb36d9a2e88ff5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4064a66d77274bedb1e16605f5bc3ec8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4d0b718fe2fe47c19addef4a9df53e9e", + "placeholder": "​", + "style": "IPY_MODEL_e11db52c903447a9adb15fe9049b3c1d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4066af1a75344e3291bbd9b82e721e36": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4069cd9685dc466a93940b5083c670df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "40839ba030504eda89907eb6d6886823": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_354fc524c99e422e924352cf4381e67b", + "IPY_MODEL_4d9ea72adb59426ebd77d122ef13c27c", + "IPY_MODEL_19df1c2c06fc4c1d8a001567ef94e5f0" + ], + "layout": "IPY_MODEL_75fa2320194a47e7a72f9321308865d4" + } + }, + "40885555589c4b24a538d360186dc2e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "408b9cb274254bdc84961f11e7df77f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_304776a9e5c74c65a396c3763beceb2d", + "IPY_MODEL_7d92f14f0f4e4c7abe96e93e9b14d12e", + "IPY_MODEL_171f254249ec40f7b8cb4de1c32606df" + ], + "layout": "IPY_MODEL_f74c6a9ba4cf48b2ad6c29a6820a1916" + } + }, + "4097821a196144e2bf11b156c0cfe10b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9989e4711203453285adac06e98f9325", + "placeholder": "​", + "style": "IPY_MODEL_386e73ba945444fdb39da9179eb187f2", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "40aa83f9debf47928ad4dabbe4ccbab0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "40be5b3ad1874a709410c6e4fd341881": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "40d0a3430d0440139379dd15774dca3a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "40e77116db5f41eb9d5986ab01662d8d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "40fe315fb6144c8fbf34bb9f7ffbae5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "410ff15285d2458cbe90401cceabb300": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4110f5d8efb540efba111c7c1516f9da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "412d8e6e21e34e139fb45d1cfea8cd18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b6dcd954a6bb41f2950c551b41fea9b1", + "placeholder": "​", + "style": "IPY_MODEL_f5d18c4bf8d44a72807189d2d28eb317", + "value": " 2.95k/2.95k [00:00<00:00, 16.7kB/s]" + } + }, + "413d38c398414368a4e5ee134024e974": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "41530e820f9143b0a835746197d12b70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4156158b8b794e41bc27ac41dacfc949": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "415ac5eb4f574f3d807d21f7b9a75832": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "416a06929ae943f686911aa23156ae1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "416d048812014358afb0f26484e83faf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1986123b93a141e0add404d38c708c32", + "max": 1955, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a069e702c2514588b1ed726912c146a7", + "value": 1955 + } + }, + "417f801fb3b84746983276695bb410b2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4183e75facff44aca6be5c79d0007c75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4187baa7916a487dadfae97e73e4dcf1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "418d4473f7514a1a8be59f437237e2db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e7e7234074a04169814bbb3a17910ef1", + "placeholder": "​", + "style": "IPY_MODEL_6e0a479332ff481fad87ee87970b88f5", + "value": " 882/882 [00:00<00:00, 3.69kB/s]" + } + }, + "419a05be39c84520a7bd3cb856dbe28e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0f3698f44584505ae65847cd4e95bb8", + "placeholder": "​", + "style": "IPY_MODEL_a554cf9380734e4cb1c8f9e98876f415", + "value": " 147k/147k [00:00<00:00, 743kB/s]" + } + }, + "419b5fb1393e44018f904d18c67fc54f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "41abec2f0f7e4d2d9d585593d7d19f0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0ca56b824786473aa532868c7719ec43", + "IPY_MODEL_67f6045a4ec94cc380c3812e6b557a37", + "IPY_MODEL_7f61fcfb725746bd926fbc63265e31e4" + ], + "layout": "IPY_MODEL_9cad731ed5534c35a1edd808766c18f6" + } + }, + "41b23c3a80b24b7187ace9c0d6df4ba4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d2b1fd42d62b42489bdefe9ff00c8b49", + "max": 2495, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d18904f9840940d096745c611ceef186", + "value": 2495 + } + }, + "41ba8d6a91ee4b58848172eab27f63e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_478164c2f85d4b2b92440c7186e020ec", + "IPY_MODEL_03ab3b738ec146db85d8099447383128", + "IPY_MODEL_858154867da647ec8cdb093731a70e9a" + ], + "layout": "IPY_MODEL_ea4abbf61ddc4861b3818b64fc8b60f0" + } + }, + "41bc8077537b4c3b95b8bea854516991": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "41bc97cebff84903ab97e1a33c1783e1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "41c5d68126f2463999536e4f85f24b81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_be0e648b134f4dbb8f2e5b0813cc4ef3", + "IPY_MODEL_799dcf103c144ee393756091aa161d79", + "IPY_MODEL_ed6de05f26894bf3a71cfbab35a75862" + ], + "layout": "IPY_MODEL_3343fea86deb44bb99a99cdeadd2834b" + } + }, + "41d1306155384240b61fe45f0d59568c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_13daf77dd23247029be70610bc06b5a8", + "IPY_MODEL_a83b4ca57b54497da0a49a0e7e707b3b", + "IPY_MODEL_26a584921e64496f9598a6b1027fdecb" + ], + "layout": "IPY_MODEL_9853001d6c8949849b76840158ed6290" + } + }, + "41d1454175374bceb73401731b93e869": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_42070704e30f404fa413c27d0dcd8f60", + "IPY_MODEL_931f26b287a14503b1730dd9227b88e1", + "IPY_MODEL_a7fe172450f345ba92fb553662636bb5" + ], + "layout": "IPY_MODEL_f89173c729734e8a8549b5578e717515" + } + }, + "41d3fe863acd4f8a94c5e31a351d9b4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "41d679e3e00341e48aff551fff69230d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad7cd8179de1457397ff25cf24091faa", + "placeholder": "​", + "style": "IPY_MODEL_d32abf7f0ed745928969370612856ef5", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "41e290f61a984e4bb44c082cbf4daad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9020bcad7577470a94e89c4f77fcd91e", + "placeholder": "​", + "style": "IPY_MODEL_c03d9f9145ae4a8a83b8342b9048cd99", + "value": " 1.66k/1.66k [00:00<00:00, 10.5kB/s]" + } + }, + "4205553b0e554cffb9106618a11b2e3e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42070704e30f404fa413c27d0dcd8f60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4c794471936e4dcf9265b8bd2c8f74ab", + "placeholder": "​", + "style": "IPY_MODEL_060567c01116429f845d44131e5e0e3e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "420b9d06b9b0414997e27c2d961ba7b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e9a45b9fd22b456b85f138e10254f826", + "placeholder": "​", + "style": "IPY_MODEL_c1e5165a5c70489499bee1c729d8117b", + "value": " 2.42k/2.42k [00:00<00:00, 11.7kB/s]" + } + }, + "42296ffdce384109b18b58fad7e27621": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "422b4276e0eb4276b9d2404e59e34e12": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "422f41ff370d4a9ab794b58397ea92c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4232318ee0d14395947770c2aea452e5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4234f57e28834f21a526ba804f5cada1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "423e8c411d3f40d99c168e3b9d4db274": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42410217266044a59e67224fe86eec91": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42428ab14a624fae98b65937aa0ea4a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "42672b3c0f8247448ac860710a225182": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4269f86f3261473f95a603f9dcb73842": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "427af3db47264e92bd3e6bca39e52682": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "427cdad308b849e5b837c9c94355aa7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "428d5839d2f0455481448c2278ce0bb0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4296312c925d4c7694bff2c25f0b4eec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6288a750d34541918ed3d9c00f270447", + "max": 1757, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_33cb7fe4a48e496b85bb3c57382e205f", + "value": 1757 + } + }, + "4299284c47e74d2c8d94f152a860cae0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "429b58ededa74c1bb1496c931df5eb96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "42b3d85437484faca5480a96ed3d36d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8fa4f294a4dd4eaca122654a07a58951", + "placeholder": "​", + "style": "IPY_MODEL_cb465eebf9fa4b0bbf068155625c1f7b", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "42d68040d097466ead7e8f221e1f02f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b86ef56ee80c483baa00b71932ffe0ec", + "IPY_MODEL_a8b644c28dd9451d93a2347e27509778", + "IPY_MODEL_5926804f81d34ffcbf2d90b5593653f6" + ], + "layout": "IPY_MODEL_799dbf6a95194464a3db6daf3979387e" + } + }, + "42dc24e5274f424097339a2850433bf1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42e7067a658b4a608ad415db72bf2b64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4304f9af8d3649aea09b46f502bf951c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aaccdb222aad480ea4b53964834488b4", + "placeholder": "​", + "style": "IPY_MODEL_27c6834bb12544cd96013e3ae766a6c9", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "430e15904bd343c4b0dda2c787222a6e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e112823e4acf4a6485c3ff87423e91da", + "max": 3642, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6a5c0939ca4d469cb957b2914b363986", + "value": 3642 + } + }, + "4310385bf54c4b6690336c7b5d9a832d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5772ea5b2e4a4a2c85c089b01846503b", + "placeholder": "​", + "style": "IPY_MODEL_7b9044d898fe4a8db49930b8d0a16a18", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "43123af979564fe195009350fe94948d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ae1ea8870df045c89e634b743261efa9", + "max": 2930, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_70894ef2fe214fd29200f64e3b494479", + "value": 2930 + } + }, + "432797a1540943b48a97b84f56e9bf44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bf6ecca851ce43cc96f4a125965e97d0", + "placeholder": "​", + "style": "IPY_MODEL_47a0b9ee42a64945abb6f351735eac8f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "433e52b219bf4d158697d2c0db6889f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4340a5edb6934879a60c5fb5b6ff0b8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b4b895258e9b422dafeecdaceeb2fb27", + "IPY_MODEL_12f8b0118927459595775fc000312541", + "IPY_MODEL_4e43ae3c91da4733a80a8aa712c63795" + ], + "layout": "IPY_MODEL_853f8c3e0cac4f7fa589316c39546c7f" + } + }, + "4347b65c5b80425c98cf6c458366453f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "434ff5be0be14d24b26ace4861923f50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_10909b1acbf0474ca073fb1e8a2b49c5", + "max": 2467, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_008cb9c73b744d22b81fbaabb0f14071", + "value": 2467 + } + }, + "43509a48b335439e84c8f7a7cacf11e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43537855cd1c40bca526e06d4f9578cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9589fd8b66f341f0b9deb7ae63adbd03", + "IPY_MODEL_9ea8dc5ae9b7492f90430e40dca3a741", + "IPY_MODEL_0b6827a598444dacb37392623c9c6ef4" + ], + "layout": "IPY_MODEL_0ab86e7c5f27461ab6065478470c89f2" + } + }, + "435b1de4ae2e4156a1dae17237a2c366": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "435be3d913d44d76ac2e4bad9b098000": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4360b7db25b24168b896ebc1fec4cdef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f088f59f1c5a44e6a2c952d133000948", + "placeholder": "​", + "style": "IPY_MODEL_3cf96e19b711479fb30825c5d9dfd72f", + "value": " 1.60k/1.60k [00:00<00:00, 10.1kB/s]" + } + }, + "436f267d3fbc4810b92695419ae7b9f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43708173f313479b96457c9970ab3632": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "438162ac46a84020b8a7f767e9d62d57": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "439f63bb5a3f425c88b7d47e78e5c74d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43a8b3b81135441d845b28c92453bf08": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43c0f2fac526439c983ce429eecd9d06": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_573bc5ac626e400193552345ed7d7f63", + "placeholder": "​", + "style": "IPY_MODEL_308a718700bc447ab3cbd7c15738c7c4", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "43c6a5c6fb234c388305e7dc66303854": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5eefdcefc3f74e6daa01dc248da49a47", + "placeholder": "​", + "style": "IPY_MODEL_b9ca2330edf24111bc9fa9c2b1e67d50", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "43c961fc8fd84aada7ac6a7e098b5f25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8b64db958b224151920c94789611a682", + "max": 1633, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c3716f7708ae49a797bb6fbbbc10debe", + "value": 1633 + } + }, + "43d81de4a66c43948e94f9195006c777": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7c5515b341b743e2927c91f8556fec15", + "placeholder": "​", + "style": "IPY_MODEL_019c99d8eebe4453a0d5eebe2ed25251", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "43dce7e30883469ab36a89e871e2a141": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43e4a79009a54ea3ae7ed50b61b4cbbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4110f5d8efb540efba111c7c1516f9da", + "placeholder": "​", + "style": "IPY_MODEL_47e0f7c4ae514758a119a542b9ce2e55", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "43f239bef2104e2f9c76fe2cf8703597": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_13f5b779c23742248487685ffb09dd0d", + "placeholder": "​", + "style": "IPY_MODEL_f0626483e4c7431b8029015ba199849d", + "value": " 141k/141k [00:00<00:00, 704kB/s]" + } + }, + "4413cc7eb0d0488fa888cfa2ee3ce782": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4432203603484e68861e825871e01246": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4435594e85874832a7fa374c5cdd9852": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "443a05b71fb3435596f9a44c30940595": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4451266e134749aeb3752ce2246b8150": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "445e2f3aa760445891dc4132f609e157": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8f522da522ae4d34823177cd3aa6e90e", + "placeholder": "​", + "style": "IPY_MODEL_6b0ffdc995d64c95a4fca0a2531f2590", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4463650675a9405d8903eaef0882d6a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "446b0c1198984fefa9a87b9125db0eed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_222b35b0fa3d49bdb6659fa8f542badc", + "placeholder": "​", + "style": "IPY_MODEL_9593bab15ccf4363a4cfb3070d18dc77", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "448e718a525d4f769ebaa4547a3935d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "449ca12cc1d3485b9674133ba6218747": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "449cbedae32848f7bd4816cadf7e239a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9540ab146d114af38a7bf87d264aaa68", + "placeholder": "​", + "style": "IPY_MODEL_ea3dec75152c445fbfa4dfed3b382c82", + "value": " 2.10k/2.10k [00:00<00:00, 7.48kB/s]" + } + }, + "44a4df6eef294ceeb11e82c708d2a238": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "44bbd121fae040c88fa2a764f40581d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "44bfc32f842d492c906962924a18c50d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "44c622db08d04d63b6883652168e641d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "44d160da54544043b4cb84f3c2f2f2bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "44f149fc1c9a428d9a174b30652540ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ae1b09d289c46b4946b2bc37ef6be05", + "placeholder": "​", + "style": "IPY_MODEL_21a1a25c88b34190b87744ddf89c8e26", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "44fd339796d947208f86898f3a6ae05b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b67213ccea524540acefe25cfa0cd48c", + "IPY_MODEL_8899ea90655e46d2be990556e58d9161", + "IPY_MODEL_1c4f014dc69d4a68a136a9a0d144fe84" + ], + "layout": "IPY_MODEL_de00cb298152433f941fa68d31bfbffc" + } + }, + "45021d922f5c4c2eb63ef02e05e358a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_951b91952fd14eb886111c975c596ecc", + "IPY_MODEL_186801289b12436696301865bf167622", + "IPY_MODEL_5e5ddbb0c8d04170b985c97a4a8b1df1" + ], + "layout": "IPY_MODEL_6ab0d1909f554a9b8bcee9b349afd948" + } + }, + "45051e1d31974b6fb0e467ac10ce3a06": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "451d132e9d9f4133bb88746cd2679b7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4520f46071cb43d38220df54fa127854": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4530ebf0cfb343dfb8807e79a1370104": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "45325b2f82924062a06cc466dbae1bc2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "453a816910fb41809bb8f7b77aae8b58": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4540c0a1da4248e18e98a488d24c5260": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a023c00b95f840ddb725a34ca65ed743", + "placeholder": "​", + "style": "IPY_MODEL_c75adb86248a47499d610ea621ece670", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4541129a747047d88d0588528f9c0554": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "454872860fd3495d89bde70c8b9caf08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "455c7d9f38b94e18b5591c3de4273ddb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "455fb950de084bb388bd2a56e513b8c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4560318535144b798e48bd2b07d5028d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a154e172cddf44c6b91bb098805f6fe7", + "max": 1519, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ee30d9251aaa456980c79d7936eb1a05", + "value": 1519 + } + }, + "45741bce027a457b83cc085a1c3fc013": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4581cae484c245c186b0694261cd3f4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3ed1a40b4e84c7087dd8eb37f8fea25", + "placeholder": "​", + "style": "IPY_MODEL_c901fc79a360401d95d7e5e427aa823b", + "value": " 1.21k/1.21k [00:00<00:00, 6.47kB/s]" + } + }, + "458ed26f9941417cad270fd10b0c0f27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_51bea860958e46d7a935d1dcc6b32af6", + "placeholder": "​", + "style": "IPY_MODEL_8f53ba8f8c7445ed87898f0b40fec5b7", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "45918d4478d24e7e9004738e38887738": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5cc1fd0b062141e5bdb6427ba76298d9", + "max": 145370, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a48ea74c75704b9bb8276bb6f47ef2bf", + "value": 145370 + } + }, + "4593bb3cd48045acaee0ee5c76ce7629": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "45b6c365018346daac253245abd6c306": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_541597752c3b4e1ebadefa236d65edec", + "placeholder": "​", + "style": "IPY_MODEL_b7add1a9c517400bac9784247b1d25b0", + "value": " 1.98k/1.98k [00:00<00:00, 7.12kB/s]" + } + }, + "45bdccae192e4a1faabbecd639f198d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "45d0d1d948b54d359090f1f570012089": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6be8a0fffbfd4e43a04d87b587b59cb8", + "placeholder": "​", + "style": "IPY_MODEL_0f49c1123a1247e5838b0b36650cfda3", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "45e527fd3bd24674877b8199ec4a6c69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6ebbd9c7e63e4b4683acbad2d8ad9cb2", + "IPY_MODEL_986911ca1f9f4e069151b7b894e169f0", + "IPY_MODEL_7d57a6f52764436db8363e73e77a0ccb" + ], + "layout": "IPY_MODEL_b42b2e4fe25b410b9e7ce51b16edf8d9" + } + }, + "45efbd54be8d48a7b7a31837caadfc1c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "461907105a0045b596410c10b7c5aa99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4633a70e2bd14f8db73dfb23551b48ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "463c794b03064b32922fea1059001aba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9035e3778fa84aa698a4498a090180bd", + "placeholder": "​", + "style": "IPY_MODEL_b503052ef57248f983c73ca6c1280484", + "value": " 138k/138k [00:00<00:00, 258kB/s]" + } + }, + "46411ee55f5141eaa5d50cb4e604deec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4653ecbca1d54ce1a453803b4b5450d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "465919a6e2694093b83b89019cb49c6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4664e6b94ce147c3ae9397fb0ad01bb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "466a9cca449c4bdd84e792c33b831b02": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "466b10cdcfcc41a18a550b1f8ee04574": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0fc5af4772ea481d9f153e5d9eae0b10", + "IPY_MODEL_75f2e5264992412f98215f1f829f71f8", + "IPY_MODEL_4b10da1f4a11497d9870703f686872de" + ], + "layout": "IPY_MODEL_e5bf6dad18344d479a7a9d014dea71e2" + } + }, + "46791dfc604c4cc6a3a138244da4c6ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "468444d3f7f24e02b3901c32b7b0aae3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "469457d23f634287a8d34321f71f7bb7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4694edba97c44f80a31da50a18b8466b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f8b69d9ad9f34ce587b01e6ed3bccc51", + "placeholder": "​", + "style": "IPY_MODEL_46e1f8b97a504cf08ca86780768ea3d9", + "value": " 1.61k/1.61k [00:00<00:00, 6.96kB/s]" + } + }, + "46a45e153d81488584699e4c27a89231": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "46a6adee35a84debae6839b4becab087": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "46b1b90de72e4828b52427058e9932c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_465919a6e2694093b83b89019cb49c6e", + "placeholder": "​", + "style": "IPY_MODEL_bd1421d8c6eb4be7bfd40f8e5e0fc6e5", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "46d3048072f048a081740281076b761e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f43884f617dc44b5808aab1b64b5f9f3", + "max": 3028, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eb61ecb0154c4132bb3ce8292891e2e2", + "value": 3028 + } + }, + "46e1f8b97a504cf08ca86780768ea3d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "46e8c40c09d641bcb2b5923775f8eacb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4709eabb26fa4d41bd2032ba6207a314": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8bc36c574da34fae842bbd4dd9b9b37d", + "max": 2338, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_31df61ce9c8c46e3857e0e896827c7f6", + "value": 2338 + } + }, + "470d7ccadf5144e49b777c71590c0bda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "470e97a1d0e347e5a7f639c706d97afb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "472113698d514c6aa13d682a0eb57a2b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "472e3fc5de534e3fa2e503379882d5b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4738d0972a4b4679b3191c5027862ef9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e450fff693c94ed79b2f7ac6cb5eec63", + "placeholder": "​", + "style": "IPY_MODEL_2379a5060470449bb7b3681eed8a92a3", + "value": " 4.21k/4.21k [00:00<00:00, 18.7kB/s]" + } + }, + "473e873aa2664a9e959c2a5957d91c0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "474f7ac9f4d14ded81f9bc1c7508ada4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4761d50c834244c0bc5fd542d7b67c32": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "476cabb54c374153b2ea2894f3b0537e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "478164c2f85d4b2b92440c7186e020ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_09baaba2eb8548bf8ad3f805164f0ee4", + "placeholder": "​", + "style": "IPY_MODEL_c18d6534ee49436ea08ae8951450bfcd", + "value": "val/images/all/DOP25_LV03_1301_31_2015_1(…): 100%" + } + }, + "47864357e79a4c5682b7854d769919e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47879564557d48cfb1e2446bebf7f73c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47887f5ff121458d936fb03bb0fe248a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47915a3973444f849131dac1876592e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "47980b4d91a14bc0be08f4b57d0f1015": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "47a0b9ee42a64945abb6f351735eac8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "47c192319ee24a039b040346abfe6b10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47cf92f7340b43f2a8cd7bdfad345b4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_413d38c398414368a4e5ee134024e974", + "max": 1957, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ad382687aa3341a8aace485fca4657f2", + "value": 1957 + } + }, + "47d01ed380244dc095e2f74c03430fa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_39db5e49e7274883b8a9723f3c33eb9a", + "max": 1800, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ce745b09329248399a765025b75c643f", + "value": 1800 + } + }, + "47d89f8718c44376bdaa32fd672a592e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47e0f7c4ae514758a119a542b9ce2e55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "47e262387932429fa15091c7d4b6e172": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2bbda55da2554b4f8312f352e26eed7d", + "placeholder": "​", + "style": "IPY_MODEL_0ea4cb35f9174a9ab6bdaed9e7a01367", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "47edadbc5b424d5b940adb860b1b9127": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f03d5df239a4ad780f7b9b8a3118022", + "placeholder": "​", + "style": "IPY_MODEL_289cd33a4f924a20b6d013d632d1eaa6", + "value": " 2.41k/2.41k [00:00<00:00, 9.18kB/s]" + } + }, + "47ef6b3a4f5549e5ad3aef59a0791d20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a501714d63a347c0acc9982bf04bd253", + "placeholder": "​", + "style": "IPY_MODEL_c1c97e126c354ab3b0eea70ea6c39a27", + "value": " 1.78k/1.78k [00:00<00:00, 12.6kB/s]" + } + }, + "47f213b7371b4b4da597040cedc380b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4803450a3ea240abbf8ec86d7cdb15cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4809ef30ff6742ab85bcd224ff5debaa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "481140caf7304ded89bf5b840d1788cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c96747fbfb4d4472bb1d62cd4c0751ba", + "IPY_MODEL_aa70a29511e84ddd89b7b2e164ae8ad1", + "IPY_MODEL_f879ea5166424f6ba299c711d399fd8e" + ], + "layout": "IPY_MODEL_79c8fe5f3aea442cab40b92f3db8e2de" + } + }, + "4815b4dbfa124ffc82df4812dd651af2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "482de96c141341c4b3345cc6a50b8f0d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fef063de0bdb4f9ebb128eda73750898", + "placeholder": "​", + "style": "IPY_MODEL_505995e79baf40658ab09bdb6b245626", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "48393281aceb40f6a8828238da938975": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4867a5b954654f97a808337beacf23fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "488237b969c444a08f688d762b8a250b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4885d3a7ad7143199296706f373e9e40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00706d646ba94dfa938ff34425cea35c", + "max": 1955, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3916a6b8aa084c40831ad8c6fa336623", + "value": 1955 + } + }, + "488eddcb7e83443fb144aaade4da9993": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "48956d63c6c241409fa0446410f29590": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ea528b2f7bb44b1f9b48ca145972acbc", + "IPY_MODEL_0f59c6d92cc540d3b0ab49fe06d8621d", + "IPY_MODEL_3307e51a65054c178d9fc1bf35674e5b" + ], + "layout": "IPY_MODEL_2348448b75f6437d93d495e21bb64b0f" + } + }, + "48a8de1f9f68483fbaa8ab876455726b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "48abf6ccd35b40cc864a130cc7319711": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48c36bbaaf084ade8d5de85d2ad4e38e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48d9d6dfb93b461eafd2b3181a4323b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3149417ba1154c2f8c8a88f76c2bcdf2", + "max": 143075, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_97b1eb4ec5774174b1e5e3e043d09922", + "value": 143075 + } + }, + "48e1275a0d0d42cebe755d9c85856dd5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48e94d05e160417e8e8f0772283c12d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48ea56cf8b064d68ae8afa93282ed711": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "48f41b52dce94a12bb954680807f7061": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48fb35899e3749598074d237a3aece6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "491461674dc94bc0a28434c3a30d28a5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4934b90531e143c688fe31f3fa6b40ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4946a56a07614f20b53a4b6bd1c0f5ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b4ceb3a8465d486e80a972e9ac93b212", + "placeholder": "​", + "style": "IPY_MODEL_b2a08d62d0574350953945a3a347095f", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "49489dfea821409dbf80a2bdc34f27f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f22b25c1d8040438f68cb2bc253fd31", + "placeholder": "​", + "style": "IPY_MODEL_56c51ee7c4254448aa05d7097c55dd39", + "value": " 150k/150k [00:00<00:00, 1.12MB/s]" + } + }, + "495baafbca14471cbdc33cbc6152b2b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "496132b56a4c44f4b4454e2a167906ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "49706f48424647b0b2d79494a3abdea1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4069cd9685dc466a93940b5083c670df", + "placeholder": "​", + "style": "IPY_MODEL_dc798efb048946f8a161ecfb9032213e", + "value": " 2.86k/2.86k [00:00<00:00, 17.7kB/s]" + } + }, + "498062ca219047c99de45455491e3bd9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4986fa3df0ea4c60a3bc344044720b44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "49c066dc67ee4df2a5fcf285d2181f45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "49cceb5e2dda494e8836f9f6c7b36ac1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_88ca4cd644654f50997dfef938ad014f", + "placeholder": "​", + "style": "IPY_MODEL_835ce627a9fa4a26a9b27b8edb222953", + "value": " 2.68k/2.68k [00:00<00:00, 16.1kB/s]" + } + }, + "49cdcbc109f14801bd0d4793cdd69047": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "49ce9a5421f3401da7e32730e87bdb34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "49d472638569444db78910487fddfded": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f6b8a0978bf24347b751c1c7c43008f5", + "placeholder": "​", + "style": "IPY_MODEL_4021f023643043838e058af88aeef912", + "value": " 3.11k/3.11k [00:00<00:00, 9.75kB/s]" + } + }, + "49e38f860d404153b246c200eebf03b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bb5bdd15f06c4f02a9298924ab8a7f20", + "max": 1436, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_feac8d2b5a78450e90ef4216fcc433f5", + "value": 1436 + } + }, + "4a03451c00094cdb9a5545394e31c468": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6431edce45ca4e889af540b369fe24bf", + "placeholder": "​", + "style": "IPY_MODEL_3cba1b5b02e24fdd9ced881f6ffef74b", + "value": " 4.45k/4.45k [00:00<00:00, 5.12kB/s]" + } + }, + "4a282c246f664481b410330de7a4bf93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a32b74086534fc188d53de257185bea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4a3d9ba0d94e494797f2b2e8f5198d33": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a3fd0e8f5b447329efd14db2642bc2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_697cfde627994b87bc30b71a7458ea7f", + "placeholder": "​", + "style": "IPY_MODEL_8b97cfcdb6ce4c05a465a2f5136d3aa2", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "4a461862121947509ccfdad321354ff3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4a574bcdb772424db5ba0a591466484e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4a62991c53b04417b7678474125910db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a71ed10d5014eb2b2931c18725b51e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4dd85ac47fe04ed2bd6ed6f28bd00caf", + "placeholder": "​", + "style": "IPY_MODEL_c0c3c5bc54f448bda196c43d48684ab9", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4a7204ec1cc847f7b0b9b635f29476b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f5fcee62bccd40519700c98fa49242f5", + "placeholder": "​", + "style": "IPY_MODEL_58bff8760e6f4be8b2b6f60fe9f52c87", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "4a80662fc24f4a7380ccb6740af0448c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e7e09f2eb9f84631826715a3e35a7fed", + "IPY_MODEL_acc8fbee0bb14943bb5390759aef1b1d", + "IPY_MODEL_8d00e4a9bcc54ffa94158ad7e9b16d07" + ], + "layout": "IPY_MODEL_fb6c1383aa044a3f8f330868fc70b17a" + } + }, + "4aa135e9ae71457a898d6154efe62f61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ac39fe0a8ca47f6ae363120153a8550": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_577428760a4e4575b70ffd8bdab924b0", + "placeholder": "​", + "style": "IPY_MODEL_34561586d71645a9aa9d0d48fc7845b2", + "value": " 1.40k/1.40k [00:00<00:00, 8.46kB/s]" + } + }, + "4ad048f86bbc487aa8d61a2eb6e868eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4ad0cc4b1ce746b6b721e425c350aa81": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ad2dab2fbd6453aa098b56c4643abad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d21f6dd0c4e947dea7ccfe2e895effbb", + "placeholder": "​", + "style": "IPY_MODEL_47980b4d91a14bc0be08f4b57d0f1015", + "value": " 2.25k/2.25k [00:00<00:00, 10.9kB/s]" + } + }, + "4aec46ffadd64cdda130c62554995386": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0951c52fb9bc482d9f32278438f9a809", + "placeholder": "​", + "style": "IPY_MODEL_0ec1363205944daaade0169825e91867", + "value": " 2.48k/2.48k [00:00<00:00, 10.2kB/s]" + } + }, + "4aedb5520fb44ad6a6e85eaa1440f59e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_56555fb29b334d48acff3717f1f2368a", + "placeholder": "​", + "style": "IPY_MODEL_9d7538ccf3be4ba69439d5848cc9704a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4afadea01a9e4a4e9ba9af48e4e53ad3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b0a0ee85f204c1e955002c2f17a0656": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b0e6771efe64989af671cfcb3f66b48": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b10da1f4a11497d9870703f686872de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dd0c8b3ab974434ea65054e53e974032", + "placeholder": "​", + "style": "IPY_MODEL_a02e533683a340d6a10dc3f6052d3253", + "value": " 3.03k/3.03k [00:00<00:00, 22.4kB/s]" + } + }, + "4b1cfb3bb70f42a8996cce192644dc38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4b1dd1a136b54ffab95dea189d09352e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c47fcc389d584f40864f9ab6fb480242", + "max": 144407, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_29bba9a06b15494faa64699494532786", + "value": 144407 + } + }, + "4b1e4c4e96d340b48fd0f866a0d4b884": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba0df14ee0b44b09a1e69885df1f7995", + "placeholder": "​", + "style": "IPY_MODEL_6e2cd33553c94fc78002d9093ad31d23", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4b225bcbf96e456d98a553fc3f494ed2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d198fc60fd8e4d9c9f79bcd7db99dc78", + "placeholder": "​", + "style": "IPY_MODEL_9ab6e4d6aae54d9096bab5654fef721b", + "value": " 2.74k/2.74k [00:00<00:00, 16.8kB/s]" + } + }, + "4b23738571c649f49263161a09f17a29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c7dcff929bb64f5bbe4eb42f21e2fc1f", + "IPY_MODEL_887fa40435724e82a61d4c4a83e79f75", + "IPY_MODEL_59278ccdc9104123a818387db882d0a4" + ], + "layout": "IPY_MODEL_a4ecece8c4f741d3a775974952e424ad" + } + }, + "4b367ca9302f49859576409fb923098a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b36e9ab7e9b4646ab49bd6dfe384944": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b5c5f82088a4e3e96fd710ac7fb6804": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b60fba5cc9148c69d47f2a1d7524a7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4b68dd16cdab4d4ca0e4404cddf9324a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4b7097b311274118a505e70557cb9fed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5b81e6fc286d43778afd83f5f3f8a2d8", + "IPY_MODEL_f1182133c53e452d84820b98cd45ef50", + "IPY_MODEL_b92e8a9367bd4ee3a1b0362a6e68a88b" + ], + "layout": "IPY_MODEL_788dfeb8dfb34b81bec2591864c4c6d6" + } + }, + "4b7c5f14b6604805bf417588b78d2899": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b8a8675a6604520a262873240ad1d60": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b926799fc4a4c5b80f41930b4f14465": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4b9c4c97a0a6418d81378e48940f96c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4bb21762149d4ce9b29f48b5e8d9b097": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4bd4d13f782348f7aaea0e8a91dca9f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4be293e45d4544c59df10a7349fe4378": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dacb3aacafa048f3bb480c9e7af3536e", + "placeholder": "​", + "style": "IPY_MODEL_8500ccc3e018487f85389d0d9e3492eb", + "value": " 1.18k/1.18k [00:00<00:00, 5.59kB/s]" + } + }, + "4bfd8539254f40f1956ab57814a39744": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4c0bc32bc12148269a011f77f6e13550": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4c1471933dca40af86640a64b5103f44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_08a23d09e6364e99a5b34f08cff9943c", + "placeholder": "​", + "style": "IPY_MODEL_3e1253fe14da43299a07dd1094ab5ffc", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "4c15d431366c4116a4240f3f20a1f97e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5d2df53041a144aea7f1c5062b6d03b5", + "IPY_MODEL_30e35ed8d500492fbad1b84cb19c50a8", + "IPY_MODEL_1a25de056f994d519b4809c9e9e32ea4" + ], + "layout": "IPY_MODEL_ddc68f1f747b4321a4608a4706c6feb7" + } + }, + "4c25842ff0934ff1a5ebd7051002ca09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4c2b0057d8694f65a198a96327c953fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4c5e135d275849a3b0ef7503c9d6fc3c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4c7057afc48c46ea8371abfbbcc969a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8d7659fed6dc408caf39dc12855c6cda", + "max": 2980, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3a1c4dd3524e4010847595de751fa309", + "value": 2980 + } + }, + "4c7147e8cd4e48bfbc1a0df8d95d5dd7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7498e6d438f94cbab0b49e1109d59302", + "placeholder": "​", + "style": "IPY_MODEL_ccca8768d22948d1bbfcc5ed06ad0d7f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4c7665f48580445d9bb8a6704a7bfbf0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4c794471936e4dcf9265b8bd2c8f74ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4c94cee472d84d348b0bbf26ab1e248e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ca372abda9049ddbb85ba8f356a5925": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4cb0774bea0e48a68617bf9372180b5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4cb0d861f56540a8904928b24e58e458": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4cb25f8cfbb54ebbb9adf9197ebd00b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4cc5fa502f6b4323a2bd58785b126ca6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_255bb54e03cf49bb8526993547250ad3", + "placeholder": "​", + "style": "IPY_MODEL_36c6f76b464d4d3093431ec484d8082c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4cdca2e9575b4f3583eb78acb1245227": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ceb9fea7244400b9c7eb8d336787536": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ddc6bf1450c64c828e697e027b3fb7f6", + "IPY_MODEL_83f917d576674cb39d1a575a613f92b4", + "IPY_MODEL_55869acb5405496ebe981887e8204a0f" + ], + "layout": "IPY_MODEL_e5f138093693493c98e7dfb496c3e075" + } + }, + "4cf02249f69942a584927d7b727097e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4d050b3012e14412bc52203b2a7e64a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2db67eec0b454d27bd8735d48d5b0ca5", + "IPY_MODEL_a6b0f67ab8fe452fa928f7c9f8cd386d", + "IPY_MODEL_f95256528b544056befdb6ce3ff327e1" + ], + "layout": "IPY_MODEL_8b4f6535479d4fe7a6fac757766fb22b" + } + }, + "4d0af35b69254631887d7ed98bc8d6ed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4d0b718fe2fe47c19addef4a9df53e9e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4d15c9588eec4b62b7a83d9b220f8121": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4d1a587a05fa44fa81d1648fe262f08d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d36c2747605844fcaee17b3004b5b43c", + "IPY_MODEL_0b765fcabd734c32bd143725a2dfaccb", + "IPY_MODEL_707cb823affb4cf98155fab0ac064180" + ], + "layout": "IPY_MODEL_f16cbc3a92fd4d0782b30ddbb4db3629" + } + }, + "4d1be009ab2e4b18bf17a9642ee3d4a4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4d3f5faf6d9d4944b4482144f681092d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4d5d86847d4044738c18f2d4e3e5c947": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5950533ed26641cab46fd580fb258be0", + "max": 1907, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d54be3e6e32841e9a5473596cae59c75", + "value": 1907 + } + }, + "4d5ef419d5a34af1afb4ee1da7d15bc7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7401875e8f8442aba660ea1a97bbf58c", + "placeholder": "​", + "style": "IPY_MODEL_1167e344ea7a4b7084687ce3afd3de79", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "4d6c716a52224ff689766ac016c5340e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4d77ab3b93284ea3ba191a8edc00698f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4d7e2fbc5aee490eb3060ddf6306a747": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7688b9cc857849fd9f6ee58d6f83ae2c", + "placeholder": "​", + "style": "IPY_MODEL_0f4e8f3409ff4575b4c43efb19cfba49", + "value": " 1.99k/1.99k [00:00<00:00, 8.50kB/s]" + } + }, + "4d88b307c10f41c5a4f442100353feee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4d925c7145a44ac38d27f850a4339bf0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4d95239ec2ad4a47ae415a5b11f10736": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4d9ea72adb59426ebd77d122ef13c27c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_235fbbcff07547e69d008886af740541", + "max": 2836, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8515511e3d304581a6c06cb724d0a2fe", + "value": 2836 + } + }, + "4da3014ce3754bd399ae0e23fc54bb53": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_33edb298f9604693a5bc2f607df99f18", + "placeholder": "​", + "style": "IPY_MODEL_143078f0183a44f3993c7eb5ce7ce681", + "value": " 3.05k/3.05k [00:00<00:00, 18.1kB/s]" + } + }, + "4db13c081baa44cdb8612b31568e2701": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d9ea6034361440efaba8146a8a6769f0", + "placeholder": "​", + "style": "IPY_MODEL_be2cf26ac0184ba9b54293a6d3379167", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4dcf75be8bcb48c9bb04d02e7835b7fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4dd720c9eea34518abc2625ff77ffdc0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4dd85ac47fe04ed2bd6ed6f28bd00caf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4dde0755b44f42f6990c8849606efcb6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ddf74abf2c248068dee1d590fe215bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4df2babcacf543a4bafdfe423bc0ab64": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4df48edd9aed41269bffa62bc02a3f37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e036fef93ae44afba8f0c7ddcc3072c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e05770f26044e4f9f8b034a4d22bf39": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e1cd2b55f154f85a4f723cb10e84078": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e22dfe4811c42969ec4cf188dfdcbb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4e27ddcfd52e4132a19f73df74d3eccf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4e35bb7e2ce04ea9babae45250ffde82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4e43ae3c91da4733a80a8aa712c63795": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d6357c0f4f44adf93325a0d33a1529f", + "placeholder": "​", + "style": "IPY_MODEL_bc5f39e1079143a3ba807425805b370f", + "value": " 2.01k/2.01k [00:00<00:00, 3.18kB/s]" + } + }, + "4e4c459cf56a4ad095807134b72939a0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e524c74f89642e199b70bd9cdb1a54e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e5f958134b14d1482d6b8ef207d597e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eaccd1fb2e1c41769ae017e85f482175", + "placeholder": "​", + "style": "IPY_MODEL_a603775752b14c9b813016b37cd30aae", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "4e69ffe0ad4d44778fb29be4531e9fa4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e73166287084a19928177986f59681f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e7f0c1a2ff6404492e8cf2d1471400e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4e7f5d0cd77441cc8f7cf352038d7956": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_791bb34ba1d4414e879e7efdb8acd155", + "placeholder": "​", + "style": "IPY_MODEL_2f608e2e50d54796a40b49873c628214", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4e89244489d2418399e62b3efef3a112": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7d40351fce40422fb3fa8f188bc667d2", + "max": 1295, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_07d71796e7084f71b733eb02e139014e", + "value": 1295 + } + }, + "4e91c44d120e4b9e8c89173dd063c41d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4e95b9638bdb491982cbbf4f0ce81dbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4eceac85e2384f01b468df9259980b6c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ed995bd19744b4d95d68a454333b2ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4efd74963c6c4f3289cdb624eb8db5ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4f083e8e9d444a2cb546600851591295": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_482de96c141341c4b3345cc6a50b8f0d", + "IPY_MODEL_e460ea4315aa4da484d726167a6fafa8", + "IPY_MODEL_3a6a009aebeb4453ac227e1ef20a04f0" + ], + "layout": "IPY_MODEL_7a7d423ce7e64b438aaedc183bf737f7" + } + }, + "4f16589f3b4b49e399c6759ce6851595": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1aad7f7677694575bcc3f7d96d9eae2f", + "IPY_MODEL_8a1315ce0cc441e2bef5f391622b6a27", + "IPY_MODEL_a4dbc3b303524757b3a2032dbabc374e" + ], + "layout": "IPY_MODEL_bdc04e14ba9043aba0b2f310f903075a" + } + }, + "4f19b35ff75e4667869e7c7fa35c8cb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0986ff4a73db4ee0b560a0596795b3f6", + "IPY_MODEL_69a63a63ff0a48028b9e768edd7c830b", + "IPY_MODEL_907b07fdbdae460d8b4164f3e7a9b4c2" + ], + "layout": "IPY_MODEL_1fcd5324f12a40a78c9662df0c402876" + } + }, + "4f20507e23844d7182a72a17ae8b631e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f2d9cf991e84dbeb7f3788dfa3dcb2c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f30989d3ee44581900b4ff51bb7d507": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4a71ed10d5014eb2b2931c18725b51e7", + "IPY_MODEL_434ff5be0be14d24b26ace4861923f50", + "IPY_MODEL_ed16fdda30724cf9ae07fd89361192e6" + ], + "layout": "IPY_MODEL_2f39ae23b418414faba5426738840f98" + } + }, + "4f378bd3e9934e0985debd6c06faf1d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0e2653aebae1428492ab4661dd9a5d11", + "IPY_MODEL_2fab5ec9afa5401e86949055b4975532", + "IPY_MODEL_4da3014ce3754bd399ae0e23fc54bb53" + ], + "layout": "IPY_MODEL_f499f755efb347ae867b1e51e671d909" + } + }, + "4f42aafdeb79436f8569b6952982b332": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4f4446f8431741d3aec7c6fc63a23eec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f59ba386fdc473bb4bdaa7e9676eb16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f736f604b68f47619cbe558d54d89b0f", + "placeholder": "​", + "style": "IPY_MODEL_5b709280254948f784701f85de83b35b", + "value": " 137k/137k [00:00<00:00, 674kB/s]" + } + }, + "4f746019aac04ed5908a089217d33011": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f771aac4ddc42389777155adb6660a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4f86e591285645f2b9ec312ce1b03915": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f9a8f0310a747cfb9cfc3b3572dad38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4fa80f44038a4dd19b8c9f1dd4cfea08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3405f2201b76477e85098222c37a7631", + "IPY_MODEL_ae001978af274e27851d362c8612c752", + "IPY_MODEL_5c6e97b333ad4ebba04b94a76965343d" + ], + "layout": "IPY_MODEL_5b7557fb12ed426fac3fcacfdd236c79" + } + }, + "4faa814ac3db4049a2f6d00abcf228d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ce7f5b0643464ddfac992f595329723b", + "max": 1556, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9c6c623a1cc84bb7b92813cf66941969", + "value": 1556 + } + }, + "4fc26cc72f8d4814bb99e441859e0ebd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4fd71fcecbc74b8bb53f122f838c793e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4fd876a701994c2cad76d1e3a8723a6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6cf82dd0fd02492d9cef218fe86878ee", + "placeholder": "​", + "style": "IPY_MODEL_957c2a21ccf44ebbbb9221df782731be", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "4fd8cb7d530d4614b455f40be1728866": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4fe561024b324056a3837174418bedd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6eab33d5d3a94574a9ce0cddca8d8f85", + "IPY_MODEL_957128c8dd5347f4af0ea35599f32b51", + "IPY_MODEL_49489dfea821409dbf80a2bdc34f27f3" + ], + "layout": "IPY_MODEL_dbafbb90e2484566b915f8986b0c4fb6" + } + }, + "4fe79bf246af45f3a8e7cac84db1b20c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4ffb0005764b46d896b647d0657a36ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "500abb0a19d94124a36a771213fadb97": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "50114b3936354f25aed5688e95dda430": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_547528e41ce842e689f613459b00b7a8", + "placeholder": "​", + "style": "IPY_MODEL_ca37f584479c44099c55ace2d313f978", + "value": " 3.40k/3.40k [00:00<00:00, 17.0kB/s]" + } + }, + "505956be6b3c4b9f859d7821edbdbe24": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d78b844780e14002acb30f69e980c192", + "placeholder": "​", + "style": "IPY_MODEL_66ac978876bd4167b002cce78640ae65", + "value": " 1.08k/1.08k [00:00<00:00, 3.29kB/s]" + } + }, + "505995e79baf40658ab09bdb6b245626": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "505c7490a43f46c9a58fd7e256c0048e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b9a55d0913804837bbaaea37d931e958", + "placeholder": "​", + "style": "IPY_MODEL_71b1dc83ec024051a2ae53b75fcc5105", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "50824fc74063400180b04681afc1a2e2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5088772fc4b749929730797b71150eed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9b3d86842e5d423c8cb05e6d5276474d", + "IPY_MODEL_6fb09bcf2577485b903bb86387a3bdc4", + "IPY_MODEL_f9d6562b8e7f4ea08e73d2f75f38b75a" + ], + "layout": "IPY_MODEL_3afe333eadb84650b1db3f45a145025e" + } + }, + "5099a8cafa0947c5b1d71cfddbab15ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "509a9e60d0d9479f8dd0419139d92789": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "509c1d827e164f1f982bd8459962dcb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "50a1c3c5a9e6494f879197c099e75cc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "50a62198db294250b20fc4b8184d7541": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "50ad8f4845d646d482ec04b14931bfba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "50af639a4d214633acfbe4170c230a6d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "50b92da5765546ce9b01e81d2751cdeb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "50c6b777f30f4795aabb33dd79f6c56f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "50d50ff1442c4909a4ca77a875645165": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6990b7e1ebcc4a45948fc68509d7e484", + "max": 3636, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_35c910c4b7f84df8a77485cbab5016dd", + "value": 3636 + } + }, + "50e27aeba00948f6b70e034f3898968d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "50f53e16acaa4f5885ec8337888a7218": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f109ff1b251429c9923d46482b8d196", + "max": 1845, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9117397f0e8e41f3853fde87166776df", + "value": 1845 + } + }, + "50fa1307d7dd4f4caf02bf5fe0bd76a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "510e96bf54c3442ab231aab7b8ceb767": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "511f85103c6943ddba7fa1be539129e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "512e0b5fdd8849399c8166ab2908b12d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eec4d6285c1849338b3181a7deb7a0c1", + "placeholder": "​", + "style": "IPY_MODEL_b959f3694f3847d6a91b953e34619898", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "513561bc87af4ad7ac73d0efdf76d7f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e76f752468e94e509a5ca0540cabbf89", + "IPY_MODEL_f3e24d199f594a37b9cfb2f6b1d9cc77", + "IPY_MODEL_01833ad6271043878b2a8cf96417b294" + ], + "layout": "IPY_MODEL_85490ac84b5747bd8399121f92b90549" + } + }, + "5153cdf46585452f8a869b15a08d6e4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b8c7fbe05ef144998ec1d714476f1e94", + "placeholder": "​", + "style": "IPY_MODEL_35b0bebb6e964fec96b3b7d2c5273224", + "value": " 2.73k/2.73k [00:00<00:00, 13.0kB/s]" + } + }, + "516523089bfb45b8b02584086b99dff9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fe3c920b14be4a11a834eedb88aeb775", + "IPY_MODEL_0159ef0c83c8492faed63dfab0178885", + "IPY_MODEL_5c07bfe37d1f4d7f8d543e8fc5c6266f" + ], + "layout": "IPY_MODEL_863c00185b8a4005800995c57b13166b" + } + }, + "5165b89157e943a99657ea8bfe777f0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3e9e3190d2754c268baf0fd0ce521245", + "placeholder": "​", + "style": "IPY_MODEL_6024fd0344ab4b1bae44fb3a8de534d6", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "5166f45e39bb43568f7c9a23289113a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1021545f24ee4fa4af45d0fa7842a180", + "max": 2171, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6f0608f78a714a34ac018e4de6acd3d7", + "value": 2171 + } + }, + "5194ad1797de40829f567754fcded046": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "519952bda1ba4799ab476b6d46e4d96b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "51a733169e7d4203862cf88e874b94a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "51aa57873e2645c78f36b374628a2510": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07873c74c46e4b74bd437c3bec1b5c94", + "IPY_MODEL_0c6a6ee568b4471ea1ce0e78aa92524d", + "IPY_MODEL_3b5b1f01032d478cb49576d1fbe1692e" + ], + "layout": "IPY_MODEL_81006d7ee45e43eeaaefe636956a6df7" + } + }, + "51adf2bb148849ddba8fa5846232bffe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "51ae91d8ec2544b3ba1ab943f2aa87f7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "51bea860958e46d7a935d1dcc6b32af6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "51c836e2b8bf4711b49912fd9aadc1a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a4f27eb7dd9a466ba522c2c75953922f", + "placeholder": "​", + "style": "IPY_MODEL_31c1fe29135a4952a932319fb1081d29", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "51d0821fc73041e58f8e8f5a2baeadc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "51d3d5979ec44113b9f1563604897bb7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5207475c3bed43fcb6c07951cd768569": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "521812c36c0c4a928c3da5233f83a7bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7bfaab94bf584c42828b5b92c24f8905", + "max": 2234, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e4fe9ec58678410998887ad20582920a", + "value": 2234 + } + }, + "5229177ec2ea471b9ed525ba37ce8eb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f246ac19fe1a41cb9148a313f66b6daf", + "IPY_MODEL_5c4caaff23604d599473823df3d75b59", + "IPY_MODEL_bb60c8b3a81e480eb0ffba3159aeff94" + ], + "layout": "IPY_MODEL_1c71c68b4c204f57b87120cf36d3ea97" + } + }, + "5230a43fd31649288476ed01ed842255": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52415785310242ddbbf9899312bae9fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52422bf2819b405a92fffee2f359aafa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3e61998d14c340dabef443ff10ba49d0", + "IPY_MODEL_bf94ffea970642e4845a4df6220e6964", + "IPY_MODEL_dbcf378fa4b049d4a0f093be89c83397" + ], + "layout": "IPY_MODEL_e36d1ad192e240028e75c4d64fe0ae96" + } + }, + "5248bc41f0694f979651acf033c7a49e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "524eb8abe9e34c8ca2fd0a98112700a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5257cbd151e44e9cb55198567a6c96f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6fa83566be0b4a6fa7f665dee3f7d69f", + "placeholder": "​", + "style": "IPY_MODEL_9b978d29d3d34d50bc2e3661f50a9f8d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "5283b89484d54504824bcc6bd654712f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52b624127e134d68990cdc71af29e67d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "52bd1038069e4cfeb6943f67badab77f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00ef050defa1483bb2522e09e3924ffa", + "placeholder": "​", + "style": "IPY_MODEL_12069b24e9e64035b993c37027e66dfb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "52bd9844a3e94d33ab22d54a72d1c7c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52bf5f06e48648119d3f3dc3cced364e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "52c29c1702314464854df32e1275ef4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52ce6cf47898479e8079d12233f34763": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_754647f26ebd4146a39d78f8e45ecf33", + "placeholder": "​", + "style": "IPY_MODEL_203d54926749455b95687e35d5ac915a", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "52d465243f1e4541be00fae7c0f59461": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "52d57b80d3ff47f1bb5f4990a4f93de8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "52d58efef02e480cbb0cd7242e0235a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_38bb4ffa11f34d56b1ea5d879a23661e", + "placeholder": "​", + "style": "IPY_MODEL_b5d0baefff55495b81cff08f92557872", + "value": " 143k/143k [00:00<00:00, 595kB/s]" + } + }, + "52eb4fe1a31f4be2b5b13c3e23e22711": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0a0680602f5a403892c81b4ca60f4d9d", + "IPY_MODEL_55b957aba1484f53be042c34764f40d8", + "IPY_MODEL_53980273131643459fc1cdf472f73a60" + ], + "layout": "IPY_MODEL_eb4489f1c02948fea0d8a937e92bdf49" + } + }, + "52f0488904cc42caac6a980abef337fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1710fbb5299c4ccabf20efeb00fd3b59", + "max": 141249, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0f86006b72f3443b9ba7b9a3d18fc74a", + "value": 141249 + } + }, + "52f581c78d7e4b0fb7fdb8dfebead9aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52f8e29bc5864095a434ecfa526bdaf5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3f5afe8ccc3c4de1b6bdfaa0b33d4901", + "max": 148309, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9e817d4c3d6f458baea0e30468acdb48", + "value": 148309 + } + }, + "53122628973643a297664e80deeceaa6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5318fa94dd56428b81519cdf8700361c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "531ae837eff94ad989cbeaf6116a2276": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5324f02757384ccba98100cf95a96e29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "532cc9873aee4fa495a868aef7815ccb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "532fec3817fc4d36bc629d7dd7901aa8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53302c9ac6364cbcb45831053e0b1977": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53476ac7279c4f74b979f6a2b59c0958": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "536a47f5292d411c9ae5a32e0abf731e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "53941c06ca054c509612e4ea19bcf482": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53980273131643459fc1cdf472f73a60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_989157da04f8473c90665eaec8558bff", + "placeholder": "​", + "style": "IPY_MODEL_62b9d48c91bf43cfbd4bfd25902a20f6", + "value": " 4.38k/4.38k [00:00<00:00, 22.9kB/s]" + } + }, + "53ce8fbd926e47ff98a1dedb596ed9d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53d192baff1e4e26b82773a74e3cf962": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53e63e7f08f445cb8867e921b8ab70c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2a99852fac134daba955d8cda133b856", + "placeholder": "​", + "style": "IPY_MODEL_a9f5ec07534241c381293e61189d5948", + "value": " 3.64k/3.64k [00:00<00:00, 28.3kB/s]" + } + }, + "53ebe2556ea34a9898988935be6cc8e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "53ef3ff1ba6a48d4bdec7300669e98e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "540ad1dc2d7a41a0a72381a3634c0594": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f653fcd0581498b928579986ce149cd", + "max": 2984, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c87dc2aa0b5f4fd3916ce657b80a4343", + "value": 2984 + } + }, + "541597752c3b4e1ebadefa236d65edec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "541735a0ae0e4a1891b23d9f1d71695e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5423c17ec5894745b8765471862cae42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_19442892a2a24e019e97a630bd07b500", + "IPY_MODEL_47d01ed380244dc095e2f74c03430fa8", + "IPY_MODEL_ac2cb95dbde046aa9d43db7b59c464b6" + ], + "layout": "IPY_MODEL_300c9f0edbbd4449b5c0cba786f43e4d" + } + }, + "5424fe192ac74067b0d5ec9e21440c4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5458e701fffe4e898713c59d928a4f04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b274be7f34db49bea53b23be229c1b32", + "placeholder": "​", + "style": "IPY_MODEL_07ca791331914ca8a1e46afc02e6b679", + "value": " 1.63k/1.63k [00:00<00:00, 8.53kB/s]" + } + }, + "545d763c9f2f4c95af3a5354c5de2faf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_daa5f0bbc5e745ec99cbdb39d0ac2b2a", + "IPY_MODEL_d075453ed9fe422d99e3a736bf5c0a15", + "IPY_MODEL_0e1a574cc50945578197bb9a7b9f6bb2" + ], + "layout": "IPY_MODEL_019464bffe684dc5bf5942c99335f772" + } + }, + "546e20ec0b984914afb29f8b6a71fb49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "547528e41ce842e689f613459b00b7a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "54778e0df56145f384e54002ef13eb91": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "547a6a12e14e49438962cb744497ecb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_47c192319ee24a039b040346abfe6b10", + "placeholder": "​", + "style": "IPY_MODEL_d1ff791cd051406f976c47eb32a7e34c", + "value": " 125k/125k [00:00<00:00, 679kB/s]" + } + }, + "54879bb588d242e49f8ae707e9449d06": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "54894575098d49c0b366352f4485ea9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5490f2c5db9144188d4acc3653508365": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "54a4e71297384adca75c0ceb1eebb9a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "54bc6848fc894562ae7a0aae03544a20": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "54c11e84b11046ce98cc7fe4dc3f5363": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "54c86ecc473e4a6fb78909c75484c839": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "54d181b9d66e406c99e560fbe9c05c9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8109e0315c2f44b8aa0c7721c9d5f0ad", + "placeholder": "​", + "style": "IPY_MODEL_c13eda6cbdc741baa9a847976268c171", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "55071fc84042412dbe884a1efe8f5294": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "552aae41509e4d64bbb4679151ffc0e5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "552c3f2d03b241bcbdb1f11c7afdd287": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a9fdcf658a3549269ece0fc56cd0113b", + "max": 3055, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_321d53e2bb8943a1915b5b1abddc37e9", + "value": 3055 + } + }, + "552cf365363242bfaeedc7a497f52b88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_05c10c40a95545178bdb1be0152a1ee8", + "placeholder": "​", + "style": "IPY_MODEL_1346179a1ad04b24870eb0623c996cdc", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "552ecf3a23ad4614961f85b7dbf8d717": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5549743b07b543a1b1c855324a367257": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "554d6583154c41059b0b573ad995eaa9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba8bde966c714a46b4f5b8c01490903a", + "placeholder": "​", + "style": "IPY_MODEL_aaedb86c61474006b29f63da71aabc2d", + "value": " 2.73k/2.73k [00:00<00:00, 15.2kB/s]" + } + }, + "55639364685b4d35b6f13aff9f732ca8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "557a033d3a7a4473ae810f516a89915f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_74d1c88143734ef79713dd7c71184ec0", + "placeholder": "​", + "style": "IPY_MODEL_263e0d2931a64689a1677db3d1785b4d", + "value": " 2.25k/2.25k [00:00<00:00, 11.0kB/s]" + } + }, + "557b7e62c3fd4f368cee56a88b6b049e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "55869acb5405496ebe981887e8204a0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_436f267d3fbc4810b92695419ae7b9f9", + "placeholder": "​", + "style": "IPY_MODEL_e719165348854f0aa947a61cdd90388d", + "value": " 2.46k/2.46k [00:00<00:00, 13.5kB/s]" + } + }, + "5596e4e09d15429491c5f1184b403185": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aa395aa30e8b4e578490f1f0b2892bc0", + "placeholder": "​", + "style": "IPY_MODEL_d837ac8063484b6ebe22ecb2d537ff7e", + "value": " 2.98k/2.98k [00:00<00:00, 11.1kB/s]" + } + }, + "559905f16c754d4ba900e8a002d87b24": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "559ad0a05af34ce591e31338c884cb10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "559dbb13fa0c4727aec7c83fc6d54e24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "55ae7fcd1714494fbb43078353612233": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "55b84cb718e14b8797a753264d5f268c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "55b957aba1484f53be042c34764f40d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3840630d96794a4fbbb091fc060a3d0a", + "max": 4385, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4e27ddcfd52e4132a19f73df74d3eccf", + "value": 4385 + } + }, + "55e21b861d7247608a610e137463a422": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "55f94826321c4bf2b732ef4dceb12eea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4cb0774bea0e48a68617bf9372180b5c", + "max": 2725, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_901422a96fe449efa69641cf1b794c94", + "value": 2725 + } + }, + "56035103d77d448f8400c03365781e3b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5605a8856d3a4e499c0b14be340ac9af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1f2e99d798464f65b9805574daf292a2", + "max": 2486, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_57c7122600f0400492305cb377b8734a", + "value": 2486 + } + }, + "5606bb4ca8c9465fa91e500d1b1d2b08": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "560a254824d54ef78445f527240bdaa1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "561f284d964d43c3aa7e388ddb1cce7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4b79b803a79468ea486d2e803ac2b4e", + "placeholder": "​", + "style": "IPY_MODEL_92da86bcfda944a5a53ad0d9096f109d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "562db0431e8148d294bc54817cb9711d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dc759eff8425436ab6a21f15f2144ac8", + "placeholder": "​", + "style": "IPY_MODEL_9d5e2a164a194da89eaf384d1ad2dd72", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "563b3b482819457286022ccd21f85f93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9e5c105474504a189226eaee66d2574a", + "max": 2734, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1859810ca5284bde9b5162a4faf76634", + "value": 2734 + } + }, + "56450bafb1834336a8d779a203086b1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "56471e18714a4139b1cf11785018e924": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "56546ff1152e40fbb7067b6ed4d30030": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_31bd8e508c594518863f5f95dc2da5ba", + "placeholder": "​", + "style": "IPY_MODEL_72fabb44a9cc4568b465e1f3c87ce37b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "56555fb29b334d48acff3717f1f2368a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5656d2414d7e45fc9faee24f93e7e29f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f5c5243a1b641d5a28f342d1baefb0a", + "placeholder": "​", + "style": "IPY_MODEL_b4f5fae9786b4d9fb163991e3be54c65", + "value": " 1.39k/1.39k [00:00<00:00, 3.62kB/s]" + } + }, + "5656ef8608c74fea88b10cdb6fd314b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5662f5808b44415a8b480ab8ae70b979": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "56806505b2ef450a8c4af99573af4fed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "568250788ae645c59d71afe46c15c635": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_228024f1797a449a817ea434b4ee4161", + "IPY_MODEL_867b302886c94ed28151b25136d870e9", + "IPY_MODEL_49cceb5e2dda494e8836f9f6c7b36ac1" + ], + "layout": "IPY_MODEL_b4a8ec780a5b4569bcc04df214e448c4" + } + }, + "568e8a357ee0424e95af5a3e2b47364f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_858d6f3b75f54b4187b7fd2241c2c173", + "placeholder": "​", + "style": "IPY_MODEL_adc50e019937481e9b9cb5cea54a5a05", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "56971af690284db38d41c75b5ff4dba3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "56bd67b90817485fb24a9c83ab728952": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "56c51ee7c4254448aa05d7097c55dd39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "56c60580875242d1953adf88c1c4b7a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "56c7b57e8b994f18b64f36bba0f9f89d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f61e0473d9eb4e1bb2e5aaa281bb4149", + "placeholder": "​", + "style": "IPY_MODEL_0523abfa2b5a4d4da419691fad60511a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "56cf9162213543fd826e6490f2715b55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_64620c2e8d77488592cf716259aa49f9", + "placeholder": "​", + "style": "IPY_MODEL_09cc4db6708049a98134cdd3b4852114", + "value": " 2.70k/2.70k [00:00<00:00, 15.1kB/s]" + } + }, + "56e557565a57460fba69921fb68f2daa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "56f2a1aa89f740e4935db8839cdfd384": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5700c29243cc4ca8bd09a2fe751be5a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fa99f5bc587a4ec7b1e98ffed325da67", + "max": 143132, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1cc03e61e64c4eb8b0eb13be9f3d23ac", + "value": 143132 + } + }, + "5722dc5c7bc94dada3f7811530b04a3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9dd5ff1306064fc4bdd04ea3ead29a39", + "IPY_MODEL_a9cb52e8d04a4238a6fdd59790b430aa", + "IPY_MODEL_285c100ca28442e3bfaf4257e3e31485" + ], + "layout": "IPY_MODEL_0f281b8ffb0d4dac9ffbfa69dc1c2f92" + } + }, + "573658360f244446b1110e0255719d13": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "573bc5ac626e400193552345ed7d7f63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "574141be644f4a4ab0de97a6a51ea1f1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57521c2433e147caa1370de0c92c256e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "576346dd58da4dcfab6d7f5e246580b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_15a0239776044901806298b96dd1bb4e", + "placeholder": "​", + "style": "IPY_MODEL_c17148e748a5466f97365200e0f98fd2", + "value": " 145k/145k [00:00<00:00, 1.24MB/s]" + } + }, + "5772ea5b2e4a4a2c85c089b01846503b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "577428760a4e4575b70ffd8bdab924b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5791941d37ac46fe93f9aca84b1b243c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b72f017a4ab949d0b809b53894856a26", + "placeholder": "​", + "style": "IPY_MODEL_e8e56aeb96754016a594eba6079729a6", + "value": " 146k/146k [00:00<00:00, 711kB/s]" + } + }, + "57b1b7eb43204bcab8577d07957854c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57c7122600f0400492305cb377b8734a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "57dbc09f66e64eddb602ae57a91affb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_70672c0bebf340fd83071193530c2669", + "IPY_MODEL_3fc45aed4a044c33988ab8613c822cbe", + "IPY_MODEL_4a03451c00094cdb9a5545394e31c468" + ], + "layout": "IPY_MODEL_6e8c462b900a4eb2ac069fe724421a30" + } + }, + "57df389a643545bbae2418315591f777": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_04767c4bbf4b4db6ad37034f82128076", + "IPY_MODEL_0fdd8411c5274f16919cd307d3a653f0", + "IPY_MODEL_665073f122704b66bb79aedc155b055a" + ], + "layout": "IPY_MODEL_75c5a84a1565416c92c100297960a246" + } + }, + "57e6ed5deadf46c88babc6923f132ed2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "57e9b783d57c433ba4b60ba757f5b41b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57eaf9f6e381451b8cf1d8933a76f6ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57ffedfc04774a72864bcbdd74cbc1e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "58198ad479c742cdad2abeb01ae5bb89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_74fe6cd7a8ba4d12ba1bddde62d946dd", + "IPY_MODEL_c83e1ca6f1314387aa15dc1f416d2b47", + "IPY_MODEL_ea7d317db1ab459d97efdce0449d77ca" + ], + "layout": "IPY_MODEL_7188f25ef10844aca4d4ac8648df114d" + } + }, + "5819a8aaee4c4b18882e3be8725bc5a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_684d5459b51a4e3fa0fe1b658ae8c368", + "placeholder": "​", + "style": "IPY_MODEL_5a504202e90942cea228d17e8c30bd27", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "58260ecc57074d05b420716b517f4ebb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "583081c0998841f6a384f9beb2a3e378": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ae77c161404b498781430c15b76ec082", + "max": 2031, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2a6297f554a84f84a6bb76207a71c36d", + "value": 2031 + } + }, + "586a169b1e26477ca3436e64d4655cce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5879acd059614671929570b1e133186c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5881eec743c74f0792b95ff8b320e1f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "588710fb39f541a5ad593edf77ca525f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5887455e911b448ea129166540f92a87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f86b791386324fc7aa3a7ad29f75adc8", + "placeholder": "​", + "style": "IPY_MODEL_eea03490657647faa7fbd4c646c225ed", + "value": " 2.94k/2.94k [00:00<00:00, 9.36kB/s]" + } + }, + "58960f6d58ca401f9fbf0022834ebca2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ed88d8fb4f0a4438808bb1f1ab13e9ac", + "placeholder": "​", + "style": "IPY_MODEL_f757b4b312bb4899aa70e2a14fe8e2aa", + "value": " 970/970 [00:00<00:00, 4.04kB/s]" + } + }, + "589d8542735d4b0694d02b38179e6aa1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "58af369c59f24725af8cd304a56dacec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_28b00af6d24846e4a096e0780f5bfd76", + "max": 1776, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_137617cb49ba46e7b697c71a8e132ee3", + "value": 1776 + } + }, + "58bff8760e6f4be8b2b6f60fe9f52c87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "58c0eb1a27404b4c827b0754bcbf4e3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "58d1bb2cf2b44934aca16d9dae8a1936": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f9cba92d034e4c61926a2e47c76b5c3d", + "max": 2075, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2e2434101a9a4fc5a86b10b032225abb", + "value": 2075 + } + }, + "58dbf78446a4443ba1e6d0258d7d3748": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "58de58f414dc457e81713e54a3d536d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "58e13a8b67ab4a70ae330d35717a4d74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "58e99695a6a044d58c236093fd336429": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_88f0f714f12f4f61a2b1ba850afbc2a1", + "max": 1333, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9e9784655f6544eea705a0adfc874c7b", + "value": 1333 + } + }, + "58eaa8b87c0c4847b2146129e3afeeab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5917ccde34e64a7583eef034bf838514": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "591e156818be4a30989dd4cd60594b72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_347f78967020438f88c087f58c517084", + "placeholder": "​", + "style": "IPY_MODEL_a687dde664ec46d8a07e93b2d0bf54b7", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "59252e4617a549f19df6be4e31f9781a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5926804f81d34ffcbf2d90b5593653f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_71aef9c05f9644dcae99d118e54ab912", + "placeholder": "​", + "style": "IPY_MODEL_e8cdfec953dc41eba4eba35c90bd5c85", + "value": " 2.08k/2.08k [00:00<00:00, 9.60kB/s]" + } + }, + "59278ccdc9104123a818387db882d0a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9de54fd4235e4155a4c2d0799245c412", + "placeholder": "​", + "style": "IPY_MODEL_56806505b2ef450a8c4af99573af4fed", + "value": " 2.99k/2.99k [00:00<00:00, 15.9kB/s]" + } + }, + "593bf7025dfb40fab8d831d4236da6af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6b5e042a522846cab686704c318787bd", + "max": 5083, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_78a8ca661ed14e55a2555b9f2d1dc4c3", + "value": 5083 + } + }, + "5950533ed26641cab46fd580fb258be0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5951e601bf3b4e278d9ab6214c93af5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5953e1de9db44528b8ccf03c1920ce6a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "595689788ca64f949c58d7ce46ede92f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b6b89c758e641c7ada67398f9f2fa1e", + "placeholder": "​", + "style": "IPY_MODEL_f5b4cd648c28494db75c64bc7a71d411", + "value": " 3.52k/3.52k [00:00<00:00, 14.7kB/s]" + } + }, + "595eb973f6ab4c3cb424973ff20cb33b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "598842208be94e19aaf56e0def77adc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "59894594875b4994ace64b3098f79cd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_232f2bccc92c4f6585bc42266da77268", + "IPY_MODEL_33005ad7c95c4ae19d730511515ce3ab", + "IPY_MODEL_c37d059570b342889c841df8cf244fa8" + ], + "layout": "IPY_MODEL_869480a5370e4164bd2ba7954ff5e3d7" + } + }, + "598d7fe487c447cc94c9be4e963cfd4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "59985c23f5d14808ae3db618294c2016": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "599b05b9807e4bd69ce7864efca03adf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ccb309bb29744c109375491b802c15a3", + "IPY_MODEL_92a55ee03b70484eaa76c8954a5340ff", + "IPY_MODEL_ff69cd3405a04408b5ddc775c0a9157f" + ], + "layout": "IPY_MODEL_34944ff6bd5d4566b7896bd69012ceb1" + } + }, + "59a8f8c8161940998cb551b754e478d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c1ab6633cf624305a625c741e632b3fa", + "IPY_MODEL_8773dc09dcf449ccbf3f1fa6e4e06565", + "IPY_MODEL_62ce198c2c374f79a2bb2b7e6b5751d9" + ], + "layout": "IPY_MODEL_205af868eb174c52932e254eb14ab6a9" + } + }, + "59bb0eaaabbf4fbcabca1eb98296b075": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_56f2a1aa89f740e4935db8839cdfd384", + "max": 2904, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eeedfb5dd5a147f7bc934a194c48645b", + "value": 2904 + } + }, + "59fa4041a9a1428a87b0335971500494": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5a134710109142c88466cbff5e7d69ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57eaf9f6e381451b8cf1d8933a76f6ce", + "max": 1701, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_af20536a5f0940f68e9c481f0d0542b8", + "value": 1701 + } + }, + "5a2351b2d9b7436d8419e75ae13a2acc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e522614df693440db36884ddfd08d1e6", + "max": 1680, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1ba649fc9050416cbaf70de0671d6beb", + "value": 1680 + } + }, + "5a25aa44e938493da0b62d80da8b2c47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5a2ee844206340b780871d31fddc820c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d14f5a07b62841db926213d91a7d08bc", + "IPY_MODEL_b1d3f484cfec453baafe3b00fea00c4c", + "IPY_MODEL_c506519abe3f4a1f8afabe353a3d90b8" + ], + "layout": "IPY_MODEL_bbcce8f46aa743b6a218cd2db676a82f" + } + }, + "5a3cbafd8a0a4a27985c1d6197103422": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5a3eb953ba244a3499e03419d88b9b92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5a504202e90942cea228d17e8c30bd27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5a5ce4e12b4343888e3e3eec9710130f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d440c497c97d4788a75a8d0cfe34ea67", + "IPY_MODEL_8af6c2ce820d4704b9b7926753311ea1", + "IPY_MODEL_8538b8aa71ef416fa99888e1333b175f" + ], + "layout": "IPY_MODEL_5230a43fd31649288476ed01ed842255" + } + }, + "5a62bf0ff66847c48dcd75064e51c2e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5a675c21e2e54f86b1f908f5dd158a75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f8c1fea63fa746b89330fc9511f8aafd", + "IPY_MODEL_8e65a89e19f74897a3c43817a39395d9", + "IPY_MODEL_420b9d06b9b0414997e27c2d961ba7b9" + ], + "layout": "IPY_MODEL_28d6dbde2749437ba0259e849c66d287" + } + }, + "5a6e5afc484a4c0da0f4a61d351c9f08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5a96d28d01aa4a969232462b72756f10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5a988be3b70645fc93094346c618e832": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb5d676255544cb6be8b0ceecc8d47c5", + "placeholder": "​", + "style": "IPY_MODEL_68fed6cb0eba4c30abe4f03b60d01b87", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "5a9e5b72ab1e40dd923705e1bcf3b6e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1852414688ce4ef8a4bec722b997c37d", + "max": 1878, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3dd25e9e139a41b9b804f809b4f064ee", + "value": 1878 + } + }, + "5ab544786a914fa0b20912b3e44912e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5abb12dfdcb9498ab4baf1bd54f0579f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ab70756fd63e4f87a5c945d24fa89c96", + "placeholder": "​", + "style": "IPY_MODEL_f8cc61dd2d7042299e819b0273e3c580", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "5adce2e795b24325ad49b710e0a33449": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5ae7ecf154294e1eaa04bf8aadb430b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_86c07a99cfcb42c0b7a13b6e647a95b6", + "placeholder": "​", + "style": "IPY_MODEL_6be72961a18e49a08a8baf1c5f894c95", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "5afdad692f22438baf0c32de49108f16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7365a05d5ed54fa2a99de837a2b5b5c9", + "placeholder": "​", + "style": "IPY_MODEL_f6876b975e8349f49bcf909c52f1fd6f", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "5b0913f2fadc4c71b8b3d9ad616404c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_646da818e2a141babbca3bb6bd61a3cc", + "placeholder": "​", + "style": "IPY_MODEL_db6f99ece1304644bc9727fa60b4b926", + "value": " 2.12k/2.12k [00:00<00:00, 11.4kB/s]" + } + }, + "5b09dcb711d04f5eae3fb75723a33e77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_071d807d3a6e4527aeadb2e5d6811d0a", + "IPY_MODEL_694c142d1f4e44c29d3a9b9cf88b5d14", + "IPY_MODEL_4d7e2fbc5aee490eb3060ddf6306a747" + ], + "layout": "IPY_MODEL_756d4b04e99f40e98e82589a80b73c53" + } + }, + "5b166bfc400741a48a7ba9150d4e2ee8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5b16d2ad3083499f9a5a07291f091b4f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5b30d447425d47efb3dfdf90a25f2555": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_aa1d3fbd3ecd4baa96eb9f3a2ee115fa", + "IPY_MODEL_dc19366078a34360808f76e244eb12a0", + "IPY_MODEL_7a6c7cae9ed04884bc334852957e7f3d" + ], + "layout": "IPY_MODEL_3c9a27611a2347da921c6ae1acbf9405" + } + }, + "5b339ba471ae4b5394df968905773080": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bd83eb416973436598beb07b59903dde", + "placeholder": "​", + "style": "IPY_MODEL_e50d12b921dc409b99eaba5004ad0b57", + "value": " 2.50k/2.50k [00:00<00:00, 9.46kB/s]" + } + }, + "5b3b31dd4acb4e6a87fd4f7c69274361": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5b3c96cc4dc54e2392cc707100bdc7e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5b467c34846a427491e16a04ae9868c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5b4fc8e711b54ce8a15db688ac073b47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5b545742365e45f4b2d64f98200492cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b8a81e93ec24f01af48a45806afd28b", + "placeholder": "​", + "style": "IPY_MODEL_89117a4fc99b487a9bab3c43f64a2089", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "5b5aa0ded13c4fcc819b8bc093bf128f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5b709280254948f784701f85de83b35b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5b743257287c4ab1bf5a7a9e89803e37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5b7557fb12ed426fac3fcacfdd236c79": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5b7a400a33b749d88682a99dce7be43b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_95b855ccefef48f2a3b9edb3cd878737", + "placeholder": "​", + "style": "IPY_MODEL_9649efd9fa064860bfe33ebb3731c840", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "5b81e6fc286d43778afd83f5f3f8a2d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb8abdaf73364e44ad833674f3bc4481", + "placeholder": "​", + "style": "IPY_MODEL_4d88b307c10f41c5a4f442100353feee", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "5b999989c0b14249b8db0d2edfd13f8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e9237a5176024d5796f9d5f6903be69e", + "IPY_MODEL_52f8e29bc5864095a434ecfa526bdaf5", + "IPY_MODEL_654056894b2b4c389aee4ca1be3d1b74" + ], + "layout": "IPY_MODEL_32881cdffa414f62963d7160c150d64d" + } + }, + "5ba077bb09f740e8ac81e18ed9dfb7df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5bbf9d20d5184af5add18b48b71de85c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5bc0aecc8c634a8fbfd935bb3bb5d457": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_38ba350375884823a1b79aafdfc30231", + "IPY_MODEL_aa132a34dda3426381652c40f12d9b30", + "IPY_MODEL_b257c4621768447fa1cd6aed710a44a7" + ], + "layout": "IPY_MODEL_bf90427669a4439f9484e2428d47e5c8" + } + }, + "5be2950297e84cfc9e4e5ee7da63f5fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8d9980c897254eee91f4c4e68fb630cc", + "max": 6288, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7e801d16827e40a5bc7472ad55dea005", + "value": 6288 + } + }, + "5be334d43d364b59a7b3b750450cbcfe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5bef949c68e0410b9692e6b8a6634042": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dcc037743f4743c0a25e7e54283e18d6", + "placeholder": "​", + "style": "IPY_MODEL_588710fb39f541a5ad593edf77ca525f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "5c07bfe37d1f4d7f8d543e8fc5c6266f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4dd720c9eea34518abc2625ff77ffdc0", + "placeholder": "​", + "style": "IPY_MODEL_109ee823b2bd4d1ab8c112b1f2e3d473", + "value": " 2.81k/2.81k [00:00<00:00, 16.7kB/s]" + } + }, + "5c25a19cd0cd4a99a03d5553ea9ec49b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c267aa714ea41b9ade28e6cdef257d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b39feb14db748738813873a4f3ffa76", + "max": 146661, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d4f3deeaa5324f93aaeab30f2f05da61", + "value": 146661 + } + }, + "5c37b3d134f548719effd448c3679f71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5c4caaff23604d599473823df3d75b59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e53bc1b6441746f2a53e6b949b375e66", + "max": 1724, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_56971af690284db38d41c75b5ff4dba3", + "value": 1724 + } + }, + "5c5824f730a448e1bf84d77138fdaa5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e74c3b0227814855aa3d32f80d35ae83", + "IPY_MODEL_86a96efe55464f9f85a93258a928a7b0", + "IPY_MODEL_4f59ba386fdc473bb4bdaa7e9676eb16" + ], + "layout": "IPY_MODEL_d8538bd32d9b4ff0916eaf719a9f475a" + } + }, + "5c5a129563604efab331925ff8ff7083": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_336d8783dbee43a8a1719436ea5cfd98", + "IPY_MODEL_b47270e5e9784feb8f7752e8888927c8", + "IPY_MODEL_4738d0972a4b4679b3191c5027862ef9" + ], + "layout": "IPY_MODEL_6bc4e7f5545149bdaab259e42d43773b" + } + }, + "5c6e97b333ad4ebba04b94a76965343d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc8d67c7aab543fca997ed56dc824d76", + "placeholder": "​", + "style": "IPY_MODEL_c56d921398d1480e9c80206949b9c08a", + "value": " 2.57k/2.57k [00:00<00:00, 15.5kB/s]" + } + }, + "5c7318815fe2427898e241922059327a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c8021f1bf2142beb5a1d0038ac7bdbe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5c8c4f8e307d4f918e25ff4cd2a32570": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5c8db7f280c34b74bb0d53b6c5292902": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c910c3f183d405e96797799331bbd5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5ca1861157f94cc59cc1047946843433": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ca7bb7fff6f421fa3b5f92dd46edf68": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5cb3a9dd4b6d491f8cf6a684bd94c10a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eec5fdd080d74996acdf1b13b23c038d", + "IPY_MODEL_0ddd7a197be540ca9deee0e78c5280e2", + "IPY_MODEL_3598c403c95a4677863b3de068705e95" + ], + "layout": "IPY_MODEL_6e33babf78f24b0f81fa22ec13437e85" + } + }, + "5cb8b15352064f5087c8154db96f6fc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5cc1fd0b062141e5bdb6427ba76298d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ccd73fd714f4f26a72b55b87c055a44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5cce75c5b0864cf7b046a3c2fd4df724": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5cf07f84b6214c8a811b77008140f7ea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5d1624fef8da4d56b7b72d105916adfa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5d2df53041a144aea7f1c5062b6d03b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ffd71f948d8b44f4b8334f05d9a3413a", + "placeholder": "​", + "style": "IPY_MODEL_effe5861b4aa4be09dfc52da8449daff", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "5d3a54b73c3f40eabf2c9b871c22d410": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e58e11fa2c3645738f7eac579a49fe94", + "max": 3516, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bdce12075bcb4c479dba90fddaf4ce63", + "value": 3516 + } + }, + "5d4c87bc8fd547e39fcdf9f9122b6ee7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5d59195102a44702a7fd4db708875a6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5d712a0640a54d1e94df46f967530866": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a193534b01c94c2b94823af00df4e5eb", + "IPY_MODEL_2d9d62e0fedc4bcdaa125402cff05beb", + "IPY_MODEL_8efaf81a0fc24fc48393e318de8ec66f" + ], + "layout": "IPY_MODEL_0e05d7461b5349619232f69025f58a3e" + } + }, + "5d88f21e62ac43bf9b9b7eb410df7efe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5da26396fa7748f9b27e8db11f21619b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5db2af8856d24c369b5ae2b7ff093d71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f838bd4c03394780aa7ca86334f2aece", + "placeholder": "​", + "style": "IPY_MODEL_8cf8946c4b0b48c0acfc17ce9b5be793", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "5db627b41e5d4ab3894810c859e81953": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f8b7e633bdf145c8b76900324facf823", + "IPY_MODEL_e9b7dd8af5f54f74b7120f0f765c0fc3", + "IPY_MODEL_fec974b3c2fa4170b21bf492749ce9b0" + ], + "layout": "IPY_MODEL_16d011a3997849e6afb3b60608a48c52" + } + }, + "5dcc8a2c0fa84e5eaaef014b17a38b5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_56e557565a57460fba69921fb68f2daa", + "placeholder": "​", + "style": "IPY_MODEL_fb544dfe5e0f4a69b28abfbf35a03a97", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "5dcd5401e39a45e0bf6557a6e451ea97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5dde841620a94cb6a70a266a3068b09b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5de8752bd7a246069e740e6d0ade163e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5dfc8dcf41734c98bb2b59873e7474ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_729112fdf5c447e29f87a203a2e6a266", + "placeholder": "​", + "style": "IPY_MODEL_854feabfe4c94605920b2803506406d0", + "value": " 1.17k/1.17k [00:00<00:00, 5.32kB/s]" + } + }, + "5dfd0790aa9f467aa63542a07dd14d1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2b3ea498f2ec4e648d61eafb76f50e41", + "max": 1956, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_260addfd294d493dad9b0f62dad21fe0", + "value": 1956 + } + }, + "5dfdf6b269e74b2e9280f8cd0eed8bc2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e023461e35d4df1a6a9e8e96ef9a49e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e04723f10744f578829b8f6bd9f5800": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ffd4a09e53364e7489940430ba524ba4", + "IPY_MODEL_4faa814ac3db4049a2f6d00abcf228d6", + "IPY_MODEL_20f770537a364899aedcd499eb9c6b39" + ], + "layout": "IPY_MODEL_5490f2c5db9144188d4acc3653508365" + } + }, + "5e065dcb17ea4a4eb700824b79413005": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e0c488830fb464e80d6c072b69d6af9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5e1de30f3ddd42a28604a1ece9f7ddae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e2d3d29d9734556be0f11aa8605fdae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7e1a5444ba6b49ac99bc9e733ffc04ea", + "IPY_MODEL_89bb77c8263a443b8542951e9dbc3277", + "IPY_MODEL_3e0eba212e214ae2b9e8e59bc970e5ca" + ], + "layout": "IPY_MODEL_8aabdd1869d74fafa3db010ccc404d4c" + } + }, + "5e3b4ee4067c44508977788b9575490a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d28b9098969742b293eff836ef84f8b4", + "IPY_MODEL_d4968b7af0e042a99eaf6f35ea29d629", + "IPY_MODEL_df6e47df5f1042fc911d69fee7433deb" + ], + "layout": "IPY_MODEL_374db19fe5784b4792a29bd3fade7c68" + } + }, + "5e43b9d2a08542049f3a359ff5e9e615": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5e463b7b2d044105a4113259f08224a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e475b4f82094908b86f59c36d0bccd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_166ac2fa0a5a4af4a7ad576316b72b44", + "placeholder": "​", + "style": "IPY_MODEL_ab24fb8c0e264df08b98fb8bf194f519", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "5e5ddbb0c8d04170b985c97a4a8b1df1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_82b5a49fd9884777a59400b451c43d22", + "placeholder": "​", + "style": "IPY_MODEL_60a48853442d45a9b0291bb06ad1d02e", + "value": " 148k/148k [00:00<00:00, 296kB/s]" + } + }, + "5e80942449574307afd8359cca8dd617": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5e828fcef95f46918b0e09a5711c6851": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5ec3c49f74004fe097c2fd9a89d9ea7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9d268805b72f4093a719a2df1461f307", + "placeholder": "​", + "style": "IPY_MODEL_b79ee0b6069f44c8958469a468b1aa62", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "5ece719c79444ef58fb58ec13a9ea36f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5edab9a599e04f1cbe8b20290a7d36f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5ee09fac68214fcba29905f6879802b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ee8ab2ce396409ca691df05656bb08c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9c42e1e2f7574defab54bf292d4e7fad", + "IPY_MODEL_cee7b93894614e798f6469539401f8c1", + "IPY_MODEL_9b88a7f32b274bbe856ad646af95febb" + ], + "layout": "IPY_MODEL_2ac0fb96071146a9a9b8e0b3dbe57904" + } + }, + "5eefdcefc3f74e6daa01dc248da49a47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f0003e6203e4788ae9e55550f4c73bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0dc293aebcd94b9b8c139d423f8434ab", + "IPY_MODEL_1429edb117e54a6d8e397cd39f7513f3", + "IPY_MODEL_17c9e85782bf4df78838a42ccfdc0163" + ], + "layout": "IPY_MODEL_faac666abde647dfbde87807150b7429" + } + }, + "5f0839571a4045e2b7a456b6c7964c9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5f1271a20c694b568d553d0ef906f15b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f202b6ca7c048a4ab80bc2c1b2c8926": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_089d7dcfd3df4e83897aa270236ae5a8", + "max": 1633, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6b7c692254c2413a872a2d4f06401845", + "value": 1633 + } + }, + "5f285ffe54314b5597c3ef8d2d1643ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0c062c9209b3493481d875593e313aab", + "max": 3109, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2bea452eace24fba8526daf57ad2c8e4", + "value": 3109 + } + }, + "5f2b5d51891d4ac58c45c7d400680839": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b8a1ff02048849eeb486f1dd16a82fff", + "max": 143737, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_75658e3eb979426abb55b1fd441177a0", + "value": 143737 + } + }, + "5f3a422f97ed48388bd3745ba5bca476": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ef154f498d924d6088fd01414a5043f4", + "placeholder": "​", + "style": "IPY_MODEL_51a733169e7d4203862cf88e874b94a4", + "value": " 2.81k/2.81k [00:00<00:00, 20.2kB/s]" + } + }, + "5f44c6d8638c4979b8a196310914cfa9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f532bb26c3b4fdeb3a111bfc41f23fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a87c971e1dd04054a56cdc1d67d2ba31", + "placeholder": "​", + "style": "IPY_MODEL_3af90075a92640fe81a5a2bcf2ffab15", + "value": " 1.60k/1.60k [00:00<00:00, 10.3kB/s]" + } + }, + "5f594aac86b0448eb55e761563dc49c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee66c6eab08347f898e2f73d53fd438b", + "placeholder": "​", + "style": "IPY_MODEL_27fd6bd65b3346eab033827d79bf7584", + "value": " 1.71k/1.71k [00:00<00:00, 7.39kB/s]" + } + }, + "5f6422fab2004f1aa7857881fcd59870": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5f795abac98042d483666cb15677d899": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f840b2753324172a2feb09245e6ac0d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f8671ec39464a4eb30299dab61e2238": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f961c0f618b437d8bd00f748050ff39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba099c3e19c44479bb4cf757cededf43", + "placeholder": "​", + "style": "IPY_MODEL_a7beba8c3c424862b0ad7b3303d46419", + "value": " 1.89k/1.89k [00:00<00:00, 9.23kB/s]" + } + }, + "5fac457f94284978bf9791475f838ad9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5fcdb7e7deac4551866f9142a633a53f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d147e8ca162041158a745954cea654aa", + "max": 3545, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_93dcb2a0cc9d4fc690ef27442f18a116", + "value": 3545 + } + }, + "5fdf892b21ae402d864a8adda7972043": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ff29e09c8944f44af5156960049d2bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c2c3eb6d0d194e61a340900c2e98c393", + "placeholder": "​", + "style": "IPY_MODEL_fb9f59ce13ad4cebbaf2ab531a7edd54", + "value": " 1.46k/1.46k [00:00<00:00, 10.9kB/s]" + } + }, + "600549f797bf40d8ac83c3142a2a6191": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c8541974093a405e8395c2c4640cdd9c", + "max": 141111, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_df181c39777545fd949c761170fdc4ae", + "value": 141111 + } + }, + "6008afea184b4e23b2d9863d57203b65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1573ae8c072c40debe60dddb242e6e0c", + "max": 1782, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_86534d69d7724f5abbc3c78c8ac53f62", + "value": 1782 + } + }, + "600ec83c6c134ed0b17155bdf87ebc76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f6b91a0c6ac9460cb6d62bc883fddbcb", + "max": 3861, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a810fb65d4d5421988b5a3d1c7a68a4a", + "value": 3861 + } + }, + "60161f5bb0254d6994e521a0f0f17496": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "601a6a231ce046d89bb627a5a25e1858": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a127e0628c24fe4890733954a0fa902", + "max": 2168, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_999866dc6d46430e8c67a3de88bfa85b", + "value": 2168 + } + }, + "601fa9b50ae94cad8c411e22860fefee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6023b156869f4455825e409431ba3009": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6024fd0344ab4b1bae44fb3a8de534d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "60293ce133dc4a129c0b7b749ef9e69f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_99954c235b9d4d589a68d0278eb52144", + "placeholder": "​", + "style": "IPY_MODEL_da6bb26751454da288bb793f4a912a9d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "6035f9361f5e4918b99456187855f866": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "606e28e1ecfe40e1a04bfcae2da41b8c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "607c6669961b4154bfdd7d9ce925095a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "607f76f7a3944842bdd3b54917f0b148": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6083ecad55114e1db201d49d9dd3d55d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "60a48853442d45a9b0291bb06ad1d02e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "60cc53f575444e419aaf840ea5fb2554": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "60d77cf847da4c4e8c3dfc7a87e3e065": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_238ed969e3f34d84b291509b0e269150", + "placeholder": "​", + "style": "IPY_MODEL_9fb818db3a1647a893e70d948bb75b2a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "60e6d5dcd6564ef48c407766cf667830": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d0ce5632a9c649b9b1afd2f378f81c83", + "max": 1277, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a39dc2a873a840b182d2e7bea6cd23b7", + "value": 1277 + } + }, + "60f626ba8dd94692a5f49883556a73ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "610c6cefb5fe4c7c8393baca992cf445": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "611ac37a2c4e47d5904d9011277c8b7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6121dbccad4a428f92642ec6e65d23a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "613d355fb988491abae35b02a34f400f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_650ea55ef96749e596b99f9a113d0ba1", + "max": 836, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_19ff2ff1334e44ac89257e7bef886a09", + "value": 836 + } + }, + "6140667453774c64ab247e4d068f9249": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "614cb1d01f2f492c9a5009ce0f512b63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "614e6b94b0ab4bafab6e1a1ef6795c86": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "615d2606e1f0456181d763820aa52769": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "616930a7646e4661810c58f224268f3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3b1b8b21e463468a818c0041472a189b", + "placeholder": "​", + "style": "IPY_MODEL_224554e16d534e8d97157f543856bce3", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "6171608533a34f86b875fe6c323a0437": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "61726f982d1246ef961de2221ae85a2f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "617ffa9d9892467dae86ad5b0bbf0799": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6193324d60a34caea316a0d066e05490": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "61af5b7c652b4dbf9c5156eb12898c81": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "61b3301098924573b017c19968515e01": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "61c64f03c26f48d3b1ca396894a50ece": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ca6daa9b9c84d399ffbac8c596077c2", + "max": 3113, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0dc0094cdad8426baff11ff5c6868d80", + "value": 3113 + } + }, + "61e6060f81d8480796001aec1094ce74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ee5d9f27b149417ea211306894d2acfa", + "IPY_MODEL_613d355fb988491abae35b02a34f400f", + "IPY_MODEL_f6ea67f098f5454e9a1179d1473e5daa" + ], + "layout": "IPY_MODEL_7b790a6153254014ad7351b2de4cdf5c" + } + }, + "61e8fac6a936465f88e16e504e701608": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_833f0068959449148d0b6e0087305d3a", + "placeholder": "​", + "style": "IPY_MODEL_8a77988506bc4954abb7148baaccee6a", + "value": " 142k/142k [00:00<00:00, 913kB/s]" + } + }, + "61ea10528fff4f95ac45aad9c8ef2ab3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "61ed9b87ecb8447ca5f0dfa115bb7959": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "61ef1d8c9f644bcf9d1bc718e9129948": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "61f32d8a4039447e979c54b2295550d7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "61f3bd7156be40cd88b3316dd46fa3e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "61f73151493c42e2bdb8a22eeac26113": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6211f34debfe4b4a8eafa4187a732d2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6215b59f73324b3792ca7c3790d251de": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "62190fc4c6f44cc1ad65ce7fce21d732": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c8a7f5aa666f403391f84606faf7f427", + "IPY_MODEL_675c704c67604f4ea71253e9d76a491c", + "IPY_MODEL_bc86c9aa71c44bc69d89115b7632f19c" + ], + "layout": "IPY_MODEL_21153cb885c9417bb8b79ff1a9d36903" + } + }, + "6219cb3db6ef48f8a99d377d22cf68ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_453a816910fb41809bb8f7b77aae8b58", + "placeholder": "​", + "style": "IPY_MODEL_30b16fd52b694f609d81261744b885c9", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "62234e8f9ce34b7aabf94970af782bb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "62257e013ea7432c8fe17e61087e3571": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "62272d0a1a9649799cc3775b0df35fa6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4c1471933dca40af86640a64b5103f44", + "IPY_MODEL_36cb7e27b4064683ac864d593370b3f8", + "IPY_MODEL_f677a024916847aa8330ce20d829b1d3" + ], + "layout": "IPY_MODEL_4c5e135d275849a3b0ef7503c9d6fc3c" + } + }, + "622a054f26ad4326a022394e4a1cb320": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_89d5d8c99de4454f8b6b05dd1dd3eccf", + "max": 1632, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_08c4e01b75b24144b2e4eba0b2fac312", + "value": 1632 + } + }, + "623eb8d0098b492c8b0b27dfa19d74ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cf8e5847d3ff4662865a01b63b869243", + "placeholder": "​", + "style": "IPY_MODEL_d6ef07639e8f4d3388ee95c58eed40cd", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "6246fe98bc5c4ee1893bffa2da59952a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "62493bfdafde4c2186cecd1ec6f3f5b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "626dd1cee1484b58aae2f559dc066529": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_96aff9a9ee714140a87101f50190b5bd", + "placeholder": "​", + "style": "IPY_MODEL_87660df242e44be3be9c322e129aa033", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "62770dd8a2b04e529316441b16850179": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "627a30bf92294683a584443dd2c2f6d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "62859520abef44129f78333b9a7997e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6288a750d34541918ed3d9c00f270447": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "62937a230f5b4133995f742b5b64df87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_88d7d194c9da4c0da5272235cd7f040e", + "placeholder": "​", + "style": "IPY_MODEL_dcb69f18dc794ebaa9b9c5a5c8d33432", + "value": " 1.15k/1.15k [00:00<00:00, 7.62kB/s]" + } + }, + "6298e944f79b4dc9aac6c019182e3443": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "629b2a5cc9254d0bb61c0ca476b72a4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "62a1d6966c704db88256d8888c182e82": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "62a33283f26d4711aea9f112a2af98a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "62a69120910e44c689ae5b32810db9eb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "62b9d48c91bf43cfbd4bfd25902a20f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "62bcb65a18e34bfcb905638516a6814f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "62ce198c2c374f79a2bb2b7e6b5751d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_378de033c58042159b345c4607c5a517", + "placeholder": "​", + "style": "IPY_MODEL_dfbb57e85cd942839429ce1f06e2a6d5", + "value": " 144k/144k [00:00<00:00, 769kB/s]" + } + }, + "62da587b37d64390a11e1a9bc8485c02": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "62e77d27e54a45559d94a0697fd3f1d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6313f5c999e34e278260351647241e88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_51ae91d8ec2544b3ba1ab943f2aa87f7", + "max": 1527, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_adf0af0ae16949ccab6a3c1f06c09f2d", + "value": 1527 + } + }, + "6323d7df641e4b48a1d7228d35861ed7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63261d7f80884c569d9e3f6eab75d0d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_01217a770ebe45698a87ec62dc01bed6", + "placeholder": "​", + "style": "IPY_MODEL_4ffb0005764b46d896b647d0657a36ad", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "6333b21ae8db4c78ace3199494f9cf71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "634cc2bacfeb4e2c958d54a5d50db927": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "63566482323c455faab1896770a25ab8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_68e15580648342b8ad268c9fbf80e549", + "placeholder": "​", + "style": "IPY_MODEL_fc86e40b95144f55806bfece59bf32c3", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "6362268792ac42ce9fa18c50b1002192": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63749b65c42748d29d02685c1ee98cd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8ce3e9e3372742b1a03af4ebea894881", + "IPY_MODEL_ef1e3e8e1d744e5aa7b0bda2f77ec6d5", + "IPY_MODEL_83470be692e14ce0a070ba37712ed466" + ], + "layout": "IPY_MODEL_f8f92b260da5489fbf8af6f513da21c2" + } + }, + "639aeb1525094e649f5bd404790aa1a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_298b2f97984f4e7b9815fb28cb4bd710", + "max": 2921, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_50fa1307d7dd4f4caf02bf5fe0bd76a1", + "value": 2921 + } + }, + "63a3c3ce10c54eca97e2d210261d262b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63ab691e54cf4da594306020391dd865": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63acb0700e6d46e6a37a8396ca51786c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "63b41bef602549888917b460ff850bd3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b8be353cf5d74c6998f6ab6e479b9d6d", + "placeholder": "​", + "style": "IPY_MODEL_b0d23f9cc30e4faaabf2059c05817238", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "63bcd9cfb68f420dad3441141f0f7e16": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63c8ecd3ffb942dd9707463e7f8e5aae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63d3f242dbc44a1c83a35b2c510cbc55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_904e39c40b37420bba1682d16f68e7d9", + "max": 2885, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e534e4b7c83c4908b015b07f02f81e7c", + "value": 2885 + } + }, + "63ed5544a18d4113a0a5876e3ea0e7a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3b9f2f92fde0408b8970b865781f493b", + "placeholder": "​", + "style": "IPY_MODEL_2888a56893d84eefbe1cf640d240987f", + "value": " 2.19k/2.19k [00:00<00:00, 13.1kB/s]" + } + }, + "63f331b144e84b608ab08c4125560a2e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63fea45103db46d6b280b2325954cf2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a98e8ba84b5b4eefa73d9d1a4e9c7569", + "placeholder": "​", + "style": "IPY_MODEL_051a521b28bc41b39e8fcf3ab6abe8a7", + "value": " 1.88k/1.88k [00:00<00:00, 13.7kB/s]" + } + }, + "6419e0020ae74fafaf0d28179cbafa0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ddee7392845e472e8efe9b36b3f8a3da", + "placeholder": "​", + "style": "IPY_MODEL_ac296a5ced2a45f9ab59fdfd8ec9a269", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "641c9ba762314f4fac3489c1781f7334": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "642a30eef8694c109ae5327064e40b40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6431edce45ca4e889af540b369fe24bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6435b9dac5fd480e8f0901b5c5836b3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5e023461e35d4df1a6a9e8e96ef9a49e", + "placeholder": "​", + "style": "IPY_MODEL_6c30a1aa2649481caac53e628166bc7f", + "value": " 3.28k/3.28k [00:00<00:00, 16.6kB/s]" + } + }, + "64436ee83a414280b7873625ceeb04b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8231244a92b6413ca82c9d3111150226", + "placeholder": "​", + "style": "IPY_MODEL_168fb84d31404ff8b9453eec2d433ab8", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "6444296d7d8f4558a474a52816ae5add": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "64620c2e8d77488592cf716259aa49f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "646da818e2a141babbca3bb6bd61a3cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "64785d85833b4fe5b396af98ff8f09a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6498a43f5eab4e5e9ee085e840df81d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5e475b4f82094908b86f59c36d0bccd8", + "IPY_MODEL_b5f908f95c0841bcb2f2212e6a267aac", + "IPY_MODEL_d7f1c0e0da3541be9e571f6e7a49040a" + ], + "layout": "IPY_MODEL_d85fd50b02ce47f086b033460bda9208" + } + }, + "64a341220f434f41b7203ee4595be3b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "64adb157f7b8492cbe7111e19f04bb1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3abdf9c136754718b56123d28460ee73", + "IPY_MODEL_b9b4a047ab9041ab9e5ee8d6e6f3fe7a", + "IPY_MODEL_8c50e55f31794a42b0c6e060d4c49de0" + ], + "layout": "IPY_MODEL_02981dbe4d3243d08fb6ca34eb671260" + } + }, + "64d23ec43c0b497c87d60233668562fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "64eb66d646754097ade41fbc6a3cb552": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eebfca6973dc472e8ac862196d1a75d6", + "IPY_MODEL_be88a79d954240eaa239c8c0020fc2c5", + "IPY_MODEL_9dfe9fa945c54cd998fa2d4957f25e40" + ], + "layout": "IPY_MODEL_d6797e8299584b68894e67601ac431f8" + } + }, + "65018e77996a4fd69e57d567e6f3c889": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_74ad264850754fd4acb99cbb0a4c3eab", + "IPY_MODEL_e264ee369cd34d96a435861a5f3295aa", + "IPY_MODEL_6ea88ea2d84a465e82a4f48b221e1821" + ], + "layout": "IPY_MODEL_74cf1532bb0947f5b81e6ac9afaed8bd" + } + }, + "650ea55ef96749e596b99f9a113d0ba1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "654056894b2b4c389aee4ca1be3d1b74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_41bc8077537b4c3b95b8bea854516991", + "placeholder": "​", + "style": "IPY_MODEL_9092968cdd7f42ad806456f1660b1577", + "value": " 148k/148k [00:00<00:00, 624kB/s]" + } + }, + "654d3e75185c449788c666cdb7dda252": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6550dbc3f2384e66ad0d94cc0af8b753": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "655c34bf80394282bd54721ef2b4d7e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6570b52d1a95485f9bd5500bb15f8517": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6581192368fc4f6a9e72c3db483dd6d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aa688f04ad0f471faf20f396f34b91c2", + "placeholder": "​", + "style": "IPY_MODEL_5e80942449574307afd8359cca8dd617", + "value": " 1.98k/1.98k [00:00<00:00, 10.7kB/s]" + } + }, + "658530837bfc475194c424d442b93826": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "65894031b0ab4a3f84dba2dece431d87": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "65907362b98c49408698a55b18c346f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c7156892facc44629bb0399d8adf3529", + "max": 3244, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fa3edb2a498d41d6b8beea7ed2b7f441", + "value": 3244 + } + }, + "6592d31649374d56aba0c1e7f221b0d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4232318ee0d14395947770c2aea452e5", + "max": 2254, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_17dc18f9df7b44cc8ca4268fe0d958d2", + "value": 2254 + } + }, + "6595902981044e18b324538f7d4fac39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "65a034a0b4624976bcae852cb5d099af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "65a17c97a4d4415fa2795f52511090b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dff036fec1ae41a5a1d039803fcc3b5a", + "IPY_MODEL_8fb7ec7ba1c643f3bbde36fabc5b751a", + "IPY_MODEL_6435b9dac5fd480e8f0901b5c5836b3b" + ], + "layout": "IPY_MODEL_50ad8f4845d646d482ec04b14931bfba" + } + }, + "65a7baa8cb2d4487966e3c783ba9d9a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3cf9d743034a450eaba4fe072318163e", + "placeholder": "​", + "style": "IPY_MODEL_70d596c04a1043f2a16eb12a4fd88542", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "65a84cd44b444b668d98988519843568": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "65be78903d3b4fcf8c93e84e83535d4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_95829ff409954b33abe6a5f6bffe270a", + "placeholder": "​", + "style": "IPY_MODEL_595eb973f6ab4c3cb424973ff20cb33b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "65c31e42f09644e88304e949ff005195": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "65d5bca6d6964361ae038b36f23337e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "65efc576e7db475aa0dceef3d1b0992f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_10b7bb96090f4a8897deef932cc093ec", + "IPY_MODEL_d0405631405f42eea78c4c6d892c4ee5", + "IPY_MODEL_ac6f73270ee4455eb1a985b8bca7bdf6" + ], + "layout": "IPY_MODEL_ad56809c41a34c59beb5d70bfde42484" + } + }, + "65fd47d11e354b9a97356ffdb7626e64": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6617747f9a554c2bb97c62338263afdc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_65fd47d11e354b9a97356ffdb7626e64", + "placeholder": "​", + "style": "IPY_MODEL_e7d90e411cc84b6ea84c2dddd564d2aa", + "value": " 1.61k/1.61k [00:00<00:00, 9.05kB/s]" + } + }, + "6617e213ffba4ef4af19f63b0939cdd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_305965f954c243bb9ae0387fc91545bd", + "placeholder": "​", + "style": "IPY_MODEL_e928b339fcad49fe8c40b221d2e4e785", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "6626d0660152408b9c12bdaee01ee315": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "662a7fcbedc84beebde9eeacac2ea9aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "665073f122704b66bb79aedc155b055a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_758b24b75a2b42c890182b03f4f178ba", + "placeholder": "​", + "style": "IPY_MODEL_f4c779ed467d4bbfb87cd414f96b9ae4", + "value": " 2.12k/2.12k [00:00<00:00, 12.4kB/s]" + } + }, + "66580bcae2794ad3af71ccfc25e974cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "66582f50b5474203a3e077fe62237229": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "667b72e9cde040a48c8c2efe3afffce6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "669e706285404711bec00c22cf9556c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "66ac978876bd4167b002cce78640ae65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "66ca62fb35254c3e963e32110af2192e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "66cbc290a945499f9b5c588a523e79a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "66d140661c86457cb9559a5905e036b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c3882d431db44709a74650b8bb03d7f8", + "IPY_MODEL_7f6cc4162cdd4c9eb9cd8c1fb7fb5fe0", + "IPY_MODEL_07b49c5bfd0f4653bba8e0fedc791cba" + ], + "layout": "IPY_MODEL_c04efb5e88264a6f9130749c0646570b" + } + }, + "66e31b4ff5df430a9916605656d6c7e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c14ee38c2bc44bbd8e5323752fb9848a", + "max": 140094, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_31e27e1ffad242d990950106aaad2fa2", + "value": 140094 + } + }, + "66e57f760a1841e685152734af2520fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "66f463559b9f4a829c47d3765951d624": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "670017b025e3411283b7c559b2cc2b64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6701a6f7fad44d2f92281f062acc094e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f1d3a8ca0b542178c47a133c7a966cb", + "placeholder": "​", + "style": "IPY_MODEL_b7d3877f07c64f72b29004a37d50da24", + "value": " 1.21k/1.21k [00:00<00:00, 7.01kB/s]" + } + }, + "670d812ffc904d72a571b5424cefb11b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f879172baedd4b509ec11980be1ba3b8", + "IPY_MODEL_b474f2b8907d4e83b2cf9bfb394dcda0", + "IPY_MODEL_4694edba97c44f80a31da50a18b8466b" + ], + "layout": "IPY_MODEL_cb8853f2ee704ada94741acecb905f91" + } + }, + "670e16768f8b4bc9ac6f1961cade05b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6712761cbdf14abfbdc27869c900ff45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "67145440b5c645a09e521b006308443b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "671b10e6c6da44b0b842865b7c1de182": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "672b13e94cd84ac2b6b978c20a732336": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7684fb9fd96f490194a2822932589810", + "IPY_MODEL_704fd563e97a473680d561531e925ea4", + "IPY_MODEL_291f329979914138ac28966db3f86d96" + ], + "layout": "IPY_MODEL_efe74bbfd70a48739462874b8c4b59a4" + } + }, + "673d76425e634e02b3a1556c2f557e26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_623eb8d0098b492c8b0b27dfa19d74ed", + "IPY_MODEL_2ece4a4a4dfd4f838a78ec2f7d8c4ec8", + "IPY_MODEL_6aaa8047f2694c89bb11adf9a049c822" + ], + "layout": "IPY_MODEL_2af893d7e46746deaf99fce6da5ee518" + } + }, + "6742099a4ee34e6996a62655cf43f1f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "674fdcdb0c88452d86b0c256a0f674b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6751da2b1d4c4a99aff1f836409fc992": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "67584473c8e74bab9b5bb3bcd2d4001c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "675a467723ef4161ae86e82a45fbfd54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "675c704c67604f4ea71253e9d76a491c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fa0841a723914aaab0661ee0cab885a3", + "max": 2187, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6fd9b4092e8b444981680447782ff353", + "value": 2187 + } + }, + "675cb3538a3a471ca12b6540cda4d5cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6783b9b46c3f4dce9e050b827fa02181": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6791eb896e33449da6339f25b8cb53d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "679e1fcb3a4144f4a5db1bd483b7fc3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_71e607ae05bd40f096a593a8420ca9b0", + "IPY_MODEL_1562f27b68cd42ca9de808b2fb09e35a", + "IPY_MODEL_c11732e19eab4817abc311cf85c304e6" + ], + "layout": "IPY_MODEL_95e4ee710fb448929f0b1a118a1bdd0f" + } + }, + "67a3046f65844bdab86316c7ee7600f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cae27f673c7a4a46ac0bce77f93b454c", + "IPY_MODEL_c0807b89c95e453abccd63628245d78e", + "IPY_MODEL_1817f29dc58c498b96b01382775f4dec" + ], + "layout": "IPY_MODEL_56471e18714a4139b1cf11785018e924" + } + }, + "67a6f2ac9f3b48b68b612e72ab5d14f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d6e8730caa2248238e2cac6765950b34", + "placeholder": "​", + "style": "IPY_MODEL_4803450a3ea240abbf8ec86d7cdb15cf", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "67ac827b1bfd40898d112b54e7381304": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "67b2e1c6029b4b49ae299224bd9edfba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "67e527bb2d1b40c8bac71a426821fa9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0362ee79e32548d6be14f36c3f11274f", + "max": 1088, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_415ac5eb4f574f3d807d21f7b9a75832", + "value": 1088 + } + }, + "67eb952d05184ed58a518d8e401506b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_468444d3f7f24e02b3901c32b7b0aae3", + "max": 3032, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_10207ff778bb4b8d9ab448538709f927", + "value": 3032 + } + }, + "67efa8d398dd4393969caba5e980bf66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_626dd1cee1484b58aae2f559dc066529", + "IPY_MODEL_d5ea69a6aab042f6af76551310d6ab8d", + "IPY_MODEL_6701a6f7fad44d2f92281f062acc094e" + ], + "layout": "IPY_MODEL_96858d2e05e64f399cd517d80ecffc35" + } + }, + "67f1dc45a78a465193de9b9b777685bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "67f512e7f3e2446cb98f700a17b2a247": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "67f6045a4ec94cc380c3812e6b557a37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c949d09fb8e848a78aeccc6171f6600c", + "max": 3198, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c1f8e73cb9f34a5b92c8c2a617fa6dc5", + "value": 3198 + } + }, + "68055bb469d2424b9eea59b44a755198": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "682ef1a4929a4b4c9b1c767dd8b67fbb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "684d5459b51a4e3fa0fe1b658ae8c368": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "684e9c9e4af64f5a865aa6531540f04f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6854185cf0254ca5ba110e748b6d5352": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "687391e2a6e843b4a6a9141841e70dcd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_306052b12a474819bf59c39eb66572ef", + "placeholder": "​", + "style": "IPY_MODEL_bd0eafc04a8c43bdbaa51d818a802388", + "value": " 1.97k/1.97k [00:00<00:00, 11.2kB/s]" + } + }, + "6885950d08b24f7099628212ea748c74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a7738e88c32b4c7b9fcee89ecb678990", + "IPY_MODEL_95f77cbf40414460ba1709e8442065b2", + "IPY_MODEL_cf0f23f206e3445c99d665846c02a5fd" + ], + "layout": "IPY_MODEL_67f512e7f3e2446cb98f700a17b2a247" + } + }, + "688a569079d84de2a565d460aee7f7af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6892e2538365410a8242cf658fecbf70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_355e507ab5b24a0baef6d306863b4ff6", + "placeholder": "​", + "style": "IPY_MODEL_62a33283f26d4711aea9f112a2af98a0", + "value": " 2.40k/2.40k [00:00<00:00, 9.04kB/s]" + } + }, + "6893aaed7c2a413aac9c6dd97f26c46a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "68a4c0234a7442359f589569f3c8c822": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "68a51ad67692460b96a7818ae9933ff7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0acee9b60d61423c83e1d067fc744fbc", + "IPY_MODEL_1f503a1126d943c38befc19c57788f70", + "IPY_MODEL_8a8a433c7dcf4f4ba01915c479fd0c0c" + ], + "layout": "IPY_MODEL_53ce8fbd926e47ff98a1dedb596ed9d5" + } + }, + "68ba15a9383d4add9a73be9d23b187da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_64436ee83a414280b7873625ceeb04b0", + "IPY_MODEL_f8fd79efe81843dab619222845cf65c3", + "IPY_MODEL_df86ceb0fc2848dd9416f3456e38e36f" + ], + "layout": "IPY_MODEL_c73c975bdd98426e84d00e8023c2bb7a" + } + }, + "68c7cc0a8ddb471f953bfb91450d3a97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "68e15580648342b8ad268c9fbf80e549": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "68e4808635cc421e9f0ceb0a501bec6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "68ebb2d7311545008fe8a4cc94f013f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "68ee7ff864064c35bac36fa85cfc1008": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a5a7afad20c41759516c69679a40801", + "placeholder": "​", + "style": "IPY_MODEL_6bb07519ee444d348ffa27c15217cc07", + "value": " 1.96k/1.96k [00:00<00:00, 7.69kB/s]" + } + }, + "68ef8a8eeba2484387a74919dfc9adfa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "68f73f8a86994b88a3def122a968636c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "68fa94fedd394127886a591c687f05ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "68fed6cb0eba4c30abe4f03b60d01b87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6904a36620824725a92fa6b340535f48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fc6aee6f754d4d4d890ae29b2714909c", + "placeholder": "​", + "style": "IPY_MODEL_4d15c9588eec4b62b7a83d9b220f8121", + "value": " 1.96k/1.96k [00:00<00:00, 10.9kB/s]" + } + }, + "69162d774b314276b2af6a0d7c4629d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6917dcb42410492fb2c52d3530c04c7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "692c8b553ded4cdd95deb2b5fad6ffd9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4a282c246f664481b410330de7a4bf93", + "max": 2112, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ff8bd07b517f4bc68873e32b3fffc3e7", + "value": 2112 + } + }, + "692de97672d44324b33b55009d3e5621": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c44cd5ed2752484fa53cd8b4af42ba1c", + "placeholder": "​", + "style": "IPY_MODEL_5b3c96cc4dc54e2392cc707100bdc7e3", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "6937878ef8e74d359a30a3ef9c42bb5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "694c142d1f4e44c29d3a9b9cf88b5d14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4dde0755b44f42f6990c8849606efcb6", + "max": 1990, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d9e9d80c1777436ab58b74c66bd48b41", + "value": 1990 + } + }, + "6954938ed5614d20ab0ed770e1ca3111": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_891724e2dab44eedb7c6a8624d4f8d2d", + "max": 1993, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_18cb0128789242268bb1dc399cb8f39d", + "value": 1993 + } + }, + "696c17edd8da4b91b1a054ede2d3cf53": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "697cfde627994b87bc30b71a7458ea7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "697e4be28fa744e7a724d151a78208b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6990b7e1ebcc4a45948fc68509d7e484": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "699d97ec26fe49aa9c2b76c4e965aa1a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "69a63a63ff0a48028b9e768edd7c830b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad3f71c63bde4c92a7372468f13247be", + "max": 2088, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ff049392cc8c433b92fd2ca25a022475", + "value": 2088 + } + }, + "69b69fcff95749deba21122b0fb9efb6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "69bf9eb558ed4dd59ebbefb518ca639b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f07cc501e32c4ba7809a836f4cf587c6", + "placeholder": "​", + "style": "IPY_MODEL_2fffeae3cc1849058fae93a3b26e6eb7", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "69ca60f5981d44f9bcd55a8493e22826": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "69cb12a78b174f058be252eecad40cef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "69d30f8694ef4a02b7d8ab58f4862457": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "69f78556ea2b4615b5d9db47314ef410": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "69fe305116a94d62b2b4bf2d3558db89": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6a03f9fc01db4612a06038e7d6d7cc22": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6a0a0dfdbfcf4d49b79c97095843b2f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6a11ef18fea54b06b02c6049a184bf36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_952c7aaefb4449b4b8d4d7fa09a48a72", + "max": 1899, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6df985dbe2044f4490763f1163f273f2", + "value": 1899 + } + }, + "6a230e333f7045ac91e3f37c37936c63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3a8d88912fdf4f28b543311626da3810", + "IPY_MODEL_aff1eb7929e247689c749ef336f46c58", + "IPY_MODEL_0ee81b8fa98a42a9911811f5963f0b2c" + ], + "layout": "IPY_MODEL_c590759fc37a4093b3de2d83259a34cd" + } + }, + "6a5c0939ca4d469cb957b2914b363986": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6a5ce40024ec44b1aa513f4c6189a875": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5fac457f94284978bf9791475f838ad9", + "placeholder": "​", + "style": "IPY_MODEL_12ccd7b3b7054a8a9ba9451b867dce52", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "6a612e7678044ea78ed24e18281deb7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6a68a47f0a804afb94f08bb02c2ae5cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aee2cccbaa8246219166962ad6ccc7bf", + "max": 2858, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_634cc2bacfeb4e2c958d54a5d50db927", + "value": 2858 + } + }, + "6a6d4b44db38442fb3465ccbaf7b7a28": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6a8231fa803343efaeeb557c33e71be3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6a82f5cfdf5f48b4820d4dafd35852f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6a8575c5b3224e3aabf9d7120ef0bee3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_be49a16b47dd4ceea53b56bbf4385784", + "placeholder": "​", + "style": "IPY_MODEL_60f626ba8dd94692a5f49883556a73ae", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "6a8f6c3c23d94ede8a0ead126d9d5e72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6a952c52a5674e79bdf2565e75e57371": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6a9714548cda416cb3bf03ce0e8d644a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6aaa8047f2694c89bb11adf9a049c822": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5606bb4ca8c9465fa91e500d1b1d2b08", + "placeholder": "​", + "style": "IPY_MODEL_65a034a0b4624976bcae852cb5d099af", + "value": " 1.37k/1.37k [00:00<00:00, 1.93kB/s]" + } + }, + "6aad608ecfc84e8585e85fb33fbfe1b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7534810f3a124c959474b081db29e28a", + "placeholder": "​", + "style": "IPY_MODEL_e37058f1bb4b44fdbb60f35544b8f248", + "value": " 2.66k/2.66k [00:00<00:00, 17.4kB/s]" + } + }, + "6aae09158fb14746bf40d4b5ac15c569": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6ab0cc871a6b49bebcf06505e25ee4c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6ab0d1909f554a9b8bcee9b349afd948": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6ab7b7c911a04c5b884689a0f9773988": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6ac4109c1daa4374a21dcb8d1e4364fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6acd4bcb16694114abfa46daecead818": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_466a9cca449c4bdd84e792c33b831b02", + "placeholder": "​", + "style": "IPY_MODEL_d655eee7f0ed44988ac7d918f962985b", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "6adc0a1b5e0341a1b4e36167f1957bb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6ade6295d471442990e5829b17c72391": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6b0ffdc995d64c95a4fca0a2531f2590": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6b17552b0f68420db3b5d8712297e035": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6b1b20aed291423c8351c087e595c758": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6b43dcde920b4adaa159bf567b13ba9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_616930a7646e4661810c58f224268f3e", + "IPY_MODEL_f015de370343469aa38381b2c92a8f89", + "IPY_MODEL_2426b583ee0f4e0cb96746ae04b080fd" + ], + "layout": "IPY_MODEL_0030257589974d19806602fa8f069b74" + } + }, + "6b4b395518584094afeb1b91c3a1ff24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6b5b0628c7c24f39a92b834a9e9046fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6b5e042a522846cab686704c318787bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6b671e4e4cf9409b96c7562c8f03640b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ff445bee815940cdaf7fa530d590704a", + "placeholder": "​", + "style": "IPY_MODEL_e70425ba92584b6caaad7cfa74f4e2cc", + "value": " 1.29k/1.29k [00:00<00:00, 8.39kB/s]" + } + }, + "6b7c692254c2413a872a2d4f06401845": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6b86b9fbe4f042728a78b5412c5dedb0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fe88b0b4f7f44f29a0752271cd2103e3", + "placeholder": "​", + "style": "IPY_MODEL_0e42111fad5f4fb88e0dc07d0524c913", + "value": " 162k/162k [00:00<00:00, 640kB/s]" + } + }, + "6b88e1337ffc4e5597026219136bd9ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a7e129911ec9437db9a9cc872ee34638", + "IPY_MODEL_66e31b4ff5df430a9916605656d6c7e5", + "IPY_MODEL_9f1e2a3d4b3e498c9a6ecf69bf36b79b" + ], + "layout": "IPY_MODEL_bbb2cee2cd2d4320acd238a4f7c009ed" + } + }, + "6b8c318a542544d183c9770aa8a1b57d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6b91f33045d44c45ad2b39cf2ef6c065": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f86e591285645f2b9ec312ce1b03915", + "max": 1461, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_49c066dc67ee4df2a5fcf285d2181f45", + "value": 1461 + } + }, + "6b9f3d6677564c91afbac76efdf9a5f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6bb07519ee444d348ffa27c15217cc07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6bb8b5b7020840039debfac598e7fc35": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6bbbd40b98454bd8a689268fd4b80b04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6bc08ebc74a7416ca8765b26dd226f3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_63566482323c455faab1896770a25ab8", + "IPY_MODEL_4296312c925d4c7694bff2c25f0b4eec", + "IPY_MODEL_e1831af076744876a8870ff2469e9884" + ], + "layout": "IPY_MODEL_4df48edd9aed41269bffa62bc02a3f37" + } + }, + "6bc4e7f5545149bdaab259e42d43773b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6bc6b3722d8846c0a0f60004c4715bd6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6bdcc8df24a344e19ff748a75b56a20b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6be72961a18e49a08a8baf1c5f894c95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6be8a0fffbfd4e43a04d87b587b59cb8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c128913e662497bbc039f4c4f65e9d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_692de97672d44324b33b55009d3e5621", + "IPY_MODEL_36fea20f190548158155512e23eafea5", + "IPY_MODEL_ecf2d39201ed459d890b01f9c78d05a5" + ], + "layout": "IPY_MODEL_e981da87b70347f982492cdb60db515c" + } + }, + "6c1309b2c208414cbb0482fa3a56ff68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_66582f50b5474203a3e077fe62237229", + "max": 1926, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cd95f6c3488a4b908f9e34a740f2eb0e", + "value": 1926 + } + }, + "6c184c1bcaaf4220999247e66598ef73": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c1a8d21a067412a8cdae54d4266abc7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c30a1aa2649481caac53e628166bc7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6c31124106fe46849ff1c67d970c2e15": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c394d7c540a4fbf9a69b80231eab344": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6c4660e5a345437c9b1217b68d2aa5a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6c481610278f4a79b85fd459fdaf5262": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b4f962905fc540cc85a6f7e708f9fcaa", + "IPY_MODEL_25b5a727e0b9458a91a4466d74524f0f", + "IPY_MODEL_1472edf3dad74f6eaa0ffa096fc3a0dd" + ], + "layout": "IPY_MODEL_f6481e43de7f40a0aba7cf5626c515c2" + } + }, + "6c4a398e006f4af6853725ff62c49222": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c4db91b5a1a4875b11a45176b685c48": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c4f77cd572741d3b0a0a17d0d1ef633": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4299284c47e74d2c8d94f152a860cae0", + "placeholder": "​", + "style": "IPY_MODEL_5a6e5afc484a4c0da0f4a61d351c9f08", + "value": " 1.36k/1.36k [00:00<00:00, 11.9kB/s]" + } + }, + "6c4f990d75784afab6abf2ca99f0f845": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c71f2d3792846ce8aa4a22733c506f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ec1ab92700514310bd160bb50e5d2c25", + "IPY_MODEL_f23c6d6333b24223a87e91b3ef5116f9", + "IPY_MODEL_17c968d33c684743af7f6ad264c02682" + ], + "layout": "IPY_MODEL_10b2746ab7f3400399ebd520e9aba90e" + } + }, + "6c8e1f1b2e4b4fe38882eb4326d80a87": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c9dbe173ed64c338edd5230b13e10b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6c9efeec4d334be6b4208b6f0110b1b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a37aca9113347878cca8e94cd730d2a", + "max": 1855, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c51354ccdcb14c98aa1d9cbccbfaff79", + "value": 1855 + } + }, + "6ca81a825c48465585e484e98aac4b6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6cb2bfc731d14778a03bd03efe0b5603": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1c727d8ce8be4c88bf78b82f35ee95c8", + "max": 2030, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_948d99fb17ee484eb58ed847c5dbb2ef", + "value": 2030 + } + }, + "6cb592b93df649f7a4b674c15d79d040": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e57234779448462184e0a127ca9bd8aa", + "placeholder": "​", + "style": "IPY_MODEL_317e868ad8b24929a821ee591b79bff3", + "value": " 160k/160k [00:00<00:00, 880kB/s]" + } + }, + "6cb8e4d58c844b7d85e69e4fcf3d1946": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6cbad73654c645ee88d2899800e0edf7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4e7f5d0cd77441cc8f7cf352038d7956", + "IPY_MODEL_322cba068b43445da720ab435e25a025", + "IPY_MODEL_1db39b5176cf46988e19138fee1deb80" + ], + "layout": "IPY_MODEL_bb138676c226420e8043b0c883463791" + } + }, + "6cbcecdaa743493ab0f62a7dce605013": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f3170150e89042f6a6b885438beaec0c", + "placeholder": "​", + "style": "IPY_MODEL_7393c00640014b1b8ba8fabb2521bef5", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "6ce24022b1be43b7bc2348b33d0d55f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6ce7b2c355f94bcc81438e2c34fa51d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a31a1bbf62224356b73736a936470b61", + "placeholder": "​", + "style": "IPY_MODEL_908b66b0b2b04dbb938a1d5885af1091", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "6cf0b99de5454acbbb3a22665ca87233": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d9e6f2d52360454cb270f7448657c2c1", + "IPY_MODEL_a39f9da3cdef42c690227fcb42334c7b", + "IPY_MODEL_a4dc1cc1e4624ce2a9c641bfb7b0c9a5" + ], + "layout": "IPY_MODEL_fba27cc863a740a38bc0e126e0aa1b05" + } + }, + "6cf82dd0fd02492d9cef218fe86878ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6d05945f9329453dba40f89f53fd4f20": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6d11d3f316cc46f88289ef87d6478bce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6d52eec42efb4a779b9b4c4435f82759": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6d5464b8481b4ebfa359c8c0fd89ec2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_44bbd121fae040c88fa2a764f40581d5", + "max": 157478, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a150a36895e74e898a95c7c8357643db", + "value": 157478 + } + }, + "6d5d50937fec4e869af3027e10bcc14b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6d7b8ee5cbe2441499121a838681bd0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5b16d2ad3083499f9a5a07291f091b4f", + "placeholder": "​", + "style": "IPY_MODEL_aa4960a793b04189a258d45791fa63ec", + "value": " 2.26k/2.26k [00:00<00:00, 2.63kB/s]" + } + }, + "6d998b76764d43429c732c6d21f14e62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4ecae76ae8048779ed2b334fcc8d530", + "max": 3036, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fee1c9371bcd4d40a99359793b546038", + "value": 3036 + } + }, + "6da674a88a45457ca17b9108d2bf26c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6dabd8be9b5847d8a41f0aa702c3b5df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6dbdb16261d94be7b038380649fbfddb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_42296ffdce384109b18b58fad7e27621", + "placeholder": "​", + "style": "IPY_MODEL_2d1a5f85f17d43fb87b2bc800509bc78", + "value": ".DS_Store: 100%" + } + }, + "6dc1a941b2f44d2fb7bb039dc5e03601": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6de25f0085d048eeb3f5c2d5c7f76c1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6de32c4fdc51461d95a8479a291b9c03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ee813fbb35ad42b8b79c46c33fbb3dcc", + "IPY_MODEL_ff4463137fe8456ca36191949b989645", + "IPY_MODEL_eb3dfb287f9748a1a99eb48084b23720" + ], + "layout": "IPY_MODEL_f0db9fc0075842f3a6c6621a2032abc2" + } + }, + "6df688419ef24dcead2e4ff2b2a07f09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6df985dbe2044f4490763f1163f273f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6e02425c18dc472ba88e45b83a55f49c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6e0a479332ff481fad87ee87970b88f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6e1d6f0806164c3aa18784562dd51d3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_607f76f7a3944842bdd3b54917f0b148", + "placeholder": "​", + "style": "IPY_MODEL_e09733303b714f90895621fa2b2e30e3", + "value": " 1.89k/1.89k [00:00<00:00, 10.7kB/s]" + } + }, + "6e2cd33553c94fc78002d9093ad31d23": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6e315f348e044584803c2a96b8ed5e88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d69cf204b3684821a597b8aebeb7e5fe", + "max": 142482, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ddeeab54b32f45ad8fdd540f656952c2", + "value": 142482 + } + }, + "6e33babf78f24b0f81fa22ec13437e85": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6e58fe07cba347c0812794de7b878763": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6e718220fe69475f8f81d5c47cc0cd0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6e8c462b900a4eb2ac069fe724421a30": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6e9e9238e16c4a0296cab55149d649c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6ea49c02074b426199376c0c4a42bf7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6ea88ea2d84a465e82a4f48b221e1821": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a0ba43a1590d4a49ac45eb7d3ceccda7", + "placeholder": "​", + "style": "IPY_MODEL_31872f527cc24a54bb3e4a8a1dcfe1ea", + "value": " 3.43k/3.43k [00:00<00:00, 25.6kB/s]" + } + }, + "6eab33d5d3a94574a9ce0cddca8d8f85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_21d7a5b016154a81aa8b9fef7caa117a", + "placeholder": "​", + "style": "IPY_MODEL_5424fe192ac74067b0d5ec9e21440c4f", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "6ebbd9c7e63e4b4683acbad2d8ad9cb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_95799885148e452d993fb43bad35ae6a", + "placeholder": "​", + "style": "IPY_MODEL_7489f780a7674f6d9abbad9abe842ce0", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "6edba4d41eb3486abef33582a691ca66": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6eed31db3c594630b8bf0f5bb7df7679": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6ef35a089c8b4023b07bbd89b4019928": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6f0608f78a714a34ac018e4de6acd3d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6f1d3a8ca0b542178c47a133c7a966cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f37afcfe2f34897b3d2053ca4a9ce54": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f3ad09c51804abd8c82ecfa0828bcb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6f3b9bbdab4c43aa85593b3b6c33435c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6f44f37e0e4e42668cb2f2cf007d3808": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f72aa18ae484be6a4f4cc93ac8123c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a5de7082158c44828a00139b44330275", + "max": 145143, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ee18abdec5804d74ac0f35e55635c4c4", + "value": 145143 + } + }, + "6f921d0a315046358625155f074a6077": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f9255e6ce5e40c39eb801752197a771": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6fa6d721d66e4ee992b083165bef328a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6fa83566be0b4a6fa7f665dee3f7d69f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6fb09bcf2577485b903bb86387a3bdc4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4463650675a9405d8903eaef0882d6a7", + "max": 2384, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2fd0454e84584fe5b73f90adfca0b1b0", + "value": 2384 + } + }, + "6fbd1448ffb041b488abec7b24a46eb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6fbe54cb639a4773bacd365d6e36cf61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6fcd7ea2633c44caafa1e45b540445a9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6fd21205cf1c406a9c248ac9492b6797": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ab546d3f9ec4139886cc78517070ef8", + "max": 1061, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8ae814fe8981444ba931511ee4c6b522", + "value": 1061 + } + }, + "6fd563860dcc458a9298c51a592316c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_945ebb1ca3eb4bc09d6b52898148e04f", + "placeholder": "​", + "style": "IPY_MODEL_79a75885ba884c9f8570eee378d67711", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "6fd9b4092e8b444981680447782ff353": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6fe6a08a69e6421c91143b1c341a5a91": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c0874e3576ef406d8df9cd4ca2c150c1", + "placeholder": "​", + "style": "IPY_MODEL_e4fe1b39345143d0bcc7404b6f22a5b6", + "value": " 4.35k/4.35k [00:00<00:00, 30.5kB/s]" + } + }, + "6ff017b258784e47a9d9baf3073a581b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7008bc57522c4ff09c04fddd50fa530b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "700a1c6943ae4f5f96b93773151642a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d6931cb5d2243868481fde8b693ecf3", + "placeholder": "​", + "style": "IPY_MODEL_6fbe54cb639a4773bacd365d6e36cf61", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "700b95faeead4437b6ec909de4a0597d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "700cd041faa1463ea34231304c77786c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c02ad2a576c747b9ba4c85172ac47e19", + "IPY_MODEL_7217b9c675c44f1b9c3562ecdf2e456d", + "IPY_MODEL_f640508b0553436488c27223b5ede2a0" + ], + "layout": "IPY_MODEL_02ef1c28e3184b04854ca41c744aabd3" + } + }, + "70174b506ecb4c668217eb956d1050ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "701aa12891bd45de8c6cd5334520802f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4b0a0ee85f204c1e955002c2f17a0656", + "placeholder": "​", + "style": "IPY_MODEL_ebf1670079d84ca28e2336a7cd09e97b", + "value": " 1.75k/1.75k [00:00<00:00, 13.3kB/s]" + } + }, + "7022b61d959e4d189909e2b3a96fb137": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3bef3638b78a4e4c9deefa497ddd17bb", + "placeholder": "​", + "style": "IPY_MODEL_dc5770e4285f48aca5bb350c1fd31b9e", + "value": " 2.02k/2.02k [00:00<00:00, 11.6kB/s]" + } + }, + "702bd982dc784810a1e835f754a137c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fc053f1571884e5aa26c97a46fe2caf2", + "IPY_MODEL_35960053b50a45a2901fa5fb534eb10c", + "IPY_MODEL_e6b2412f729749b89e8a4576b2cc9e8f" + ], + "layout": "IPY_MODEL_87f1ab24adf74daaa7e75e3599d88ea5" + } + }, + "704d230e2af34a03b1c7aee793eb997b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "704fd563e97a473680d561531e925ea4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_712dfc9a8c454439b188917372ca3592", + "max": 2194, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5a62bf0ff66847c48dcd75064e51c2e2", + "value": 2194 + } + }, + "70672c0bebf340fd83071193530c2669": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ebb63ad4e2b14b1e951536f4a2b977d4", + "placeholder": "​", + "style": "IPY_MODEL_a5ec501d3d714fc5868c7657b7a12eff", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "706e50bb02e24142bf45917a7fb1737e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "707345904e55482b819c9e14b477c5b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "707cb823affb4cf98155fab0ac064180": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_988076fe0f114bfaa5cebbe01353ab89", + "placeholder": "​", + "style": "IPY_MODEL_180d4216ba8e45d18bd2992f8b4b2957", + "value": " 1.41k/1.41k [00:00<00:00, 5.74kB/s]" + } + }, + "70832079707e4fcea00eb70a891f4e28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "70894ef2fe214fd29200f64e3b494479": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7093600bad454a5589efb814b9f1e9fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "70ac8924ace042e984c0d60cfe3be42c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70addfc07f454d249c15447ad13db71d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "70bb9601b5c14b56bab2122d6e767c97": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70c2eb47a4f64ff8b2a1707b89b9d78e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0ce6fd1c1f25467b984c088051d3d931", + "max": 6299, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0e96c529407f47f0ad1bea298aa17134", + "value": 6299 + } + }, + "70c5dea767024da2934dfc11db647bce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70d596c04a1043f2a16eb12a4fd88542": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "70e04eefe5dd459a9a18af04e155a109": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "70e6b6296e4f43dbb15bbe24b9cb56b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "70fd1b06cf0745e88093c031296ce6af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "70fe3fff23e14729beab290180ebfa5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ece0e8670b7240c1bc634097d1798f25", + "IPY_MODEL_9c7561a026944e4e9d25e60783110fc4", + "IPY_MODEL_9503a5aec8a940a798163249bb0ed2cf" + ], + "layout": "IPY_MODEL_f8607237a89744c88e0f57482f629347" + } + }, + "7118be5d336742708e524cf7687a18eb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "711a038bdaed47449823cc0efb7f7c11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7ed3da09950548aabb1e39f14c9fb3e4", + "placeholder": "​", + "style": "IPY_MODEL_2b547c7b6b85460dbc49c5ab5f2e6a60", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "711bc2c51c204f368b2425bb389b101b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "711c500b0f5b44818fddbacb4c072a48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "712250b09e3241d6a3cfd19e7de50ca7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "712dfc9a8c454439b188917372ca3592": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7133fde26d6f4718b463e39efe8ceb7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "713afbd7a58743699024314c50961d3d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "713e5ea5e2e64d478a76386f5c76e35a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "714e2f7146f34f74867a15318d405ab2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "715e37d5a1004183b85db46946844f77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9caf1757f9714668aa70edf835fb3423", + "IPY_MODEL_4885d3a7ad7143199296706f373e9e40", + "IPY_MODEL_92af150fbb614af0b7fec0d35eda0e4e" + ], + "layout": "IPY_MODEL_a4073c2f1fad4c4d89c16d411a96af6f" + } + }, + "716739fcb3284bac8c1f32ce224e6e0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "71733d24df934df7b1d75eb01787dd80": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7188f25ef10844aca4d4ac8648df114d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "719196d77688488eacac1beda20f3599": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "71a41e11038f414aa8e796a1a505a23a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "71aef9c05f9644dcae99d118e54ab912": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71b1dc83ec024051a2ae53b75fcc5105": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "71b27373c492446a97b3af5c73ad6343": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71b3ebabe84541278c47b53878f0719b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71b9abf29f824b589d391d58bbec4d55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3c6e226c17f9479592f983fb45b19c64", + "IPY_MODEL_aa521c976ae644c3a70ee4472709c9f6", + "IPY_MODEL_3c63aca96c664baf9ff352d9e0bb0139" + ], + "layout": "IPY_MODEL_e2d7317b33d847c99c060d9d8b080105" + } + }, + "71e2de7dd50d40b29dd44aa8e21bab44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d31b5066db74913a1fae6418c7870ba", + "placeholder": "​", + "style": "IPY_MODEL_d927bb346d2a4b75bb27c482fc0b5b8e", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "71e486675e2f421aa991a45d70df33f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f44052810219462496d0e5c140aa60b9", + "IPY_MODEL_1f7eaa1a8d90453aad24d4f24ea6d441", + "IPY_MODEL_f2df55cf40fb4a858fd254065a26bf7c" + ], + "layout": "IPY_MODEL_0c872c1b095a43ba9cf18798081c5e73" + } + }, + "71e607ae05bd40f096a593a8420ca9b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_95d12f3de0ec4c1d9b4b15e810e4af44", + "placeholder": "​", + "style": "IPY_MODEL_b39b3240183b4a05a08895f8e7c14194", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "71f358137fa04cdfa432dffd3239f1b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "71f3a8fc5e994acebad8260bd23e8e76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71fc8a0fd75a45739abe0b8eed824e6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71fdffc88b4543fc9059ec6506c461be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_939a9ad240c1492f85ef8fc4a20e1161", + "placeholder": "​", + "style": "IPY_MODEL_f75cf6f7fb514466a68db9b86699bb72", + "value": " 2.07k/2.07k [00:00<00:00, 7.69kB/s]" + } + }, + "72034c1d74ca4f2ea9f917e89b8ee29d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7217b9c675c44f1b9c3562ecdf2e456d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_015f71364eed4c439eff58a2b3c77a5c", + "max": 1624, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_33e48a7bfe2045daa8fc155ad02c745b", + "value": 1624 + } + }, + "7233e536c38e4e4aa49ecde4329533dd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72465fa73f89458292847e5bcb53491e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "725860cfcdc8462b8381a373a2afabba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a80efaf7b6c644159d80c65a0539a2ac", + "placeholder": "​", + "style": "IPY_MODEL_168b2ab93ab64e9d910022d359efd6f3", + "value": " 2.99k/2.99k [00:00<00:00, 17.3kB/s]" + } + }, + "7259b23bc3f44d1c9cb6fb5f058e18a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_17ad1cec7f0f4b15a07270714a498c84", + "placeholder": "​", + "style": "IPY_MODEL_c116305c4b1f46df87446a3a512b3141", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "726063b933d34480a3ffd4ed226f614c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7260f2ba12d345d1b35ae29b6c568a17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "72685e4c6b724207bfa1344ac2684d52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3b2267634e1f49228ca31c1891e2bb30", + "max": 1304, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9513e91d07d84ee49d09ed90d22f0ca9", + "value": 1304 + } + }, + "7269294bb59049308410718becfdeed9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_614e6b94b0ab4bafab6e1a1ef6795c86", + "placeholder": "​", + "style": "IPY_MODEL_db4e5816dd86453a935f75f62db8f361", + "value": " 143k/143k [00:00<00:00, 548kB/s]" + } + }, + "7274b6fbe1044d45b9e7d8693f1b4281": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "72765007ce1641928ff20a2f372b8812": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "728437dce3cf498cb8f52e9cb0365b98": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b7a43d5a5054372bb559f527ff86954", + "placeholder": "​", + "style": "IPY_MODEL_b084e5da24aa430f9dbf471fb7f35fcf", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "728a7dce1de34c139acd19513aadc8ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "729112fdf5c447e29f87a203a2e6a266": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72c4de84ccb444e099e565c4e7748966": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72c8f005b1a14b588695ae38f5ff0fe8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72fabb44a9cc4568b465e1f3c87ce37b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "730c1cd2bed54619b5dd17388afc63c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "731768b877c748b9ae5b90c7f02fe7bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "731b59a8996940a8a962df4c390e19ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3cee7ed2b4384cb0addf1dc3278c388c", + "placeholder": "​", + "style": "IPY_MODEL_1a801289b0434eb1b06bc61a81b01fd0", + "value": " 2.34k/2.34k [00:00<00:00, 10.7kB/s]" + } + }, + "73253e9a84b0482ab7d7240a77fb8a9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9a3768a9ae124944ae58bcff4444b4cb", + "placeholder": "​", + "style": "IPY_MODEL_7628cb87dc984915b0f721d46f0037ff", + "value": " 144k/144k [00:00<00:00, 715kB/s]" + } + }, + "73264053e79f497f9184cc75908aef28": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7365a05d5ed54fa2a99de837a2b5b5c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "736ff172b3f548f490eb268865a583bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "737202af86744c2fb223d0c4b34febd3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7375ba19c24e4182883b1a2b50b839c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "738f32f7f29c44fc88066afc920457d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7393c00640014b1b8ba8fabb2521bef5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "73a96590fd47443bb964334b454db653": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "73aabae894e84cefa72982cbdfa7d23d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_72c8f005b1a14b588695ae38f5ff0fe8", + "max": 1526, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dd07e7bd9bb949e0923baea7292a073b", + "value": 1526 + } + }, + "73b42a3c1d374ac585572ed9c1c1fe67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "73bf239c583d467b883c2cf30536997d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b94135dc08114fbba0f1f81831cfac08", + "IPY_MODEL_7eb8af422a414cc58cc29b6925a5c487", + "IPY_MODEL_1fb86c477e884eeeb1457d22adf04760" + ], + "layout": "IPY_MODEL_9b576ca818594d3f801623f2013d7a0c" + } + }, + "73c72a46ba6149a58baf02acf5b6d2ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "73e39470c1574f98b3c1c54bc31c3043": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_451d132e9d9f4133bb88746cd2679b7b", + "placeholder": "​", + "style": "IPY_MODEL_ae7001499fcf4bcbb08d6e54fbb6f264", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "73e5f61865074e8581d48098e8893974": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_55ae7fcd1714494fbb43078353612233", + "max": 1541, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_050b959d20b245cbbbb71c1056b2756f", + "value": 1541 + } + }, + "7401875e8f8442aba660ea1a97bbf58c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74064bf6cac44fcf8ca51f749275eede": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6dbdb16261d94be7b038380649fbfddb", + "IPY_MODEL_7841660c9ea34d37a4aa3a31bfe9db45", + "IPY_MODEL_0c4a2c3408b84fce9b91c46d2dd7cb55" + ], + "layout": "IPY_MODEL_dbb46cc39a66473f9a7405c2d846d84f" + } + }, + "74136606b4eb4ffcb008c76126920186": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7414155e2886401cb1a3eea5c77b3393": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74389671135745ce80b98ded35d0ea89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "74581f0a19d943dabebed3e31b5b7e8e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7480a759285f4cf483a874aba868ae88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "748290a07b884488853d060a4f8c5f5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_88877c9b788d49c9b9b937ad2e1a22cc", + "placeholder": "​", + "style": "IPY_MODEL_e7e34bd06ea94425854ab9722b05f5c5", + "value": " 2.82k/2.82k [00:00<00:00, 17.0kB/s]" + } + }, + "7489f780a7674f6d9abbad9abe842ce0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7498e6d438f94cbab0b49e1109d59302": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74a30ded055d4cf1ab99b9e248aa2d2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4cc5fa502f6b4323a2bd58785b126ca6", + "IPY_MODEL_d213346f2edd4d7f984ee7dbce71c906", + "IPY_MODEL_6617747f9a554c2bb97c62338263afdc" + ], + "layout": "IPY_MODEL_bd3b0404b995407fb78fa52edb575f8c" + } + }, + "74a6cfb82aba440da8fa2b57f05366c6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74ab3be8e85e436a9626b53fb6f70198": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "74ad264850754fd4acb99cbb0a4c3eab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d1463a44292e48e99a710141a1fcc7b2", + "placeholder": "​", + "style": "IPY_MODEL_0f8a73eee95d4d209b9dea011727b9ac", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "74ae97551d2846c7bead04dee684d507": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74cc7aded9fe4ab9afea0a479a6ce7cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74cf1532bb0947f5b81e6ac9afaed8bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74d1c88143734ef79713dd7c71184ec0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74d722d07c1a4392831f6108512ddd1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb1fc1769deb4cbc87f8c99da23353aa", + "max": 2854, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_040a25cd86284d1a9b4a61574521ebf8", + "value": 2854 + } + }, + "74f183b45dc349bba3effc2742dbdd29": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74fa7a110d1a4229acc6ded65e628be8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "74fae3888be24e9f959e52c7cee24aae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "74fe6cd7a8ba4d12ba1bddde62d946dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb13db3c3ad042df8b9c469a069c6bec", + "placeholder": "​", + "style": "IPY_MODEL_f9c1c7c353dc466892675f5bc0530d9c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "75006769140d4f38aedb3bfb89fc0ee8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9fd8f783faf04946a7aaf94263787467", + "placeholder": "​", + "style": "IPY_MODEL_cc3766fb4e1041dea9679e6672f17622", + "value": " 147k/147k [00:00<00:00, 301kB/s]" + } + }, + "75066a0903cd4262b593c23c62f8f9f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f39d3f07fd2547c39e9de088eedc57dd", + "IPY_MODEL_1a9afe25ab384aaca232705bef1cac1a", + "IPY_MODEL_b184f455b61442b28789c234f97690b4" + ], + "layout": "IPY_MODEL_6215b59f73324b3792ca7c3790d251de" + } + }, + "750d9e6e23c844cfb4703c6dc124474d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "752e5e49a1264055bc6b9fe9724163a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7534810f3a124c959474b081db29e28a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "753c6c7221e04fd6840d49e50cc64f9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "753dbe1f1ba34123b437b70193c4bf07": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "754647f26ebd4146a39d78f8e45ecf33": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "754dffb1f0cb4708923b71a61f350256": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "75588186399a4276bef1133904e0ead3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7ac8c0ce33584ece9c4775e2850a9c44", + "placeholder": "​", + "style": "IPY_MODEL_cad0e5ebe1ba47b1bb1d2087ec579fa6", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "75658e3eb979426abb55b1fd441177a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "756d4b04e99f40e98e82589a80b73c53": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7578790aa4ee4672941232bbda5b17db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "757c86b9023343fe8e14990bef7f235c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "758b24b75a2b42c890182b03f4f178ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7599031563994e95abfedd0170aaefdd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "75997d4ff5af4d1caf9af6112e9e9d7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "75aab476b5ff4b678e58b68b69e5f399": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_81eec735a77849c8b0d0100a64d6eac2", + "placeholder": "​", + "style": "IPY_MODEL_8863e06bf3f44769b755a28637cc0b71", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "75b43141679d485caead431ef33921e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ee1af378e6e44b92835f1682ef857109", + "IPY_MODEL_5a9e5b72ab1e40dd923705e1bcf3b6e6", + "IPY_MODEL_9cdea6f6a01b48048a7d1386938b55be" + ], + "layout": "IPY_MODEL_35ae88dafffe4c7aa944753177293dfd" + } + }, + "75b7eb814f6b4901b96af72ff0907cac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8f653efd4f8444668240e11ecc185b74", + "placeholder": "​", + "style": "IPY_MODEL_856988ad083740d39d2b7a7933eab75f", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "75c5a84a1565416c92c100297960a246": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "75e7368792d24984a87b240693a4f816": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "75f08770242141369d6d491ab224c70c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "75f2e5264992412f98215f1f829f71f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ab6ce7d3577c4541903b165bc8092f8e", + "max": 3030, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e0c6863ca51c482b9b8510b1d96e083c", + "value": 3030 + } + }, + "75fa2320194a47e7a72f9321308865d4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "760be2183fed4dd6ac46ee24698963c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "760bf81784eb46e6b0b97c0316400c50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "761d1cba2f3c46cab7a3a40c992563b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3704e2768da445518ea06c00cee952d1", + "placeholder": "​", + "style": "IPY_MODEL_c71829aa97cc42f9998a0b51c5b8eaa8", + "value": " 850/850 [00:00<00:00, 3.93kB/s]" + } + }, + "762887e0b0dd4e8e956b648a15e54046": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7628cb87dc984915b0f721d46f0037ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "762a8ad531d2406c9699a68676d076ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_afd7c3480e8647e9a8337bdcb17cb14d", + "placeholder": "​", + "style": "IPY_MODEL_fa8f1c9ef17a4c7c94a8145b66d95c4d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "76573c67b65e4aebacbcfbcace4aa931": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "765d7f46a8b9488f8452c31d479c7ca1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "76739e29d0f84bcc8e9ce68feed13dc0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7673a121cd6f49ae823aa50f616037c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7680a1f18fe24a4c970f83bdf25bc59f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7684fb9fd96f490194a2822932589810": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4867a5b954654f97a808337beacf23fb", + "placeholder": "​", + "style": "IPY_MODEL_60cc53f575444e419aaf840ea5fb2554", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "7688b9cc857849fd9f6ee58d6f83ae2c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "76a1964c0bdf477b87110c978e359b86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_79b23eaac99c402b8bbe75e5914ddfeb", + "placeholder": "​", + "style": "IPY_MODEL_1a9657a0da9b422e8f7e18ef9863d50c", + "value": " 2.50k/2.50k [00:00<00:00, 10.6kB/s]" + } + }, + "76a7b024888c4adf90ad9323706d8ffd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "76b892ed01404b85b197ac2e023da302": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "76bf4f9e50fd43519aec2b7bc69f35a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6fd563860dcc458a9298c51a592316c5", + "IPY_MODEL_e2cead14e99d4093ab98f83b2cd201c4", + "IPY_MODEL_f5a90544c5004dad9ed5c80a0618f3c1" + ], + "layout": "IPY_MODEL_0f5f10031fd54f1c8ce448bcc2fe4eb4" + } + }, + "76c134c8b7a446958142eb4c7b2f2f43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7a95c7eed6bc47408f9b919387ca9822", + "IPY_MODEL_793760456fff4283bdcc45ddedaea01c", + "IPY_MODEL_c8267273c5f344349591e6fe7bce37fa" + ], + "layout": "IPY_MODEL_1a19174cdb59426baa88d9a11d68ab9c" + } + }, + "76dccd35cb3a42288e8e787c818aa51b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "76e37ab3a5bd4f10a557f1d2cfaa9b5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "76f0f56afdc64a508a6909e9b1f00d12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "77159464773a49c4babc2c72c5bd13e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4c1e6e503e74bbea3073f307b9dfdde", + "placeholder": "​", + "style": "IPY_MODEL_bb0f547a7db84fdea1318f7ae7c11a1c", + "value": " 147k/147k [00:00<00:00, 760kB/s]" + } + }, + "7729bc4a6aa14796947be4b0ecbe761b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7738fb82cb004ab887d7ee39505f372a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "773c8544c7464f89a3cb17576f359a09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "773cb45aa3d641028a8e020327a3e4f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f36c1b53da014bcb8b9266c503cb4ae1", + "placeholder": "​", + "style": "IPY_MODEL_cbd20dd0898d43ef8d4411306a7a227f", + "value": " 2.86k/2.86k [00:00<00:00, 7.86kB/s]" + } + }, + "773f789cf8014daea99bc04480af5247": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "77424cf0da1941da96c94e0da10bb7b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "774efbfcdc6147b78e2b23fbdcf34e6d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7759eac59dd94abd899fe9febe971dbe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "775c5c12de294176b14b4bb303272eb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2daa6b90a16342b7bb772fa5dddb0bb2", + "placeholder": "​", + "style": "IPY_MODEL_77a30ee82a7f407a909789ce7abee811", + "value": " 1.63k/1.63k [00:00<00:00, 10.9kB/s]" + } + }, + "776074ec97de445ca95fb3e113dcf409": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "776e3ebbef23444d896787b29ecf3c5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_986703b1ff2148938337cdbbbd15cae2", + "IPY_MODEL_20e2c11acec541e0bfadad723ef5538e", + "IPY_MODEL_41e290f61a984e4bb44c082cbf4daad0" + ], + "layout": "IPY_MODEL_ff81cc209b8145f3b50f1d50edf990e7" + } + }, + "7770f7787a6845779a4e6bccda4ffb5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_68fa94fedd394127886a591c687f05ee", + "placeholder": "​", + "style": "IPY_MODEL_35ebecd771cc457785de57f51447bfe9", + "value": " 2.50k/2.50k [00:00<00:00, 13.9kB/s]" + } + }, + "7772763a98dd45beb1aee9eb265ad5cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "777f681b6f474921a3b73e8d10106cea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "778b7ad8925a4fa7aad46835dcb57b87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7795acc19a974a05b83b1b1004f00d15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f463926058a04395873c79f0ee391b22", + "IPY_MODEL_8771fe3bcf3e4fdcae530abf98fd7e64", + "IPY_MODEL_576346dd58da4dcfab6d7f5e246580b2" + ], + "layout": "IPY_MODEL_bdfced5e609c4779aaf91e0f4f43329b" + } + }, + "77966e966386466f9321c900b3674941": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9d3ac651945745c19fe033679b94bbf5", + "placeholder": "​", + "style": "IPY_MODEL_af0b19592d5e48a69c3cd773456ab8aa", + "value": " 160k/160k [00:00<00:00, 827kB/s]" + } + }, + "7798d8869ef942ccad0311cf2f022b72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "77a30ee82a7f407a909789ce7abee811": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "77ab8254e226454bb4d8ce7646d700c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_71733d24df934df7b1d75eb01787dd80", + "placeholder": "​", + "style": "IPY_MODEL_50e27aeba00948f6b70e034f3898968d", + "value": " 1.57k/1.57k [00:00<00:00, 7.56kB/s]" + } + }, + "77b1480126cf4316a2f0319887ace0bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f5500e5415b74d97b7bc3a72bc69b291", + "placeholder": "​", + "style": "IPY_MODEL_ee65a4958c43430b9eb1d2564b99770e", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "77bb6310118f414e82b3e04c26f7a9db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cea15cd46db54d4797d05d9c7eb185fd", + "placeholder": "​", + "style": "IPY_MODEL_1b76fce471b74aa0bcf6f18d0aa89452", + "value": " 144k/144k [00:00<00:00, 263kB/s]" + } + }, + "77da7311330b489f8ed1c087b385a257": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "77e4c526c8b843e5a9a1cfdf351b18bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a46b4a0c2ebd4160a469c11053509add", + "placeholder": "​", + "style": "IPY_MODEL_58de58f414dc457e81713e54a3d536d5", + "value": "Fetching 2111 files:  92%" + } + }, + "77fed7bba6fd4024b4967e5ff9dba850": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_22416e43c09f4592bbda3b851294837d", + "IPY_MODEL_dd61191a424040fbb50d7765105fc4e9", + "IPY_MODEL_bfbea7345d3d43a0b5fa8eeb768abf4f" + ], + "layout": "IPY_MODEL_5da26396fa7748f9b27e8db11f21619b" + } + }, + "780fc9d305094aa58637b0c517a302f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2a6f40375d9f40b49ccf6c8f1e99d4ec", + "IPY_MODEL_48d9d6dfb93b461eafd2b3181a4323b7", + "IPY_MODEL_8068643b38104473a7d5875d4894f412" + ], + "layout": "IPY_MODEL_57b1b7eb43204bcab8577d07957854c2" + } + }, + "783cfc22f62d457c8ea6e76a5114f0b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c93dddb837ed4cf7a788d08f28354522", + "placeholder": "​", + "style": "IPY_MODEL_684e9c9e4af64f5a865aa6531540f04f", + "value": " 1.35k/1.35k [00:00<00:00, 7.34kB/s]" + } + }, + "7841660c9ea34d37a4aa3a31bfe9db45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dab6d609cd404d2180a7c7dca67875bb", + "max": 6148, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_32b81290db4e490697d3e6fee9b14284", + "value": 6148 + } + }, + "786450970b1c4d93a25e3414836cf346": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "786687e380f34f7bb4ce3d4b02f42c9b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "787f9882d2314d488dd65c3dafb84612": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "788dfeb8dfb34b81bec2591864c4c6d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "789a2ebbf777433fb2339b8af2f907d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "789b7210015b4d63bd5454262b25ec73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c48f5699233240ddbd4eb746d2d59ebd", + "placeholder": "​", + "style": "IPY_MODEL_e800ba72fdf5409d9b8614a27bbef8fd", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "789e1e4d6a59437591b7c4d36dc26165": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_711bc2c51c204f368b2425bb389b101b", + "max": 2405, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f87ab56c33ee44c6a36b27a5df00f133", + "value": 2405 + } + }, + "789f81733f4f4df7bc784ec7485196c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "78a8ca661ed14e55a2555b9f2d1dc4c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "78be75b0033f40fead4eea748740f0a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a4b0f70059f04e2280215894d40bb895", + "placeholder": "​", + "style": "IPY_MODEL_28332ee9c2a14cc6b7e3d06a7378ae86", + "value": " 2.92k/2.92k [00:00<00:00, 7.97kB/s]" + } + }, + "78defad018394d35b496df6106c0283f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "78e0f03ac87a418aa827a2024ade8b09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_251cc33a4ed745589cc1ab0fbf1540e3", + "IPY_MODEL_5fcdb7e7deac4551866f9142a633a53f", + "IPY_MODEL_38b10a8402c34e779cbd0bf5553268d3" + ], + "layout": "IPY_MODEL_ad53f0c84fc54f3ea17d4998a8ffb1ee" + } + }, + "78f8f8f50bc549c187d7f727905bd0ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "790139771a45490f80feaa97b17d9b48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "790d48212bf24d33a50f05f77dd317f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7919864fec9746989e6f68de634cc1bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8f580fa566b64c7db9c64699e1730e8c", + "placeholder": "​", + "style": "IPY_MODEL_acb1abf03f6844f8833c068f4f885704", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "791bb34ba1d4414e879e7efdb8acd155": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7925d5dceadf42a5a29af6f3979e393c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "79297e990e3a493b915cef5f9aa3b992": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7933eb2238024efe9c6395f5ed48faeb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "793760456fff4283bdcc45ddedaea01c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a67a602b89314ea5b7dbba1696f4d6f3", + "max": 1924, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d803fa06eed4414db4e9d722dc67c57d", + "value": 1924 + } + }, + "793acddad31c4bb19ca6fb7194983e68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "793f64fb3f8a4ebeb14615c6c9dbcd71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "79477c56bc71468d9b800bf4a5003163": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dc7492fc0ac541e28b3c9fc471d6574b", + "IPY_MODEL_7c993f04a350437193aa73eb69314d10", + "IPY_MODEL_acd786f9c6f24ba69acab672b3fe5ea7" + ], + "layout": "IPY_MODEL_9a766bb59370460bb7336ec1cb4f4d2f" + } + }, + "799dbf6a95194464a3db6daf3979387e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "799dcf103c144ee393756091aa161d79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2c9c1d333b36434fa07beceb0ee238a7", + "max": 3878, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8c8d377f8cd24861b80abb3f6c0a595c", + "value": 3878 + } + }, + "79a75885ba884c9f8570eee378d67711": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "79a7c868061b4a9da72d2d14110ddfee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "79aad48ac89f4dc4a4b77a75d117bdff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_73e39470c1574f98b3c1c54bc31c3043", + "IPY_MODEL_92d2d20c50b244aeba5ab105a75be8af", + "IPY_MODEL_149008619f9048d28074923f49f774f9" + ], + "layout": "IPY_MODEL_5a3cbafd8a0a4a27985c1d6197103422" + } + }, + "79b23eaac99c402b8bbe75e5914ddfeb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "79bc3b34da6e458e88b22d6ce97d3e6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07dea9075f054ff0afb4958aebe97d1c", + "IPY_MODEL_3b7b11f1e2dd4b0ea4ab33dae8cebfcc", + "IPY_MODEL_6fe6a08a69e6421c91143b1c341a5a91" + ], + "layout": "IPY_MODEL_e401729096864937a0a132f459857c14" + } + }, + "79c8fe5f3aea442cab40b92f3db8e2de": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "79e4a8e012d94076baeaf17dd16b1e33": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "79fc2fa592ff477facee14d99c31b344": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d8bc89c72995463b900f8a6d114b80b8", + "max": 145013, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fec348f0b4c148c68462329045ce0906", + "value": 145013 + } + }, + "79fe4426be464d77ba9c8a536abbdc75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f34bc3d10342461b856c1235be42e31f", + "max": 144474, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_204332fa93b54f75b1c2fcafbd018c1e", + "value": 144474 + } + }, + "7a05a08964dd4565ae4e3ac13f58beea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a1f89254da34a10ac8379f86a84006f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a25400b974c414ea0576ac347084717": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a2ffa1cfae24e9a9f83fc391b67a9b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a3c50931b464aac9f4644c13baaa33a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a43be29be164c52a8874d62a01b29ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7a57c1af83a44672b166142dacc14c80": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a5a7afad20c41759516c69679a40801": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a6c7cae9ed04884bc334852957e7f3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d5ca6ac4b8314c7db61bc4ebd23650cf", + "placeholder": "​", + "style": "IPY_MODEL_47915a3973444f849131dac1876592e1", + "value": " 1.43k/1.43k [00:00<00:00, 8.23kB/s]" + } + }, + "7a74a44c253144c693a6315fc38c954b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a7d423ce7e64b438aaedc183bf737f7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a81896a1540408fb81802d34af6d0a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7a8b331f92414356a8468befbc33fe7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1d87355cc14940b591b3bedcc45490fd", + "max": 2799, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fe4401b6c2824f65840bc20bffd0a72a", + "value": 2799 + } + }, + "7a8e58d904bb48959b2e3b00415456ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7a95c7eed6bc47408f9b919387ca9822": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_699d97ec26fe49aa9c2b76c4e965aa1a", + "placeholder": "​", + "style": "IPY_MODEL_2872f962b1f34aaeab3c4f8340c0ff37", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "7a99c9c0f0ae4e9e9413e0ee205a44c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7ac21f84dd7e4061a07424733f6b2d93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7c66c2d5ab3549c28b62a9bce81324cf", + "IPY_MODEL_0d31136a544f4388988a76018dd3e9d9", + "IPY_MODEL_b1eb53ce8e254ab09c6383706762b49b" + ], + "layout": "IPY_MODEL_e32dd5c3041642f09e25b870b59d18a8" + } + }, + "7ac8c0ce33584ece9c4775e2850a9c44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7ad5e26c5eae4c4ab10eb921297c75fa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7afc037dc8e84d469137169c324e0dc8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3fb51e4e74ed46d19d5b9a2a76b70068", + "IPY_MODEL_9f6711a2bc384acbbf9740b1f4cbf02e", + "IPY_MODEL_a3aefbd9a35c40dd9fa4abd7277d3713" + ], + "layout": "IPY_MODEL_d6b4b9872384434b85f67d1f3b7dafc8" + } + }, + "7b1668190e9a4e75ada8fc16cdd293e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4593bb3cd48045acaee0ee5c76ce7629", + "max": 1077, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_312e855fb1e84c598931d320294e9ee5", + "value": 1077 + } + }, + "7b19664b1fd84bff82c38f3baae208bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7b1a77fc9b5647fd9393fbbb83524204": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b27d909b86949e4a325fcd38dfe40d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_43708173f313479b96457c9970ab3632", + "placeholder": "​", + "style": "IPY_MODEL_22e582d624024a988607b3b2c0e78b0b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "7b285f6af8b24e75b975ce0c9b8b123b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b3f0c64fb1448e2bcadd44ca6e854d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d121308bda2c4b48ba790d78f1456d6a", + "placeholder": "​", + "style": "IPY_MODEL_8d23029f0316460abce925cdfc0383b6", + "value": " 5.07k/5.07k [00:00<00:00, 23.2kB/s]" + } + }, + "7b45a999b8c841b2a4c21f63342c3d03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b4b632386f349d7a48f84c1bda8af91": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7f5e1d38942e4da580e7dbd05c66a0b1", + "max": 2677, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_aa0dbdf05aab437691a6eac118056bb6", + "value": 2677 + } + }, + "7b5bf18e866446c6a3c9cab8dfcecdd7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b6f4fbf7e1e4751b5611017f36a9167": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5c25a19cd0cd4a99a03d5553ea9ec49b", + "placeholder": "​", + "style": "IPY_MODEL_ee8e19490f674f7b8ff9983686aae74d", + "value": " 3.86k/3.86k [00:00<00:00, 21.5kB/s]" + } + }, + "7b78114f88854d40901d056f4c0a06be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b790a6153254014ad7351b2de4cdf5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b7a43d5a5054372bb559f527ff86954": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b7d5d969b5a47ebabbd99d1909f0514": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7b8e56a985c34020a97d95bbe47b29e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7b9044d898fe4a8db49930b8d0a16a18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7ba36718aac54e0f817b667c6e0d588d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7baa110b686f4f4194335195f8931353": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7bb5f31d145b4a25af71437bb03bb7bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7bb72454006b48909ac6cefb12826232": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7bc765db15904bf3968fd26a6406a7e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_08d4a2629caa425283be9c82d2613968", + "max": 3265, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3b4f37a47c634e6e83e25eacb9f47c5e", + "value": 3265 + } + }, + "7bfaab94bf584c42828b5b92c24f8905": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7bff6f925d324ecbb6f97882a219a2a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1f88d7442ee94a37a6ddca1f0e50de7c", + "IPY_MODEL_49e38f860d404153b246c200eebf03b3", + "IPY_MODEL_a5081b80f0b24ef5ace2d992b175480b" + ], + "layout": "IPY_MODEL_86619392e7df46efaf2416ad390cae42" + } + }, + "7c343847bd774c95aef358fe88072b37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7c38c9ba91d14de5b6cf14bd2b18dd85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b41246a8aabf4aaf812d29e09e0c0fc7", + "placeholder": "​", + "style": "IPY_MODEL_b0b019c301b14ba7a60f9d961987f508", + "value": " 3.29k/3.29k [00:00<00:00, 22.1kB/s]" + } + }, + "7c3a989cceb64e06b7595eb8cb542bb4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7c3e444e8fe64590bf030695dc5f0a19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8d9dc33eb2c243bca30a0f3f94063ebc", + "placeholder": "​", + "style": "IPY_MODEL_f8ba7ac1b82e4f5ea6fa36fe8ac3fb1b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "7c50c70954a1433c98bf3cf2da698dbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6617e213ffba4ef4af19f63b0939cdd6", + "IPY_MODEL_0b41cf7365494aec9691f3b28287c111", + "IPY_MODEL_4b225bcbf96e456d98a553fc3f494ed2" + ], + "layout": "IPY_MODEL_43509a48b335439e84c8f7a7cacf11e4" + } + }, + "7c5515b341b743e2927c91f8556fec15": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7c5f87ecc5df42fd8b185546177187a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7c5fe9b9a6884fb7903de40ea1b2d5e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba0124f48230482a80747400bfc4e78a", + "placeholder": "​", + "style": "IPY_MODEL_8e589f2532b547ae88df357a0f0197e1", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "7c66c2d5ab3549c28b62a9bce81324cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3f00354518d48e98e9e21a905372f73", + "placeholder": "​", + "style": "IPY_MODEL_7dfd800c4be04befa7681c4f2b12f8a5", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "7c7143100cd54ac9b8424b519bca48c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7c7818be3336437ab670db3a68d2a759": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_63c8ecd3ffb942dd9707463e7f8e5aae", + "max": 4075, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_62234e8f9ce34b7aabf94970af782bb8", + "value": 4075 + } + }, + "7c79b6fffe22465e9225d878cfa39b4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7c7c32dd8a6e4ce38e89f8f9019784bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f16f6e3070f846039b86abbad6b65046", + "placeholder": "​", + "style": "IPY_MODEL_b7f79062781b494486c5848b9cd7fbcf", + "value": " 3.43k/3.43k [00:00<00:00, 14.2kB/s]" + } + }, + "7c993f04a350437193aa73eb69314d10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_81f6d8bd910b4ef5bcf3c2b7c5a18328", + "max": 1797, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b0bb12259d034c9fa7333a1b66ad58e5", + "value": 1797 + } + }, + "7c9cc0be1f4c499f917c19ed23904829": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_21388718ee8747c1b7fe0e11f69b4e21", + "max": 2878, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e18d8f4beb434665a6b48e61d073acf0", + "value": 2878 + } + }, + "7c9e85ecec3b4ad48a19ea2a055a2a34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_60293ce133dc4a129c0b7b749ef9e69f", + "IPY_MODEL_789e1e4d6a59437591b7c4d36dc26165", + "IPY_MODEL_c04af8a840ad47b1b5c4fba66a5d79ac" + ], + "layout": "IPY_MODEL_bb7092a8385d4a6a985ca01f8baa524a" + } + }, + "7ccb9fb06d9a4d5bb74f1a5a4ec7be24": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7cd8e9e55edd4721b4e64d4d130ab3c6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7cf82e8870a0457daffe713685ede248": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7d00948f1b694a28a99ee8549cf7bf93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ef046ea175444331ac5bb0f6f8ea9269", + "placeholder": "​", + "style": "IPY_MODEL_f731705dec8640ec950c92ec5993ab82", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "7d050b63b8c94a1581155239762ce4d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d378f6252e24554bc0c33568a1bf8f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b210043b913d4294a7d182416d5b2797", + "placeholder": "​", + "style": "IPY_MODEL_2f0b7953946742858fff8961bac868bd", + "value": " 3.18k/3.18k [00:00<00:00, 14.1kB/s]" + } + }, + "7d3ce71b88af4d0884574117e6917505": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7d40351fce40422fb3fa8f188bc667d2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d4110a9d025478080705fbe531d000c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7d57a6f52764436db8363e73e77a0ccb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2039e262be184e239d0f9cf62838aef1", + "placeholder": "​", + "style": "IPY_MODEL_76f0f56afdc64a508a6909e9b1f00d12", + "value": " 1.47k/1.47k [00:00<00:00, 7.25kB/s]" + } + }, + "7d5c30ef47f64f3dbe445261da651fb1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d6538c795a449cbb04a94e40e235d0e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d74d727cc3045d290d146edcdf10eb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_16bf4027fba243b289c11ed0d42a7557", + "IPY_MODEL_26e5bfd2134d4cfaa63069ca47768f81", + "IPY_MODEL_8e34e2d085d7434e943d84ac06fe4c66" + ], + "layout": "IPY_MODEL_53122628973643a297664e80deeceaa6" + } + }, + "7d789106e7ae4f93bc106c47b7a71881": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7d7df712f8184a4eb6d096d75a4467bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d92f14f0f4e4c7abe96e93e9b14d12e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9a0dfd4400c045ffbd6b6232f101dd2a", + "max": 2736, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_953070b85fc840dbae65bca07eec8112", + "value": 2736 + } + }, + "7d9a49ae500149beb8034f206e29b47c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7da794f9cd444197820a9e3a0a6e576d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7dc6a715f9c6467abdce237373511692": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7dcc3afe44e241f29a55bb9c07946ebe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a1ba962317bc4339977ead5cd1c0b878", + "placeholder": "​", + "style": "IPY_MODEL_b2b48ed771dd4097a1ce338d1aea6f5e", + "value": " 3.09k/3.09k [00:00<00:00, 22.2kB/s]" + } + }, + "7dcd95c81ee9442cb12cb77ad36a13f1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7deac3978f9741efbf36f85fbdf4e826": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7dfd800c4be04befa7681c4f2b12f8a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7e0eb9be09ce433f837fcba97f4185c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7e1a5444ba6b49ac99bc9e733ffc04ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ead887bedf71461aa5375e2131e87b95", + "placeholder": "​", + "style": "IPY_MODEL_034974452b294b36b90dd6f91b3f24e3", + "value": "val/images/all/DOP25_LV03_1301_31_2015_1(…): 100%" + } + }, + "7e2b0ceb09714f3cb769f89f261eeddd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7e30917c8fe141c393e22c42bbdf7a25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_305ce59f87a043d79cea5b6d48a0a8b6", + "placeholder": "​", + "style": "IPY_MODEL_ebab26ca85fc4d22ae32d0fd99718e4b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "7e341ab3c084491cabc4ac7d3c47ead4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7e370774426f482dba58f3d81d7adcee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7e47f26d15b64875b3f535049c5d42cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7e4ca641059e413e9410dfcdbc72bd29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6eed31db3c594630b8bf0f5bb7df7679", + "placeholder": "​", + "style": "IPY_MODEL_9e9d11be4d00406eaceef9082a67b6de", + "value": " 2.88k/2.88k [00:00<00:00, 10.2kB/s]" + } + }, + "7e4eb7d314174c70b74b3d03cc81dbb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2524750d1a754f08bb9ae7ea72d5a50a", + "max": 2980, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_11d6112c3ec0470d9fba057b696eca0e", + "value": 2980 + } + }, + "7e4f832a9866431a96cdfe890fc9001b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7e7716a4fa76472687038614cc2ceda4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7e801d16827e40a5bc7472ad55dea005": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7e81d47b4b98495b95f4a3ebf57041e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d884afc2644d47838540b22aa0a9da25", + "placeholder": "​", + "style": "IPY_MODEL_e625cca5301249249fe86f5ae1b64a74", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "7e855de7626040d6b9282729c89aafba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_351e7b77502341989b3a2a5701864a8c", + "placeholder": "​", + "style": "IPY_MODEL_6a612e7678044ea78ed24e18281deb7c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "7e88b74351354c51b4a96b214d12278d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_79a7c868061b4a9da72d2d14110ddfee", + "placeholder": "​", + "style": "IPY_MODEL_9eca51c2d85d428da4df8574722485fc", + "value": " 1.06k/1.06k [00:00<00:00, 4.32kB/s]" + } + }, + "7e97d88de8f54d89bbf8aceebf2f87a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7e9c2086b82c4e3aba3c320818e5b68e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7ea2983a7d8f416792ce6bea1718e52f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7eb8af422a414cc58cc29b6925a5c487": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3dbb39f8dc904d74b5913e0d8a80976a", + "max": 147176, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ab0c72a25a084858bce1ae706363f1b4", + "value": 147176 + } + }, + "7eca41f469be4837b4495b3670d73085": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f32453e2b47e40d7b41ca85ed25a1348", + "placeholder": "​", + "style": "IPY_MODEL_abbc041f4d84458a9e045f70918c7cc6", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "7ed025af4d5a419dbd5aebacd56e7c5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7ed3da09950548aabb1e39f14c9fb3e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7eddeadb39604828ab0ddad1fbd2f898": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7f00831c75f14b2682d9cde63803d201": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7f008c5952de4b9fb827e8f7750d9552": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aa8c2e7ee3544f3aaec33492876aaecb", + "placeholder": "​", + "style": "IPY_MODEL_60161f5bb0254d6994e521a0f0f17496", + "value": " 3.26k/3.26k [00:00<00:00, 18.0kB/s]" + } + }, + "7f24ab9dda5e4f0ea37f4c02fe55705c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7f3cab2aee9843a4b4744854af545c70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7f5d5a7c4f6c43d2b3f2b16562c67062": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7f5e1d38942e4da580e7dbd05c66a0b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7f61fcfb725746bd926fbc63265e31e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d441e4b6fe8c41d1a4ecef83b38ce374", + "placeholder": "​", + "style": "IPY_MODEL_d0b9e56f256a4a1ab6df79243c236308", + "value": " 3.20k/3.20k [00:00<00:00, 23.2kB/s]" + } + }, + "7f6542bcca044ef59cced7911412b334": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d0ab4ad19b904923b7565504355ade78", + "IPY_MODEL_99524bac1d7f42f8b5a7bfed87b73e9a", + "IPY_MODEL_d37c0b78a1e440f184ebba8e948cc2d7" + ], + "layout": "IPY_MODEL_337c545ca77142dcaeb594986cd07e55" + } + }, + "7f6cc4162cdd4c9eb9cd8c1fb7fb5fe0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_805ac1f5939b4accaf3c3abc3891c97c", + "max": 749, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8d296edf146340219627f2daae59a812", + "value": 749 + } + }, + "7f78c2ac96104f108f4f0b27e754ffcb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7f80dd8cf30a4f1eb5f668085a390a2e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7f832cb12d074230b8cc4caea6f7de29": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7faa17fcd1f044f383a82e155ed81ae0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7fc34adf4dee49fd9df1d354370f0bf0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7fc9e42c867d4bdcacd7534c7c75dabf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7fd10654516c44109bd7f0b143a4f190": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_90457ab1800b49f4a7e7d483b0ae51e1", + "IPY_MODEL_3626969f7b9443a7944bfd0c8914865f", + "IPY_MODEL_3a1f4a99ea7746029dd41aa380af63bd" + ], + "layout": "IPY_MODEL_1efc618189184858a00fd07aec166260" + } + }, + "7fd1ab39d7eb49ec9be8aae7b3b9fa32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0a4148da43b14f52bd8d6c443ce5cc57", + "max": 1473, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1bdd99e3b58045c084364746ef289167", + "value": 1473 + } + }, + "7fd36c3cf1c34770a663322eef572e30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_35c3383d0460405a85bba462748d9500", + "max": 3825, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8c0e21ccc844496eb83f483f886c754e", + "value": 3825 + } + }, + "7fef0e8cb4ca459193463f078b96aa90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7ffbf7bd04e64d589053311aa5d80103": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b75029cb87941459e0b9c532adf2c53", + "placeholder": "​", + "style": "IPY_MODEL_82990bf17f88449291cb491fea4ec802", + "value": " 904/904 [00:00<00:00, 6.02kB/s]" + } + }, + "7ffcd9a004df40d782c0833ce049e98b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "80046b1dff0047da9b5bce0bf2a892a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "800e0c841828478884c918d92a6c5d35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_41d679e3e00341e48aff551fff69230d", + "IPY_MODEL_f9e3a689beae42e4aed09d0dd145e90e", + "IPY_MODEL_b3f03cbb9fe0401b80f26ee76fcfd0b9" + ], + "layout": "IPY_MODEL_b5efbfd7d17c4a81a862b29bbc28237c" + } + }, + "80289d686e61497e921ca3b83e872bcb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fe836c5d55ae41019294174927d41306", + "placeholder": "​", + "style": "IPY_MODEL_d54495aabf234fd1935b4ed3a5193d3c", + "value": " 6.15k/6.15k [00:00<00:00, 85.1kB/s]" + } + }, + "802d5316497140809bad1906e58c9039": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "803e2f6a3b9e47c5818f028f9f1b1fa6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "803f505e745247e2bfcac7211eded872": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "805ac1f5939b4accaf3c3abc3891c97c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "805e826d4298449ebd4500db5c8ed019": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8066490a19a24cd882fd9f9598e64e1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8068643b38104473a7d5875d4894f412": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_246eb3ff17c44107b4d71598e4acb14c", + "placeholder": "​", + "style": "IPY_MODEL_5ccd73fd714f4f26a72b55b87c055a44", + "value": " 143k/143k [00:00<00:00, 694kB/s]" + } + }, + "80853d21490b4c418b534618b633f302": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_14ca03fd5e804516bde00684081b02b3", + "IPY_MODEL_a2b7d8c60c574500a2eeb68dd0a71a16", + "IPY_MODEL_748290a07b884488853d060a4f8c5f5d" + ], + "layout": "IPY_MODEL_11fb437ea7a348e3806227efee163215" + } + }, + "808f08fcdfb54f72934c135037bc5f54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_303ab718177d45c38a8bc94eb7642062", + "placeholder": "​", + "style": "IPY_MODEL_8ba3523b8b464286ae9aba94efee4f64", + "value": " 1.30k/1.30k [00:00<00:00, 6.96kB/s]" + } + }, + "808fde7efac8416ea750b85e4e06efd0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "809adf67a5b14e74a4fd933b5fb5c70e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "80ca8e2c62cd4ddab8a9ac039df14327": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "80db2671b0c64ce780f08d36f4018b79": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "80fcd0ea956a47a7b24b2d16df4e059c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bf312d3c031f4d2ebaa8b112d5b22bca", + "IPY_MODEL_c076a02490fc464b879ad88808260d95", + "IPY_MODEL_e03969f0822346a6adb420fdf84e692e" + ], + "layout": "IPY_MODEL_1c772da0a2bc41029891217c08d55a61" + } + }, + "81006d7ee45e43eeaaefe636956a6df7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8109e0315c2f44b8aa0c7721c9d5f0ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "810e9c19eecc494785e5eca3deb85080": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8118225760b24198af5dd8001990f1e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_18bd3db6b9cf4363bbfd10cdec2e5259", + "placeholder": "​", + "style": "IPY_MODEL_a87455e7f40e4b9ea51e7c3e0f61e411", + "value": " 2.98k/2.98k [00:00<00:00, 13.7kB/s]" + } + }, + "8139937d055641c985b0bdef7cb90184": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81444a1f49ee4c51aa1f86ebe9966cec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "814d64032ca54309afe22a486993102a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "81596d1078bf447480e1db2ed142a1cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8170957dd63145328a506f00f28a03fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81850d089ab44acc9ec0cbc102f7436c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "819fcd9c775443b09298197f30a6af31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "81a14bebf04047368e0cea8ac6763b32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2001515cfab94120a22fa53694b657d3", + "placeholder": "​", + "style": "IPY_MODEL_98d70605fe5649aebcf8630e140ef3c9", + "value": " 1.25k/1.25k [00:00<00:00, 8.68kB/s]" + } + }, + "81af0a726180435fa9f5d63316fedd8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "81bb639bb7ea46d0908aed7b1b187571": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_63261d7f80884c569d9e3f6eab75d0d7", + "IPY_MODEL_9cd82f62b0504528a18bc9c2540d182e", + "IPY_MODEL_d302064d0f1f4a5aaf74ae5225dcedba" + ], + "layout": "IPY_MODEL_a4adcf5709f84d10beda973794af0d6d" + } + }, + "81c3d8820f2b444e9b08708903100b01": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81e317c285f7442f90919a7041f5691c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81e82920e468407eb68ca2eaf6a836ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4b9c4c97a0a6418d81378e48940f96c8", + "placeholder": "​", + "style": "IPY_MODEL_58260ecc57074d05b420716b517f4ebb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "81eec735a77849c8b0d0100a64d6eac2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81f6d8bd910b4ef5bcf3c2b7c5a18328": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8203a8a680a84076b570ff8cb1a1d279": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_270125145064487a990ec12e37a6b64a", + "placeholder": "​", + "style": "IPY_MODEL_d63273f594814fb3aff95df413c338ac", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "820af612da554b1fb67ba4a8fd4ee363": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_53d192baff1e4e26b82773a74e3cf962", + "placeholder": "​", + "style": "IPY_MODEL_67f1dc45a78a465193de9b9b777685bc", + "value": " 1.90k/1.90k [00:00<00:00, 7.94kB/s]" + } + }, + "821e93e958634768aae2763d8a5fce79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_19264cf15774460a9e568ed86f0d0df9", + "max": 1087, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_127419a2127748848b6c38586e727b20", + "value": 1087 + } + }, + "8225206a8b614e489527fad31a974531": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e54ab1ae78784e81b1e78ab0734828f3", + "max": 3208, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_449ca12cc1d3485b9674133ba6218747", + "value": 3208 + } + }, + "8231244a92b6413ca82c9d3111150226": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "823510d8b71a459e93e2e5dd1395ba1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_39815d0500b54a4f806c3a8316c0e146", + "max": 4736, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b182fe9680b64f23b3afbac97fd4c0f7", + "value": 4736 + } + }, + "823f85e43c5c440db41f936da95f09f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dea1c001a43349d8b9801bb127653076", + "IPY_MODEL_59bb0eaaabbf4fbcabca1eb98296b075", + "IPY_MODEL_136aa1aad3e34b7b9c9a8ce8042cf7aa" + ], + "layout": "IPY_MODEL_d253eb92e95340e496034142f14a8cce" + } + }, + "826eb6230ca0425cb7c373646f39776d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_65a7baa8cb2d4487966e3c783ba9d9a7", + "IPY_MODEL_5f2b5d51891d4ac58c45c7d400680839", + "IPY_MODEL_960e6b2028af4335baec1a8980643f20" + ], + "layout": "IPY_MODEL_54bc6848fc894562ae7a0aae03544a20" + } + }, + "82990bf17f88449291cb491fea4ec802": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "829bd9ba29e74bcbb28ba08a703715c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "82b5a49fd9884777a59400b451c43d22": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "82ea5220b8a9474fae3847658cdbf0fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "82ff4a7e2d054626bb9524035c2d03ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c13e282bb7a847768c0da638e4b91f46", + "placeholder": "​", + "style": "IPY_MODEL_61ef1d8c9f644bcf9d1bc718e9129948", + "value": " 6.30k/6.30k [00:00<00:00, 26.4kB/s]" + } + }, + "83025c1ea9df490f9c139673513cb88e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8326e2b9bc944b0caf80efe0d50ba919": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af0874fa72cd430abc3555aeece4b6af", + "max": 2808, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_73c72a46ba6149a58baf02acf5b6d2ca", + "value": 2808 + } + }, + "8327c1e5f7024cec8aeee05b25cc80ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "832bc3ba78c24c39b8042e9b2c8f771b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e56bf30ae89a4e98a80fc6ee88a68df2", + "placeholder": "​", + "style": "IPY_MODEL_e55faca86deb46b78ef742f233c6d245", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "83380807cd2b422aa2850fd8021edca0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ec409bc08cd2432c9b4e44177e583eac", + "IPY_MODEL_3d20009577614074862310c09d308047", + "IPY_MODEL_80289d686e61497e921ca3b83e872bcb" + ], + "layout": "IPY_MODEL_2ead3577b8bd4b8d840acd89c1d180ab" + } + }, + "833f0068959449148d0b6e0087305d3a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "833f957dad3f4b23b726dc12e1e7f7d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8342873f0668418e83ca489f9510f2d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "83470be692e14ce0a070ba37712ed466": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_307615d7141e455bbfb66d13fb310154", + "placeholder": "​", + "style": "IPY_MODEL_b76ba822f51542dba2cad82e44273c5c", + "value": " 1.00k/1.00k [00:00<00:00, 3.48kB/s]" + } + }, + "834b5ef4d54d4c9c9084802ad8d63857": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "835ce627a9fa4a26a9b27b8edb222953": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8367cdb0915443dc88f43218b16d6367": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "836c41f4090c45cfb6c581374c7ef134": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "837a00ff5d7a48659990b369a9666ddb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8387f8d6209e41768844c5b85b5fa61c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "839317f8f28b4b5d992091fe9e8d43fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fe3b64347dab41a2b1e19c842aa8daa7", + "placeholder": "​", + "style": "IPY_MODEL_f4146003c6f8463f93637bc04bab731a", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "83a101a5bc874246a44747da93d117ac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "83b3fa41047b45919e7c9b3dafdee7cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cab0659d8f6b497b82d081908eda3cd3", + "placeholder": "​", + "style": "IPY_MODEL_928f4b058a4a4a9899a4f2ce5fbfadc0", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "83e117c0bb4448e6af42a8331a8fc197": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "83f917d576674cb39d1a575a613f92b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7133fde26d6f4718b463e39efe8ceb7f", + "max": 2458, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fbac8f675c7c4402b6c4a3b3efd9a0fe", + "value": 2458 + } + }, + "83ff6f62c0ac4f369e6a034ad2f034e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7d00948f1b694a28a99ee8549cf7bf93", + "IPY_MODEL_90e5c3ba0f7747bea423fa258e2d7857", + "IPY_MODEL_d464fa16a30f4552ba234466d4112267" + ], + "layout": "IPY_MODEL_8d183c9bac814f0c8d2f8438572f869a" + } + }, + "840d1ea506e04da582e0dc9440dbf887": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c6bba8a3b32049eeac5519856d75fe46", + "max": 2636, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9ffcfbe2dd2146e5860d7c4c35883845", + "value": 2636 + } + }, + "842eb9c770864bd59a456afaab841365": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8443849c16094053895558bfaead7659": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "84580ffdd8ae49d8879ef702525074fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "845ca584343e46348274dbdd751e0d71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a916d81e9245418aafc27f5e2eba13f2", + "IPY_MODEL_c4dd31ea213a4515a0021e4104f0ea0b", + "IPY_MODEL_6581192368fc4f6a9e72c3db483dd6d2" + ], + "layout": "IPY_MODEL_d862b0b27438481a83d668b11fe9fac4" + } + }, + "846e10b634304f3f9c857808825e08a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d0b641c72e6e4624bf25713c71c66a8a", + "placeholder": "​", + "style": "IPY_MODEL_a9b78dd6ef774da6b23d6e7811252db1", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "847bc4a2721a47e4a146b891ec35d02b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_86b15a51804341e28773fc11b8d5185a", + "IPY_MODEL_ce4ef0f5a7ff4bed9d9d8b3134301cd8", + "IPY_MODEL_4ad2dab2fbd6453aa098b56c4643abad" + ], + "layout": "IPY_MODEL_d7082d2746c74767bf35c618caff15b0" + } + }, + "848a553dd3a84ab7934d7dece6ea405a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7bb72454006b48909ac6cefb12826232", + "placeholder": "​", + "style": "IPY_MODEL_04506ff36d39464eb5be438bd2de848a", + "value": " 2.87k/2.87k [00:00<00:00, 12.2kB/s]" + } + }, + "84a247af39964f8885ca472109ff094b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8c027e78f4ea40a0b8806bead2e58f09", + "placeholder": "​", + "style": "IPY_MODEL_532cc9873aee4fa495a868aef7815ccb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "84a8e3bb3afb417da2266a5acf21a07d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "84ab171e5a6d4f0d8f1f5881e6e6da00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_474f7ac9f4d14ded81f9bc1c7508ada4", + "placeholder": "​", + "style": "IPY_MODEL_7c5f87ecc5df42fd8b185546177187a5", + "value": " 1.08k/1.08k [00:00<00:00, 4.52kB/s]" + } + }, + "84d38bdb29f443b6aed037befa591eac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_33f0044773aa415dbfadc1810b030709", + "IPY_MODEL_213752daaeb64dadb6815b055933daf5", + "IPY_MODEL_a758a8738a104a8c9034e3b6a11a85b2" + ], + "layout": "IPY_MODEL_74a6cfb82aba440da8fa2b57f05366c6" + } + }, + "84e401d1e07847ae9d139550f7852560": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cac3f95654bb44099151e8fbd1961563", + "placeholder": "​", + "style": "IPY_MODEL_71f358137fa04cdfa432dffd3239f1b9", + "value": " 1.56k/1.56k [00:00<00:00, 6.02kB/s]" + } + }, + "84e83a8e4cc04fb4887cef24173f2ada": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b495b71f90f4431a8d15ceb13ae8d5b6", + "IPY_MODEL_0ae24dc31ad349a684eacebd26f3fce9", + "IPY_MODEL_7f008c5952de4b9fb827e8f7750d9552" + ], + "layout": "IPY_MODEL_15af0b11c94344bea7cd65520dead630" + } + }, + "84fe0444fef7453aa487d1d8f0904a6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8500ccc3e018487f85389d0d9e3492eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "85080c2726c9465d85f20ff8b71fd173": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8515511e3d304581a6c06cb724d0a2fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "852cccb363904a6384f76571d5d29d73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4540c0a1da4248e18e98a488d24c5260", + "IPY_MODEL_416d048812014358afb0f26484e83faf", + "IPY_MODEL_6904a36620824725a92fa6b340535f48" + ], + "layout": "IPY_MODEL_803e2f6a3b9e47c5818f028f9f1b1fa6" + } + }, + "8536b6c3bb3443fa8b8c5245489923df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e2ce011856b24340b23832d46aad63d2", + "max": 2107, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6a0a0dfdbfcf4d49b79c97095843b2f4", + "value": 2107 + } + }, + "8538b8aa71ef416fa99888e1333b175f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_67b2e1c6029b4b49ae299224bd9edfba", + "placeholder": "​", + "style": "IPY_MODEL_88ef9568f39a413d856a26e3956fc030", + "value": " 1.96k/1.96k [00:00<00:00, 13.3kB/s]" + } + }, + "853f8c3e0cac4f7fa589316c39546c7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "85477cb0284e48d38ec56ff114c2302c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7e30917c8fe141c393e22c42bbdf7a25", + "IPY_MODEL_98a39a57d5264eaa9da170e75b666426", + "IPY_MODEL_95c038dffad6456980867c5af07c5a5c" + ], + "layout": "IPY_MODEL_9df384158c9641378bdc922e645f7662" + } + }, + "85490ac84b5747bd8399121f92b90549": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "854d0921ce1349b09ec268206eba0a79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "854feabfe4c94605920b2803506406d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "856988ad083740d39d2b7a7933eab75f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8572ac61bd4046489d77120601088f06": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_89233233577443a7913d2b8d26ccf817", + "IPY_MODEL_55f94826321c4bf2b732ef4dceb12eea", + "IPY_MODEL_554d6583154c41059b0b573ad995eaa9" + ], + "layout": "IPY_MODEL_a9004b75d9e84a6bba3a3a7705111167" + } + }, + "857828ca78dc491a9e258caf184c2298": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "857afd42b9424d74a506c862e67a8950": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "858154867da647ec8cdb093731a70e9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_07acfa2b2e7f4666a0615272cae66dc5", + "placeholder": "​", + "style": "IPY_MODEL_4d925c7145a44ac38d27f850a4339bf0", + "value": " 144k/144k [00:00<00:00, 735kB/s]" + } + }, + "858d122a0cc04477adc67503f01fe527": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "858d6f3b75f54b4187b7fd2241c2c173": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "859ba95884ea4a9fb84ffb3297c6d469": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "85b8e2d840234716bbcfe4f73beb2b6f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "85bab1c7f5ac442289d5a33a3df3f312": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "85c3326b3d774270a5186db473a6a8aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f6b848e211bf44159dcecb8cca6af229", + "max": 2047, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3ec96a2b6c4a40be9ba0432314dd9314", + "value": 2047 + } + }, + "85d0edeccce24bea85e23bf112d9b645": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "85d4b4e5a7d548febafd1a9e6e90eae6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_01f1ef103de14fc68deb958f7f3e21af", + "placeholder": "​", + "style": "IPY_MODEL_094dfc60cf4a4985b7392a05e06bb345", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "85ef686511884d3e8c5135c9c9844de2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "85f0f3c11f7f49bea563d4c01962c8f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6211f34debfe4b4a8eafa4187a732d2a", + "placeholder": "​", + "style": "IPY_MODEL_319a0e64bf8546ebacb08e062804999e", + "value": " 954/954 [00:00<00:00, 3.20kB/s]" + } + }, + "85f2eb3466464f6db0ee8ca386a004dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "86002897439140d5bc0f628a1f3e6707": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dca592953f724355875fd340de7c9756", + "IPY_MODEL_50f53e16acaa4f5885ec8337888a7218", + "IPY_MODEL_f6bdb7a2654549fe9726d2feb8f9d045" + ], + "layout": "IPY_MODEL_daed743c2dfb47f5853c02a083d42049" + } + }, + "8608686e155b4f0ca37a5f61bf7ff517": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2d0803c3b23848848b792485959860d0", + "IPY_MODEL_031f9158bbb34ccfa0b17eabf3148f92", + "IPY_MODEL_ceb5edaf93fe4ab786ec99e8632b129a" + ], + "layout": "IPY_MODEL_a0065523160949119a44ffa228d4f4c8" + } + }, + "860d66f6885d4532b5fd5ff649551f4b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "861397d11d2848d59017893c79ddf171": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5dcc8a2c0fa84e5eaaef014b17a38b5f", + "IPY_MODEL_a5b216dc00c34a8caa870311854ecebd", + "IPY_MODEL_505956be6b3c4b9f859d7821edbdbe24" + ], + "layout": "IPY_MODEL_2f6937a6146f498098f7097e88d6f0dc" + } + }, + "861ab1d8420f424aac692ddeab51b18c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "862f8e4fc5484d2da771f88b4f6c3559": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "863c00185b8a4005800995c57b13166b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "863eff68f497414d8578abab6406e091": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "86489bac14394b8c940cde7001c5e893": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "864c3d81b819496b8e740ac80e6a6278": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9d2f4c8b5f594621b3ed967f56b64f87", + "placeholder": "​", + "style": "IPY_MODEL_814d64032ca54309afe22a486993102a", + "value": " 2.08k/2.08k [00:00<00:00, 8.83kB/s]" + } + }, + "864de426328f449f9d440610473c9f0d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "86534d69d7724f5abbc3c78c8ac53f62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8658f9cbaf3b46cb9fd8def80a9ca55f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_972a049f41074edea4f324f73af3e573", + "IPY_MODEL_e2b03b494672404d8b7e64a41d86066d", + "IPY_MODEL_1131e84fe0004cbfa7cfe64314bd9004" + ], + "layout": "IPY_MODEL_6362268792ac42ce9fa18c50b1002192" + } + }, + "865cbcad459c4622bedd25f1702b3445": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0ea681e43d314298bf4a5fa120c98f85", + "placeholder": "​", + "style": "IPY_MODEL_8aa2e305c1b849afafc7cd1bff00da72", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "866156662e8c4e5ea1280dabe82b15ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b33134184dbf43978011e8403ab2e1c5", + "max": 2103, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d2e439fc631a45fbbc484d2c5e168d4b", + "value": 2103 + } + }, + "86619392e7df46efaf2416ad390cae42": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "866705bd4d8c435f8c3132c706bf0b0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8d23164753b94898b9c2659261e0c490", + "IPY_MODEL_e3bc655af8c345c1a973f8e15f20fe08", + "IPY_MODEL_f754431750db4e4fbd00a09d474892ce" + ], + "layout": "IPY_MODEL_7a3c50931b464aac9f4644c13baaa33a" + } + }, + "867b302886c94ed28151b25136d870e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4761d50c834244c0bc5fd542d7b67c32", + "max": 2681, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_06430419cf2446e482d5010c2104df15", + "value": 2681 + } + }, + "868073bddc93429caf7934743efe25c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8682a507fa494b379fef0f9b5b0661ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "868e0848780d47aca276551d813bbb95": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "869480a5370e4164bd2ba7954ff5e3d7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "869f6687a0e8493f92449dba665f1c9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "86a96efe55464f9f85a93258a928a7b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c994d17ba781415585b9498a4a4cf1d1", + "max": 137293, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_38a0464bda91420785ec93921e34f032", + "value": 137293 + } + }, + "86b099e3fc384f34ad304d20ea9b1ed0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "86b15a51804341e28773fc11b8d5185a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4156158b8b794e41bc27ac41dacfc949", + "placeholder": "​", + "style": "IPY_MODEL_90d88e5ca7184062816125a4ba1bf524", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "86c07a99cfcb42c0b7a13b6e647a95b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "86d29201a4184838af661a25111881a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_097f8e2bd8504bafbae7971e2c865b0d", + "max": 1686, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_22958fba1e214d76b332fb8cfe5ae0f9", + "value": 1686 + } + }, + "86e55605bb10452d9c52fc5b701b74f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "86e7460160d64d98b2627e98a4a085f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f9cb189df8f94991bc9f0d617a9d095b", + "placeholder": "​", + "style": "IPY_MODEL_454872860fd3495d89bde70c8b9caf08", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "871efcbb8cf84770949c773177e80895": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_762a8ad531d2406c9699a68676d076ce", + "IPY_MODEL_c26f635152e54e48b0714f4394ddfc66", + "IPY_MODEL_ce7018edd3ce44d8bdc9fb38319dff9c" + ], + "layout": "IPY_MODEL_0bd10570e877416c928ef0b410339709" + } + }, + "8725f8993092465c98f68f1ed6c35122": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_47d89f8718c44376bdaa32fd672a592e", + "placeholder": "​", + "style": "IPY_MODEL_372bdf4c92534edc8747e44a1ff1b1b5", + "value": " 2.30k/2.30k [00:00<00:00, 14.9kB/s]" + } + }, + "8727bc13b7ca420fac14bc4255481829": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "872c4e032fe741f4b209aa022b89aca1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "874c585cea7d4b32a1e8793027906d07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "875658097d5d4205a59538b3e16d5399": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8760b16760f041e3b5aa630be43eedae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87660df242e44be3be9c322e129aa033": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8771fe3bcf3e4fdcae530abf98fd7e64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_47887f5ff121458d936fb03bb0fe248a", + "max": 144570, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9678f86c98184c698e3b2600a296213e", + "value": 144570 + } + }, + "8773dc09dcf449ccbf3f1fa6e4e06565": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_61f3bd7156be40cd88b3316dd46fa3e8", + "max": 143729, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fca3824059c444999a63b7eeac43c285", + "value": 143729 + } + }, + "878ae4a32fb64a9084bf1517ed8d9b5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_efae1cf41a1a4d3caac840e8a4182aa1", + "IPY_MODEL_e8a7618e62f44377aa8dcb6b38dcacce", + "IPY_MODEL_687391e2a6e843b4a6a9141841e70dcd" + ], + "layout": "IPY_MODEL_b664b000df014a02bc6da52555c7c4fe" + } + }, + "878dfdba3acf4fccada8d9c3d420bb7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee9a760fe91e46429c3318274b40b6aa", + "placeholder": "​", + "style": "IPY_MODEL_e7c719191fc744e68d0482f5320177f2", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "87a7ba046c3e4f35b5b03bd4a17f61d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87be05c24a0a407baec681b4b06d52fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_20ead03340614820bc9f0ea85a8b4853", + "max": 3459, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7480a759285f4cf483a874aba868ae88", + "value": 3459 + } + }, + "87cc0cd59b194b2cbd895d1ad0e5b00e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87cd1fcd56cd42c2b49a2efe3aaf9f67": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87f1ab24adf74daaa7e75e3599d88ea5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "885e1857f08f469d8a591d6f24fb9920": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8863e06bf3f44769b755a28637cc0b71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "886c51a5f8fc4c73a6987bc2984af18e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "886f90c5df234f768b06eb9d0cbc03db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_19ef9ae517984a28805e00970adac821", + "placeholder": "​", + "style": "IPY_MODEL_1b2668e9821c490b861eb6eeaf82cf53", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "887fa40435724e82a61d4c4a83e79f75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0454603b7a344ed68addabf5abb625a4", + "max": 2986, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_44c622db08d04d63b6883652168e641d", + "value": 2986 + } + }, + "8885d8b4fd5d4e94856ebc886a06c5f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "88877c9b788d49c9b9b937ad2e1a22cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "88912c85187c47aba7d3ec34cecfbf98": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8897bf1b444b4a8387118b18a8c98f83": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8899ea90655e46d2be990556e58d9161": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ec975d198e446b1bcb4925057b1ceb7", + "max": 2341, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c841984e31be49ddbf848d796834f26f", + "value": 2341 + } + }, + "889ff6601e5049018f0c8dc30865e553": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "88a2ee38266d4319a2e3128cf79d631a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "88a8dd0ad1cc48f999c3d6e758a3d6f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "88ab24633dfd41b0878d6620936901bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_75b7eb814f6b4901b96af72ff0907cac", + "IPY_MODEL_bb3f00f258d84b9e9d65262e3d40a745", + "IPY_MODEL_c05699467511476f90b07f0ea65fc765" + ], + "layout": "IPY_MODEL_07aba533e4024609870239294b62fe37" + } + }, + "88c89609c881481992acf5410c121fa5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_30eb693998e14aa6ba7f572d0c90aee8", + "IPY_MODEL_eb3d549204f347d194ba92f8595c22fc", + "IPY_MODEL_9276b7a2ed4c47c99da46853e8fca4ef" + ], + "layout": "IPY_MODEL_1aaf1fe5016446d9bfa5f4b43c4ea403" + } + }, + "88ca4cd644654f50997dfef938ad014f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "88d7d194c9da4c0da5272235cd7f040e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "88dfb5a4c6af41f79de05897352e29cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "88e2a65380d54e0ca6467af1a923f117": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4d1e8e45b354055ac38af9904f4fdc7", + "placeholder": "​", + "style": "IPY_MODEL_7c343847bd774c95aef358fe88072b37", + "value": " 2.34k/2.34k [00:00<00:00, 12.1kB/s]" + } + }, + "88ef9568f39a413d856a26e3956fc030": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "88f0f714f12f4f61a2b1ba850afbc2a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89117a4fc99b487a9bab3c43f64a2089": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "891724e2dab44eedb7c6a8624d4f8d2d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "891c79c3a2b947efa2ecf0dfd7b38858": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "892069935efb45eea0955e4870114b0d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89233233577443a7913d2b8d26ccf817": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb96ece3c1bd401498759cf125e99c54", + "placeholder": "​", + "style": "IPY_MODEL_9d21b565918943b38e2eba6ff19497af", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "893d4dbe226e489a810128f31bdd2cd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8950e1dfe5834495b7611aef0ffe125a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "896463c18d8b456ca7725681b5fab2bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ef985732896b4fe2b76db62ac4207fec", + "placeholder": "​", + "style": "IPY_MODEL_58c0eb1a27404b4c827b0754bcbf4e3d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "8974b5fc546e4decac98cc96c725a61e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8978fe8657a64ea5abcf75abf14aee2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ae853d56c0d5470ab3fba373050d64f0", + "max": 144578, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_11b858c20ef745fd848b690f2320d7f4", + "value": 144578 + } + }, + "897f7169ca494a33b0c60264da3d1ff5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89808693a88c4d24a5f8d2b960daac73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8986aa30c6fb4b02a77cfff95213cee2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "898a666040444842af8c045c72dcc0f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4aa135e9ae71457a898d6154efe62f61", + "max": 882, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3b08028c582c41f09f65dd91cec0f877", + "value": 882 + } + }, + "89954df636ae41e9bc32cf356fb607a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89a4961fe5a94ec3ad87b133189d6977": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89a916ef42d7416eba57f69ba9d2fe32": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89add487285743f2b529f0306b4375c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1b43041a3dad440da8478d98cc9e6608", + "IPY_MODEL_cecf7c866d044eaa9647d5a5b1d1a29d", + "IPY_MODEL_a9fc89b6d8e6465e9242964c09fa2afc" + ], + "layout": "IPY_MODEL_71b3ebabe84541278c47b53878f0719b" + } + }, + "89b2ee299a8541bea9045c704bcde56d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89bae1fb93124c98ac2a0389d56f4f61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89bb77c8263a443b8542951e9dbc3277": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a48e42a747d243d380645e58d1e7b363", + "max": 141498, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8342873f0668418e83ca489f9510f2d1", + "value": 141498 + } + }, + "89c2503ef7df40059cf183248b113543": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89d5d8c99de4454f8b6b05dd1dd3eccf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89e30dcc57c14d09a6bf363daeee6d41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c1c8a352cf154a49b6bb920293e1ddea", + "max": 2299, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9c1a960b4bf94152a0c0451a02ea43b1", + "value": 2299 + } + }, + "8a054d4acf434761808a4937e123efc0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a055713ab1e44c7a48126b982fe6d59": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a07e2616513492f99936bf22f81c858": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8a0da96d80f945e0acfa2494111cf74c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8a0e9f24284349848002a87535d65243": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a127e0628c24fe4890733954a0fa902": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a1315ce0cc441e2bef5f391622b6a27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_97102016a2a940a39f2865aad0f8e289", + "max": 1492, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c22ce55dab2b4e59b9809847e7d7e9df", + "value": 1492 + } + }, + "8a17f26998804762921e766358b55801": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8a210801cbbf4c8db63916bb8729ee4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9a9e28a68615400b9c4dd4b764b3cc1e", + "placeholder": "​", + "style": "IPY_MODEL_f042856c6ac240e2b0341306d4597a65", + "value": " 148k/148k [00:00<00:00, 756kB/s]" + } + }, + "8a60d423c0724c918628f0e411249f83": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8a635eee177f422d858be701b9814b94": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a64c2127a0e478ba4366d1accca11ea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a77988506bc4954abb7148baaccee6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8a7a94e67a8a48bb9073f7a8d3b7a483": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ed112c83ad9840d1bca2762166164a8b", + "placeholder": "​", + "style": "IPY_MODEL_74fa7a110d1a4229acc6ded65e628be8", + "value": " 1.57k/1.57k [00:00<00:00, 5.07kB/s]" + } + }, + "8a821cd1a8ba47fcb7c096d615a8b26f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a8a433c7dcf4f4ba01915c479fd0c0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00d224de54ed423ba3268968af72db6f", + "placeholder": "​", + "style": "IPY_MODEL_76573c67b65e4aebacbcfbcace4aa931", + "value": " 143k/143k [00:00<00:00, 803kB/s]" + } + }, + "8a8e805327ae4122a43debb4f96db082": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a942bf0a5824b0c88f65e6e855ff907": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_857afd42b9424d74a506c862e67a8950", + "placeholder": "​", + "style": "IPY_MODEL_3cd99dd16a2849f2b7dd67fcc0b23225", + "value": " 144k/144k [00:00<00:00, 707kB/s]" + } + }, + "8a95b31652c44d9d8674970cdc40144b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a9a416b9ef84f04865a148fb0c5f71c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6444296d7d8f4558a474a52816ae5add", + "placeholder": "​", + "style": "IPY_MODEL_9eee41b017be4bf3b9d1149b217e4461", + "value": " 2.83k/2.83k [00:00<00:00, 3.48kB/s]" + } + }, + "8aa2e305c1b849afafc7cd1bff00da72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8aa3fabd2cd7420dbbc259dabfa0fed1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8aabdd1869d74fafa3db010ccc404d4c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ac68915728747b4a9bf15dea4d544a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8acd64de9f7347eb8baa795235657a13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8ae814fe8981444ba931511ee4c6b522": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8ae909db76bf4b328231c0204b6c75a0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8aef752d4adb4ace84e3b4fe0a671584": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c11e04bc998b41b3ad81f37e4506c3cf", + "IPY_MODEL_5166f45e39bb43568f7c9a23289113a5", + "IPY_MODEL_07f6d54be05f4ce7b59db870d4b15199" + ], + "layout": "IPY_MODEL_b6a2683f9222477ea23ae1600761813f" + } + }, + "8aef7f2a0a7147dd82b2ca98f70f40d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8af6c2ce820d4704b9b7926753311ea1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5f840b2753324172a2feb09245e6ac0d", + "max": 1963, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bb9af2faa50b4c1099f51d373230c310", + "value": 1963 + } + }, + "8af770be580b4f22a0e336618b74b2d2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b10b1cdab3e4a4881061a10c0add9af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b188bec49574a8988f8a0e6e2daf5d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b237999d31347ed9d2db43e8f0bb5f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dc90934fda5647968c6ca8cf319ff14c", + "max": 1147, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_909e864572954b80b269de174c5f2eeb", + "value": 1147 + } + }, + "8b4f6535479d4fe7a6fac757766fb22b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b61c77cc9de47f58ba10c675177d74a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2f28716184a14cfd8047c22aab9c7ba0", + "placeholder": "​", + "style": "IPY_MODEL_753c6c7221e04fd6840d49e50cc64f9f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "8b64db958b224151920c94789611a682": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b761b8f5fa34054866db1eb00a38cb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6ff017b258784e47a9d9baf3073a581b", + "max": 1609, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_50a1c3c5a9e6494f879197c099e75cc9", + "value": 1609 + } + }, + "8b7652077eee4cba8a63127b8765f5e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e5fa52ad015e4ecfb2a79a939c1b5c60", + "placeholder": "​", + "style": "IPY_MODEL_ec0e076ded3948d8bcc55dfd93e30f9e", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "8b8af13b8bd74d2fb7f94d548ae5db10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8b91b7f67a844a3aa6b43035ff86aa7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_591e156818be4a30989dd4cd60594b72", + "IPY_MODEL_79fc2fa592ff477facee14d99c31b344", + "IPY_MODEL_cdc40c0f19294fc3aa0a42503b402cb0" + ], + "layout": "IPY_MODEL_01d4f0ab0aee40938719db3e678a49a8" + } + }, + "8b97cfcdb6ce4c05a465a2f5136d3aa2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8ba3523b8b464286ae9aba94efee4f64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8bab5469e3f546cba5df01f90cc9ef8f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8bab65c6e2de4b3cb93e2bc2c25376fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8bc36c574da34fae842bbd4dd9b9b37d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8bc3bffc9e344a1e9652592e7c26e9e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8bf3cca4f4764c768ae911906e6d9e70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dbf60ccb291446b88295f630798ed21b", + "placeholder": "​", + "style": "IPY_MODEL_b7c41a260de94704941f5794e15f9a09", + "value": " 1.58k/1.58k [00:00<00:00, 7.33kB/s]" + } + }, + "8bf9cb6e7e6b4135a752a89b3f3f48bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8c027e78f4ea40a0b8806bead2e58f09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8c0bca1f03314613af0cdea9603cd322": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8c0e21ccc844496eb83f483f886c754e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8c37ed2c336a4a9f862ca31f11548864": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8c3fc6351cb44622a151661416fd1c5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a05a08964dd4565ae4e3ac13f58beea", + "placeholder": "​", + "style": "IPY_MODEL_069913d99a5e48d8b6d489b0a00b176b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "8c50e55f31794a42b0c6e060d4c49de0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc9cf702054c4f1382498ec1be39d2d5", + "placeholder": "​", + "style": "IPY_MODEL_ccecb63f36be400f9736a4182e55bc8a", + "value": " 1.28k/1.28k [00:00<00:00, 6.83kB/s]" + } + }, + "8c5fe0a361544b3b8e152e1d90cdbc3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8c6b361a467b43309b04ea439aaca093": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8c6cc91b64f341f0ba4f3497a1ee05d2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8c871187cffc4410ad55e119cc0e894f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_33649289a7c849269c006483034e29d1", + "IPY_MODEL_b8855ec149d549dabdd9cfb36f649018", + "IPY_MODEL_c7c024031bec4a73be1773834cc0f319" + ], + "layout": "IPY_MODEL_cc3b6f81df554c14a6be3888affb0af4" + } + }, + "8c8a8e82e16445d0b4e45ff630fce342": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8c8d377f8cd24861b80abb3f6c0a595c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8c8e7d53e2f4427f94e2fea9202e2330": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_12437814a1674176ac1f7e1cf584d0f6", + "IPY_MODEL_e46054c96e2c4a9e99cba754c515c4bb", + "IPY_MODEL_dd44a5d7f4f34213aede9a73a6cd6bd2" + ], + "layout": "IPY_MODEL_38d74cf51e8e4f93b5b6d88550b38728" + } + }, + "8ca6adb555404d329c4dc0d01a249b0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8cb04f6989e14865bed858a1892abf6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8cb5c07289cb4edca11e5339a6b19e0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8cbf41c3c168441f92930753e9d7e922": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8cc19ef478864f7cb5537361e7d6b595": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8cde45e057be4744a53906a0f3b32ccd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ce3e9e3372742b1a03af4ebea894881": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_be4f95e2630d447bb2acdf947fdf71bf", + "placeholder": "​", + "style": "IPY_MODEL_802d5316497140809bad1906e58c9039", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "8ce735e81260444cbc63ee33fab47e58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_31c9cc3339964c8dbef56067c6c4739f", + "placeholder": "​", + "style": "IPY_MODEL_76b892ed01404b85b197ac2e023da302", + "value": " 118k/118k [00:00<00:00, 162kB/s]" + } + }, + "8cf8946c4b0b48c0acfc17ce9b5be793": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8d00e4a9bcc54ffa94158ad7e9b16d07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4d0af35b69254631887d7ed98bc8d6ed", + "placeholder": "​", + "style": "IPY_MODEL_e932b0c7e729498e8d0f86148a98656d", + "value": " 972/972 [00:00<00:00, 6.85kB/s]" + } + }, + "8d183c9bac814f0c8d2f8438572f869a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d23029f0316460abce925cdfc0383b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8d23164753b94898b9c2659261e0c490": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a7567e4297db46cd94b48d00dee47203", + "placeholder": "​", + "style": "IPY_MODEL_3db84acc212242c0a2d3eb39f96c9d63", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "8d258b81db9d4c06839d4bcebf54a798": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8d25b7b7ffeb489abd96561529e3a418": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d296edf146340219627f2daae59a812": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8d299bfe4a4f4587a1f23bd1c79270a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8d32da12091946f3863e896347bc7e81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_87cd1fcd56cd42c2b49a2efe3aaf9f67", + "placeholder": "​", + "style": "IPY_MODEL_69d30f8694ef4a02b7d8ab58f4862457", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "8d3d960df0eb4b1eb455eae26548c342": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d7659fed6dc408caf39dc12855c6cda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d9980c897254eee91f4c4e68fb630cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d9dc33eb2c243bca30a0f3f94063ebc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8db7f1ac326c4123b2f4255c78f73c4a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8de77fae37854035a0df4f5c055eb053": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8dfeaef78f184301a846c173ea1e5ae5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8cde45e057be4744a53906a0f3b32ccd", + "max": 2195, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2c7ce897b627497297cc024eccd9d1de", + "value": 2195 + } + }, + "8e0ab8aea3e8496aa73ff342fc3cc022": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8e1ff6a1061c45f387b2fa2bbe86b33e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e26198a49994576afbd7eb0f9412ee6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e26be38227840a0b5cd86a7d13acf2c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e2daa3c5a3f4e579aa486bbf41da2af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e34e2d085d7434e943d84ac06fe4c66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e7adc274284a4769b2476e8c8cc6d4ae", + "placeholder": "​", + "style": "IPY_MODEL_fe56b5b2e6414ad58b5a607a39bc37b7", + "value": " 813/813 [00:00<00:00, 5.46kB/s]" + } + }, + "8e355e45a6ed4979bb17352e8b9d1e16": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e36a3a3d97042bd884c7a2fbd0d2973": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8e589f2532b547ae88df357a0f0197e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8e65a89e19f74897a3c43817a39395d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f20507e23844d7182a72a17ae8b631e", + "max": 2419, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1450d40db4af4d488b81459e6c2360f0", + "value": 2419 + } + }, + "8e8c962602d3454590b802e2a3e97276": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e94e2cf6db841b5bd55719248731a1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8e9fd64e98014e599328b8334f6afb17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8ea2f2860e2a4c60ba566864b80fda75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8ea6c91ccb4e4849a363b05b5e91fe80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8eb3f632caf94726b74d3ba56caafcc8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fb5fd5514ff84c29b3ed14e4542b549e", + "placeholder": "​", + "style": "IPY_MODEL_91c58d61ddbf4b45b2118a67f73507a3", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "8ec975d198e446b1bcb4925057b1ceb7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ef3042f1499473885b295417b1316fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3d4152eec8214239bea0ac155727b7f5", + "IPY_MODEL_1cea2e1fee5e4cefb70f1c229962b807", + "IPY_MODEL_9f9d2050df8a4c71bdc4c99a82e4ab7e" + ], + "layout": "IPY_MODEL_9d3c31165d0e401fa21251fed2069fba" + } + }, + "8ef546e1d5fc4ea89be7e64d2e30fc01": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a3a921fa53be42b3a77cb7755a39350e", + "max": 1435, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e5667fda338c420f8e1571798c45b206", + "value": 1435 + } + }, + "8efaf81a0fc24fc48393e318de8ec66f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9de4ab6709124597b1dd6b8083dba7ff", + "placeholder": "​", + "style": "IPY_MODEL_8c8a8e82e16445d0b4e45ff630fce342", + "value": " 1.56k/1.56k [00:00<00:00, 9.36kB/s]" + } + }, + "8efc76cc9a9244fba23931e0ae961dc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_208465f4d5484588a36785a08f0e5d5a", + "placeholder": "​", + "style": "IPY_MODEL_8682a507fa494b379fef0f9b5b0661ee", + "value": " 3.64k/3.64k [00:00<00:00, 21.2kB/s]" + } + }, + "8f1547eced9442a4bc8b6bb2a0c9bb57": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3641147b07c84194beb19387c6367fc5", + "IPY_MODEL_188ad615368d4677849f42daced9e3a9", + "IPY_MODEL_9f4ac4d5c31e475e93617107e203e2db" + ], + "layout": "IPY_MODEL_182c69c4fbc842349bbb54212d22033a" + } + }, + "8f31392dcd0140b8b729c9fc3fd664ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8f334e03af9d4ef18b797590cd1d2f7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8f438a5a09214277abde6a013bbe1d5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8f46a01987f34ba8903e4166df4bd1ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cd60ca7e71e54497926001bf87e757f3", + "placeholder": "​", + "style": "IPY_MODEL_7a43be29be164c52a8874d62a01b29ee", + "value": " 2.68k/2.68k [00:00<00:00, 11.4kB/s]" + } + }, + "8f522da522ae4d34823177cd3aa6e90e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f53ba8f8c7445ed87898f0b40fec5b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8f580fa566b64c7db9c64699e1730e8c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f653efd4f8444668240e11ecc185b74": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f6831ee39f54df486aec11189011b0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f8610fffad4402091f7f48bffb338d4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f8d4b29a32044c89ea2757b1f6875e5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f922de694b243fda8494e30ef79e212": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_155b6ec3988542b8a7519f8d1e61d872", + "max": 2821, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3690d1da40a641038177840ae59cc26c", + "value": 2821 + } + }, + "8f9ff5fb7184412a822437f995b9a2f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7233e536c38e4e4aa49ecde4329533dd", + "max": 2669, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dedf80be58c54a6da1c024afc9be3a32", + "value": 2669 + } + }, + "8fa4f294a4dd4eaca122654a07a58951": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8fb7ec7ba1c643f3bbde36fabc5b751a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0371eb6ccd747fd9450a10062080a1b", + "max": 3284, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3750564167db437983314aafc19e3cab", + "value": 3284 + } + }, + "8ff47c556e5c40538a2a01d0fd058c75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "90030fe712844075ab7a9a2f2857e549": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "900862bc9f4648fb970842d0b24a685a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "900c46ba2cb44abf95b63b891e7a50a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_23136d404c6f4cb3851b3fa4c26d7629", + "placeholder": "​", + "style": "IPY_MODEL_de3e017777d54010bf3b6147b66b594e", + "value": " 4.00k/4.00k [00:00<00:00, 25.6kB/s]" + } + }, + "901422a96fe449efa69641cf1b794c94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "901d30bce786401c8a425c4e3618cd44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_839317f8f28b4b5d992091fe9e8d43fe", + "IPY_MODEL_601a6a231ce046d89bb627a5a25e1858", + "IPY_MODEL_24bf99fb79df437c8399b1aa8edaa9fc" + ], + "layout": "IPY_MODEL_e87653b130ed4efc90101e9655ad0376" + } + }, + "9020bcad7577470a94e89c4f77fcd91e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "902b127f72414d18a274bfb19f2a960c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1dbf03ee74a34a46919100ccc3fa0b9e", + "placeholder": "​", + "style": "IPY_MODEL_6ef35a089c8b4023b07bbd89b4019928", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "902cb54088a545a3a01bacff53cef592": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9035e3778fa84aa698a4498a090180bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "903fbe13d9d44ec98e226e8207130e6b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "90457ab1800b49f4a7e7d483b0ae51e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3aa6ea5c2f8a4873bc0a42e268549813", + "placeholder": "​", + "style": "IPY_MODEL_9d7244dd1234445a88c253f71eb7caf0", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "904d740c4dfe411ab0e26dd0626bdec3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "904e39c40b37420bba1682d16f68e7d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "904ece6e8f9849dfbb84bc1b8e53322c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9053690348744db2bf88247f691c98b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9063970146f04b009bd90d2a7c29efa3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "907b07fdbdae460d8b4164f3e7a9b4c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aadff50db6924beeb69a78f22b97ecf6", + "placeholder": "​", + "style": "IPY_MODEL_8cb5c07289cb4edca11e5339a6b19e0f", + "value": " 2.09k/2.09k [00:00<00:00, 11.8kB/s]" + } + }, + "908b097d474b4424ad81d085fc0149f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "908b66b0b2b04dbb938a1d5885af1091": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9092968cdd7f42ad806456f1660b1577": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "909e864572954b80b269de174c5f2eeb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "90a70fca66b5495ca8dcd6c014f11529": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "90a71cc46c8540bd8548e2fbb93f9659": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1fd33c20361c4ab9b4e284879d3cc979", + "IPY_MODEL_b96861a8db3e4eb2b8f00c69ee2540c2", + "IPY_MODEL_5dfc8dcf41734c98bb2b59873e7474ea" + ], + "layout": "IPY_MODEL_70bb9601b5c14b56bab2122d6e767c97" + } + }, + "90b3b8a2d6df4a28a95156ecf39f3c0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_836c41f4090c45cfb6c581374c7ef134", + "placeholder": "​", + "style": "IPY_MODEL_7578790aa4ee4672941232bbda5b17db", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "90cd7506a61a4c21939ca0c1c69a1183": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "90d88e5ca7184062816125a4ba1bf524": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "90e0bcdddf1a4e8fb6e23322df53c63f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "90e22e5c064d49c98c7010602b3873e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_184b9199c3e74a8896bde4ebc07324dc", + "placeholder": "​", + "style": "IPY_MODEL_1dd431ea9a8e4e0db1394cb15a8b045b", + "value": " 3.14k/3.14k [00:00<00:00, 13.9kB/s]" + } + }, + "90e5c3ba0f7747bea423fa258e2d7857": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_35d57dedc5bc4ae8934508afdddf6ea4", + "max": 2767, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_21e7694cdc734562aecc6ac73955e729", + "value": 2767 + } + }, + "9103f5c89f0b44e7827e1a4b3e38cdec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_91dbcd43795e4ef0870b00f6d7fd1497", + "placeholder": "​", + "style": "IPY_MODEL_26455656569c4e10a0d3e8dd010e88b5", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "910b2790b6944a1197abbc6efcac5f46": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9110669de8b34cf78ed177d32714a8a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4b93724e4bb40b1a7bf0d52ba497c06", + "placeholder": "​", + "style": "IPY_MODEL_f1e2a8b2d1d04cd0bb6b79358f14f037", + "value": " 2.42k/2.42k [00:00<00:00, 10.6kB/s]" + } + }, + "9111d5ef4738417287aa45b65b4f5c8e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9117397f0e8e41f3853fde87166776df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "915a135beee048eeafcac5ba75fdf120": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4c7147e8cd4e48bfbc1a0df8d95d5dd7", + "IPY_MODEL_26594f9b919f4c3898b6ddef330472b8", + "IPY_MODEL_97f937e3f9ae4fb786aa2d34f5a3a26f" + ], + "layout": "IPY_MODEL_706e50bb02e24142bf45917a7fb1737e" + } + }, + "9173cee6a01b490ea02519f0e871df5f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "919ccf81767740e6b0e51f0244d42b6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5a988be3b70645fc93094346c618e832", + "IPY_MODEL_18141f19282a484387bfa2c5877399bc", + "IPY_MODEL_05abdc63f4784bb99b8337ab761478da" + ], + "layout": "IPY_MODEL_bbceaa7f16734639b4b054ed3f1c522d" + } + }, + "91a803ecdaf84287807dd55bc214e5fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "91bcdff17ffd48bd986ebcb4b2485bf1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "91c132d65da14d3eacdd43ebe591387a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "91c19999fa2e4e9c952d6be7d01f1cee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "91c58d61ddbf4b45b2118a67f73507a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "91dbcd43795e4ef0870b00f6d7fd1497": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "91eede4c63b74595b06a7cc58d6a9181": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "91f5b1c12b0843bd97efdddf8147ee2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c2a4dd41475c44a1904cf725622864de", + "IPY_MODEL_0a7c93299ba34ceb9f41ec1612239460", + "IPY_MODEL_9d7b71d7298344f5ad3a1ce9edaf79da" + ], + "layout": "IPY_MODEL_be7f021ee6ef4ae0b73df6b88e516c71" + } + }, + "91f6b95afb77431eb782ae86a29ea2a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8d32da12091946f3863e896347bc7e81", + "IPY_MODEL_2fe87d9d3e394affab458e4ab11b857c", + "IPY_MODEL_cd2f28a173d24b8f9cf464ad0f25e5d1" + ], + "layout": "IPY_MODEL_552ecf3a23ad4614961f85b7dbf8d717" + } + }, + "91fd39518bca4100b9d2f811d37e416e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9205b5f40e5e4f9280e6bdbbef69e612": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "920a149e9e8445f38ec46dee511d95e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e4a42e063fb8450bac61a2fa1fc9978c", + "IPY_MODEL_9ce28b7d25c442409390a4c439259977", + "IPY_MODEL_7e4ca641059e413e9410dfcdbc72bd29" + ], + "layout": "IPY_MODEL_39bddc4d8feb42318076514caba500d8" + } + }, + "920afbfb0fe04f7a8d46b6f2c5649cdf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "921966af9b5e4eba899e4e8617d0273c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9222af4dafe647d8b2b62a8ba21b1242": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9238be051b94470d8d316e82d018073e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9244be8f6d3d45779fba0c6320ead499": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "924909e490754eaaaff0b4feb0d82cb1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9256e2daccde404895734e3e0468ea6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e09a402034f440e9a5edc67056bf8373", + "placeholder": "​", + "style": "IPY_MODEL_8ca6adb555404d329c4dc0d01a249b0b", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "925cbe97d3c14f9ea650fc52026539e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a12d850a64a746b585400c29c5911364", + "IPY_MODEL_fb3aaa0c9fb44de8939c65b32cef9e96", + "IPY_MODEL_e288f62b099f408aba7176e6beb0c629" + ], + "layout": "IPY_MODEL_30ed1855a669469d8fdfca95da2cdc5b" + } + }, + "9268014e1fce4c98bba888080c7e99a5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "92690e94b483488eb97cd09c4e281c75": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9276b7a2ed4c47c99da46853e8fca4ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6c4a398e006f4af6853725ff62c49222", + "placeholder": "​", + "style": "IPY_MODEL_9a43688b74584871886361e0b5cd41d3", + "value": " 1.72k/1.72k [00:00<00:00, 4.36kB/s]" + } + }, + "9281680943994fe1bbb59624f1ebbbcf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "928f4b058a4a4a9899a4f2ce5fbfadc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9295716322b940bfa1cbf1920fc2d384": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "92a55ee03b70484eaa76c8954a5340ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3b5f521ab89409486d7bbc1249acd0e", + "max": 5056, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7c79b6fffe22465e9225d878cfa39b4e", + "value": 5056 + } + }, + "92a6d8efaa6f4884ac134bf478feb39d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "92ae0066ebb741b2ab1af6fb13a3e5b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "92af150fbb614af0b7fec0d35eda0e4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb83a756a2e14835972aaf06491b05ab", + "placeholder": "​", + "style": "IPY_MODEL_fddfb3e673d346bf9d01a8b51914d516", + "value": " 1.96k/1.96k [00:00<00:00, 13.5kB/s]" + } + }, + "92b292aab77842fe968c882a7e0471a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "92b6da65975542aea2a390b30a414cc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eee2ede7cc3d44bbb984a71e41574f09", + "placeholder": "​", + "style": "IPY_MODEL_f80ea21655ed41579163385ff1c1c3d6", + "value": " 1.91k/1.91k [00:00<00:00, 12.8kB/s]" + } + }, + "92c5e2bc61f648c08f6834fcc2a2c75f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "92cde396f9014a40b024fa3241e121e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f5af42802496449b9c29fb41fb5d9e15", + "placeholder": "​", + "style": "IPY_MODEL_908b097d474b4424ad81d085fc0149f4", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "92d2d20c50b244aeba5ab105a75be8af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4b36e9ab7e9b4646ab49bd6dfe384944", + "max": 1286, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_21423cf0eb484026845330bfd1131a08", + "value": 1286 + } + }, + "92da075d497d4d2ab5a3e65e8827d0d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b0d463f8d60d4e4180089ee08f481e56", + "max": 1777, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_72765007ce1641928ff20a2f372b8812", + "value": 1777 + } + }, + "92da86bcfda944a5a53ad0d9096f109d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "92f31bc1769b42c8b9b4d371f62234e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "92f38008cde74333aaf64d1243975398": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b959aba56e8a4fdd869eaba75c4354bd", + "placeholder": "​", + "style": "IPY_MODEL_34c692e1885f42978284204550f32a27", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "930032b5a81848cdb1a77b5bbd1a2186": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "93050188a11f4ff5b3e49b76eadca644": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9309ddc565b74b7ea4f42e3a0d10f8b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_88dfb5a4c6af41f79de05897352e29cc", + "placeholder": "​", + "style": "IPY_MODEL_5a3eb953ba244a3499e03419d88b9b92", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "931b5b63d409473689d92965a864b157": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "931f26b287a14503b1730dd9227b88e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9bec013296344ffaa74e83754ce2ae8b", + "max": 2385, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0f3c5dda7dc045cdb89cbc6cfc6a5da0", + "value": 2385 + } + }, + "9347e69e3db5460280382522c42dd0a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "936e6e3e12cf47dc8bfb4ce22e8a400b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "939a9ad240c1492f85ef8fc4a20e1161": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93b37eb9f7684200993c00b158e92730": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93bef73d1e72479392d09a6851573411": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93c2da8fb1d643d9b5d0325937b0fca0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93c572d8ee1f4f7d8222784e5a6ce270": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ae2a76eb4b164b5ab30af49670ab58dc", + "placeholder": "​", + "style": "IPY_MODEL_f30a46062e68457eb3254c98fc2fce38", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "93c5915fe8f7422eae68f5d969b3b661": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "93dcb2a0cc9d4fc690ef27442f18a116": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "93dd0152ba1b49a38187659a7c97969e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_143e0041cf3d48f890e90b50b5297e06", + "placeholder": "​", + "style": "IPY_MODEL_5e0c488830fb464e80d6c072b69d6af9", + "value": " 5.08k/5.08k [00:00<00:00, 23.2kB/s]" + } + }, + "93fe0e0226ed4d7388258bee55f536c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "943d2c83b27b4005866a9031e87bd928": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_469457d23f634287a8d34321f71f7bb7", + "placeholder": "​", + "style": "IPY_MODEL_54879bb588d242e49f8ae707e9449d06", + "value": " 2.61k/2.61k [00:00<00:00, 9.05kB/s]" + } + }, + "944415f3735e412caf969fb9b8611ae9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "945ebb1ca3eb4bc09d6b52898148e04f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "94635859e324417a92d4441a8e2d4c71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "946cf0c0ed42476a9844610f5d21ae44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "946d40b249ff457fb8c7612d995e2cf4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_37681c6c9cfd49cda4d9e5abbcced7e1", + "IPY_MODEL_0825289871574ff7bd8271862bfde792", + "IPY_MODEL_ea6a01e499a648e78fe516b32d7a05d4" + ], + "layout": "IPY_MODEL_9b75f5780aaf45f6beae9ee83eb6a79b" + } + }, + "948d3111539d4e41b406398a59bf7268": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "948d99fb17ee484eb58ed847c5dbb2ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9496500e7e1b4e66b830707566c474c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "94a2f68fa81a4fd89c739fdf581e9ae1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "94a3119653014631a9087231b7521d18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ce486005dbe340a59a1db2e9a7f4bb3f", + "IPY_MODEL_f55b5c959ede48c888291bcfe6b355e7", + "IPY_MODEL_7269294bb59049308410718becfdeed9" + ], + "layout": "IPY_MODEL_7680a1f18fe24a4c970f83bdf25bc59f" + } + }, + "94b229945f4f448cb0ad850915b6c340": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f6434b5ffcfb4bfbacc2357cc036009f", + "IPY_MODEL_e67b2ddaa6554f65ab929d287415f098", + "IPY_MODEL_ef43291c1c054539be42678c3f1b06cb" + ], + "layout": "IPY_MODEL_1d703ecd11ab4b6bacdc74794ae8ba52" + } + }, + "94bb758a893a43bab4cb9f82bf6f9eb0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "94ccdf8357de4bc692918fc931ca07c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "94dfa312dc4e4016914715be97e96eba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "94e34f9bc25941ff92c79f7ac582f1eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "94e5f646de364c7fbf1f30011f71ec73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "94e764a64b714c29aa16c693528dc16b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "94f46bdcb7914a8eaa79db54df980167": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "94f9c79f57474e7fb35d10ef4391720a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ab35ef5c44924386aff1569cb6af0b43", + "IPY_MODEL_639aeb1525094e649f5bd404790aa1a8", + "IPY_MODEL_78be75b0033f40fead4eea748740f0a2" + ], + "layout": "IPY_MODEL_226f9fb5d5d74a04b9afed400b71df41" + } + }, + "9501dcf5ba7f468ba960d110073601a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9503a5aec8a940a798163249bb0ed2cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_90a70fca66b5495ca8dcd6c014f11529", + "placeholder": "​", + "style": "IPY_MODEL_69b69fcff95749deba21122b0fb9efb6", + "value": " 3.73k/3.73k [00:00<00:00, 13.3kB/s]" + } + }, + "9509d791074c4df898e874250d5c02db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9513e91d07d84ee49d09ed90d22f0ca9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9517dea5a8d44435970ec50b7a407089": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "951b91952fd14eb886111c975c596ecc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_860d66f6885d4532b5fd5ff649551f4b", + "placeholder": "​", + "style": "IPY_MODEL_dc2b2ace1fc643f6bab6f4056d5f0735", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "9522cd3f14a348eca5b861f6954049d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9527e89f4a70470a9fc9b32996f3f111": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_573658360f244446b1110e0255719d13", + "placeholder": "​", + "style": "IPY_MODEL_e788f146051c467386b14eb1a2acdaec", + "value": " 1.56k/1.56k [00:00<00:00, 4.31kB/s]" + } + }, + "952c7aaefb4449b4b8d4d7fa09a48a72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "953070b85fc840dbae65bca07eec8112": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9534a63875e242f1b2b13af0b31816d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_99b6a4e8dcf44f85b86d56200ef9aaf3", + "placeholder": "​", + "style": "IPY_MODEL_04c80c35f52248d3a67c3c598d410eca", + "value": " 4.14k/4.14k [00:00<00:00, 21.1kB/s]" + } + }, + "9539cf21c7844b1893a9c67c0136a4cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "953d5cf0fd7340e2b96963811165ffd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5abb12dfdcb9498ab4baf1bd54f0579f", + "IPY_MODEL_c80ce5513b01458c95e695336ccec17e", + "IPY_MODEL_ddd7bb5d7d5e4621873a428ab3d83672" + ], + "layout": "IPY_MODEL_76dccd35cb3a42288e8e787c818aa51b" + } + }, + "9540ab146d114af38a7bf87d264aaa68": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95410020c6004486b5fe6963052c7dab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "954915abc01f40f2b79e9a2b19a101eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_757c86b9023343fe8e14990bef7f235c", + "placeholder": "​", + "style": "IPY_MODEL_28d2c547300a470b952a0d687e30b161", + "value": " 144k/144k [00:00<00:00, 865kB/s]" + } + }, + "955049bc27064fe2bf0c92efbedaf5ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_63b41bef602549888917b460ff850bd3", + "IPY_MODEL_47cf92f7340b43f2a8cd7bdfad345b4e", + "IPY_MODEL_362b9658a2f3422ba4c06833f75720ed" + ], + "layout": "IPY_MODEL_89a4961fe5a94ec3ad87b133189d6977" + } + }, + "957128c8dd5347f4af0ea35599f32b51": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b690e33f0a484e5683e5c550332345ab", + "max": 149972, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eab22391f959447ba3816f0eba6a8b0a", + "value": 149972 + } + }, + "95799885148e452d993fb43bad35ae6a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "957c2a21ccf44ebbbb9221df782731be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "95829ff409954b33abe6a5f6bffe270a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9589fd8b66f341f0b9deb7ae63adbd03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cd2617817afb49b5a012f489b0371e69", + "placeholder": "​", + "style": "IPY_MODEL_c6fc05bf3b97420b8387aa4e0070b11d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "9593bab15ccf4363a4cfb3070d18dc77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9595c62e1ccc44cf90c12775184acc68": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "959c48251a3b4a51bd49a47ecd8c8a51": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e1904b4f110143fdb4378ccb285ef492", + "max": 2656, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ebab7ead7528424cae1b06730d222ecb", + "value": 2656 + } + }, + "95a1cd8f701643bc8fd80f96e6d427bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95b855ccefef48f2a3b9edb3cd878737": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95bc1c65857c4de79df508645dd27d87": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95be018529964c0fb7881d589f3ed6fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b96785226f554e718d823d7fdbd1e9e4", + "max": 2498, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_281836d326fc45ddbe37f5227e533596", + "value": 2498 + } + }, + "95c038dffad6456980867c5af07c5a5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d89565b61e5343b3a1356c2f479e3dd0", + "placeholder": "​", + "style": "IPY_MODEL_b800b2df268b4c0da537e6c3f097c56c", + "value": " 2.20k/2.20k [00:00<00:00, 7.56kB/s]" + } + }, + "95d12f3de0ec4c1d9b4b15e810e4af44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95d4ce53218a4ef79283c20926fae78b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95df8b1a73ef4e99b5be78a3321e3933": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95e4ee710fb448929f0b1a118a1bdd0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95f77cbf40414460ba1709e8442065b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bee1220061ad42feb4be374175fd1830", + "max": 145236, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_920afbfb0fe04f7a8d46b6f2c5649cdf", + "value": 145236 + } + }, + "960e6b2028af4335baec1a8980643f20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ed502a9b444142a88ee3eca15a175705", + "placeholder": "​", + "style": "IPY_MODEL_d621bfa2510b478598c3fd4ef7a947f4", + "value": " 144k/144k [00:00<00:00, 781kB/s]" + } + }, + "961e85f7828343c99f66f4a4f622fdd5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "962d27159b2141bc91566958f596e196": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9649efd9fa064860bfe33ebb3731c840": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9665eb39255048768c65539713c4ff7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9670537237f241c7962a9aab6245f14d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9678f86c98184c698e3b2600a296213e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "96858d2e05e64f399cd517d80ecffc35": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9688a3cd4ba04b0289bb7e9c2a834570": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "96aee07a9e5041ce978571a4ff65960e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_97d2493c63c54eae9888635e616f15b3", + "placeholder": "​", + "style": "IPY_MODEL_7cf82e8870a0457daffe713685ede248", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "96aff9a9ee714140a87101f50190b5bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "96c1faf31d984ee197eda3e902c2baf3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "96d39f5db56948fdba83ab3a09128b74": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "970e880777ce4c86a4c49829169c3251": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_394d5976f0a544819dbc57a01ccf7565", + "placeholder": "​", + "style": "IPY_MODEL_f66427cbee42482c9504bc608d6d33b0", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "970f443709e44aa28a1d5a77fdf1b899": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "97102016a2a940a39f2865aad0f8e289": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9718fb2003634ff5953ee265ed117c2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9727d0e3e3474e4cab6cee8641e3eebc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "972a049f41074edea4f324f73af3e573": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fb09ae7d5f1f42db956352663e477efe", + "placeholder": "​", + "style": "IPY_MODEL_d3be718e9bbf48f59ee4849f54df704a", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "973a8e144a4a4caf9664f7c0521f0532": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "973ab01368fd4ab8b228d150f3de7da3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "973c9e95f279499189ab90bf7e356ede": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "973d7c138beb45b1929b98e1876ff22d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9744004389cc4a2cb492e6168676a884": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "97520f36c0a84b128895d61c734f42d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9759780fd719462cbbaccf0799c2b8c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "975d3ddbcfe848b1b109c47ebd081b4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_54894575098d49c0b366352f4485ea9c", + "placeholder": "​", + "style": "IPY_MODEL_d6e8b7b419a640b8947e9b05e6f251e1", + "value": " 2.17k/2.17k [00:00<00:00, 14.4kB/s]" + } + }, + "975f3a8c3d4c4719a39301e38423a0fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9783013c85894208a1e6bb1a54b02004": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "978df93a979845939a26cc7971a2f83f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6c4f990d75784afab6abf2ca99f0f845", + "max": 850, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_36f39723938d474ead365ebe84a8265f", + "value": 850 + } + }, + "979575d2bae747c6a60ada6d0ab0e7ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f24324565238444dbe3a2c305df2089b", + "IPY_MODEL_b52dcb671cad4df0a7c2dc9798a46936", + "IPY_MODEL_5791941d37ac46fe93f9aca84b1b243c" + ], + "layout": "IPY_MODEL_d0f5bacb12d24c0db1f87b2fdac2a78f" + } + }, + "979dde537ac942afa423bebef7139811": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "97b1eb4ec5774174b1e5e3e043d09922": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "97d2493c63c54eae9888635e616f15b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "97de91cf96f54102a1466f9fcf4d24f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "97e44eaa9ced46798bb1f6fe42a53cde": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "97ebc4e559654238866b044ca7f88b5d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "97f937e3f9ae4fb786aa2d34f5a3a26f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_614cb1d01f2f492c9a5009ce0f512b63", + "placeholder": "​", + "style": "IPY_MODEL_a74e23b80a4b44b8887698a01a9825a1", + "value": " 1.99k/1.99k [00:00<00:00, 9.39kB/s]" + } + }, + "983a2f4b1b6843cf91ed56e08a40a76c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "983bda56ec4a44bdb276fceeb85eceb3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9853001d6c8949849b76840158ed6290": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "986703b1ff2148938337cdbbbd15cae2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1c6ec1b2d26a412d938a397097504b8c", + "placeholder": "​", + "style": "IPY_MODEL_1133b3dc7ba249689b6e8a4e4b1ada68", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "986911ca1f9f4e069151b7b894e169f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_30d19606a69c4abda846379b3bcc6aab", + "max": 1472, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bcb0c02826554995945534d0002fbed4", + "value": 1472 + } + }, + "986e00b4ac214ef1add19b8ea8ad73ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_886f90c5df234f768b06eb9d0cbc03db", + "IPY_MODEL_339b5448aedd451a8d8ad56f5235c622", + "IPY_MODEL_6b86b9fbe4f042728a78b5412c5dedb0" + ], + "layout": "IPY_MODEL_946cf0c0ed42476a9844610f5d21ae44" + } + }, + "9880088a9a5e42829a3d357fce101ecd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9cb096f2bb054374bf0fd2c5a55e7037", + "max": 2861, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_793acddad31c4bb19ca6fb7194983e68", + "value": 2861 + } + }, + "988013979fe64b25933544bb25131efa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_65a84cd44b444b668d98988519843568", + "placeholder": "​", + "style": "IPY_MODEL_d8078c6773cf4b7ca7804534cd5a0cba", + "value": " 1950/2111 [00:39<00:08, 19.06it/s]" + } + }, + "988076fe0f114bfaa5cebbe01353ab89": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9884f5c62dae4fe3848d6a39ef1bf8f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9888fd84cdd1468c93eb6758b7aeb523": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "988cdc08b067469687b839de53768ed9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8e8c962602d3454590b802e2a3e97276", + "max": 2697, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_def124b279af47fb88d91e33ab62ebc4", + "value": 2697 + } + }, + "989157da04f8473c90665eaec8558bff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "98937268e0894b1fb565637bffd7ff5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5be334d43d364b59a7b3b750450cbcfe", + "placeholder": "​", + "style": "IPY_MODEL_206fb37080b844369ea9101e6725ef96", + "value": " 1.06k/1.06k [00:00<00:00, 3.45kB/s]" + } + }, + "9899417287b3424caf309ea2b933b928": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_557b7e62c3fd4f368cee56a88b6b049e", + "placeholder": "​", + "style": "IPY_MODEL_5c37b3d134f548719effd448c3679f71", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "9899e34882cb427b82dd4d561e7b4704": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "989a922a017b41c8b7cae6618980c845": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "989ff5a668f8463584fd4dcea6db98db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "98a39a57d5264eaa9da170e75b666426": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c70a2b1f5e84460791dadb42552b7c4e", + "max": 2197, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b90567b033e941348bbb0a7c2eea7395", + "value": 2197 + } + }, + "98a496e4cec34a52be5fc252d4d78088": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_efb7457baedd4b5a93140453560619ad", + "max": 2943, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7e2b0ceb09714f3cb769f89f261eeddd", + "value": 2943 + } + }, + "98aa51927bf84e63b23df7074a023fe9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "98d70605fe5649aebcf8630e140ef3c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "98ed8eccabb2449fbb4a369dec687480": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c25617f7d10f47d6ab3972d1439a0548", + "max": 2685, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d48d0e6491c844268ab8deaed270279b", + "value": 2685 + } + }, + "98f760db493c4cb286cdfad937d0ab0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "98fdca05001448cdb29ef109296ab240": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "990574d93c8647159e779d4d1e1707d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_34650cf096c54f4d9fe62ee91189eac3", + "placeholder": "​", + "style": "IPY_MODEL_aec2e4055a0345758b5ad7db7f76a65a", + "value": " 3.60k/3.60k [00:00<00:00, 17.1kB/s]" + } + }, + "9911462630384121b857622176cd2f9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "992e3a33dce545b1bde39a802fc2d1f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3de1499e99174b0585a7edac4751d823", + "IPY_MODEL_2933367ca72a4b0bafb85d3e9d153f0d", + "IPY_MODEL_75006769140d4f38aedb3bfb89fc0ee8" + ], + "layout": "IPY_MODEL_1ce9f315fe80443f885e321ea4dddaf3" + } + }, + "993372b0e77c4d5996ab1dc3218857d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "993a96ddb18b47d99ca8dfa19a460d1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57ffedfc04774a72864bcbdd74cbc1e6", + "max": 1607, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_25afe5de45b7446b89cbe4d616509a70", + "value": 1607 + } + }, + "99415b66463d4b1281234edba0b1c580": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "99524bac1d7f42f8b5a7bfed87b73e9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ccf8f612bf244ef5833c3253db6daa82", + "max": 2436, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f6b8c8611c2747469aecd8e72e5e0557", + "value": 2436 + } + }, + "995e62c504a94235a05526bec728d6b9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "996f2543e55e4aff8b0593e9ef268c2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "997a74646ea24f0bac09aebdaaf254df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "997a970cafb14a9f9280ad02b01a96dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "998491fe8cdd4f39bb205c515343e444": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "998610555d474d9cb1735592bbfeb035": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9989e4711203453285adac06e98f9325": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "999190a0ee0c4a7c82ba8f915bc911f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ce08a6817ef54cabbf210ee909e2f2af", + "placeholder": "​", + "style": "IPY_MODEL_833f957dad3f4b23b726dc12e1e7f7d8", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "9992c49c8cf6461a98028aa9c2ec98ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8c0bca1f03314613af0cdea9603cd322", + "placeholder": "​", + "style": "IPY_MODEL_910b2790b6944a1197abbc6efcac5f46", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "99954c235b9d4d589a68d0278eb52144": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "999866dc6d46430e8c67a3de88bfa85b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "999d2873de7640c9938b6cf5b876284b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "99b6a4e8dcf44f85b86d56200ef9aaf3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "99d463a923bd457781dc42af2f2a13ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "99f7caf54ea14438a58e5dae018baaf3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f80597d919ce4fdd984720e3794c5263", + "IPY_MODEL_f9909dc8500b4787a61ee3cbff6c6b0d", + "IPY_MODEL_e8ca16c1962c44a9a3d3b85154c0c98a" + ], + "layout": "IPY_MODEL_02fddc077d224892bc1dd294702fcf2c" + } + }, + "9a0dfd4400c045ffbd6b6232f101dd2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a24f57e72e54eeabd3c4345e800dbd7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e214328e0e4f4896a4cbbd3de1543d9f", + "placeholder": "​", + "style": "IPY_MODEL_419b5fb1393e44018f904d18c67fc54f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "9a3768a9ae124944ae58bcff4444b4cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a3ca082918a4716a7d37695b068acda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a43688b74584871886361e0b5cd41d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9a49fad6fd9a401bbe72ecdc53600952": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9a4adbb90790415baea4d366ac9f964c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a60a37ca06647e2883e120a2bee3ab6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_018a871845564735b153282edf24aae6", + "placeholder": "​", + "style": "IPY_MODEL_0d318e10d5494e019f0fd4f8a999a6c3", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "9a766bb59370460bb7336ec1cb4f4d2f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a7c4ee9306d4747af4634d9e6742116": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1513fcd1969e41ef981b1acae79d455a", + "placeholder": "​", + "style": "IPY_MODEL_9f123d6141ad49ccb38f43cd7bb3b6ae", + "value": " 2.58k/2.58k [00:00<00:00, 10.5kB/s]" + } + }, + "9a9e28a68615400b9c4dd4b764b3cc1e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ab50075ffd04418b1be6d74f8e9564c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ab6e4d6aae54d9096bab5654fef721b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9abeed165220422ebacfa4de7edd6e1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9ac61caa3d9b4afa9e84e0030b6fe209": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ad1849928ae4f509957aeea0bcadcf5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3eef5fcf83624a07b31a234caba7c4ec", + "max": 932, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6b1b20aed291423c8351c087e595c758", + "value": 932 + } + }, + "9ad82021080b4c33a74440bcfce0e5d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ad9d715e689480492db6b42e14c44f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_896463c18d8b456ca7725681b5fab2bb", + "IPY_MODEL_d209f6e7c21e403a99cd2b90940f475b", + "IPY_MODEL_d50257c1f5d0427dae7b2fe8a4fe88c1" + ], + "layout": "IPY_MODEL_4066af1a75344e3291bbd9b82e721e36" + } + }, + "9b069609240e42d1a4b78cb3586b9392": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b2f5dd8af524000ad6e6d6935964843": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_892069935efb45eea0955e4870114b0d", + "placeholder": "​", + "style": "IPY_MODEL_18be3174c0e44705b83174ac52dafffb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "9b35b88e594a42d19e6156ae10b238ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b3d86842e5d423c8cb05e6d5276474d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f9cfb174ed3543ca8d589fb33bd11790", + "placeholder": "​", + "style": "IPY_MODEL_8de77fae37854035a0df4f5c055eb053", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "9b473e967f7342f28f4bf3c15dcc61ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_35fe5d53193744b3aedf039ad424cfe8", + "IPY_MODEL_0f3b8678e9fd41aa8c981936cd629aa8", + "IPY_MODEL_32a7046f3a7e48838ba13459aacc5313" + ], + "layout": "IPY_MODEL_805e826d4298449ebd4500db5c8ed019" + } + }, + "9b4daf37a5c0483eae0001ccd65d56ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b576ca818594d3f801623f2013d7a0c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b60a00bd843471bbb763b2124425402": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_320a2b54e114488f862226880aaa3556", + "IPY_MODEL_9e7a0a78ada3450fbd37e107abd1c8f5", + "IPY_MODEL_808f08fcdfb54f72934c135037bc5f54" + ], + "layout": "IPY_MODEL_67ac827b1bfd40898d112b54e7381304" + } + }, + "9b6d91413f104bc3b68c86af04a0880b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b71b9e8b3bc483c811f60cb971de80b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b75f5780aaf45f6beae9ee83eb6a79b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b7da3897f5e452f8c0e397dac387eb0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_35a3398182754026b9aa3628d9274699", + "max": 2102, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b299407cb23f4f1d8eb2db78755c344b", + "value": 2102 + } + }, + "9b88a7f32b274bbe856ad646af95febb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8f8610fffad4402091f7f48bffb338d4", + "placeholder": "​", + "style": "IPY_MODEL_272cd7cff658450e89b5067cdddcb3da", + "value": " 3.37k/3.37k [00:00<00:00, 21.8kB/s]" + } + }, + "9b8950df54de4f68a822f5e07af599d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9b978d29d3d34d50bc2e3661f50a9f8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9b98b4b9cfe4472fbb488af7ffa59cc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e75a6481c3824589a0a77c8ed31a672d", + "IPY_MODEL_0b72512a4e9c4266902c1b480e051e94", + "IPY_MODEL_63fea45103db46d6b280b2325954cf2c" + ], + "layout": "IPY_MODEL_5ab544786a914fa0b20912b3e44912e4" + } + }, + "9ba61d42f3634943a68a565fbdabfc05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9bbb957167e2487985265160e2892ad5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f503e87bed04eb287322b70be8e0d77", + "placeholder": "​", + "style": "IPY_MODEL_74389671135745ce80b98ded35d0ea89", + "value": " 1.75k/1.75k [00:00<00:00, 16.5kB/s]" + } + }, + "9bbd5a482bf74264811d6fd0ce2c412d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_20e2059f029741b7b4e1d7db0206dbc6", + "IPY_MODEL_2f8ed28d5b4f476d9a5ccb04a96d62b7", + "IPY_MODEL_a19ba3b4da9f43c28929dfd34d57a348" + ], + "layout": "IPY_MODEL_2f295f94023c497f99b38f459b9b128b" + } + }, + "9bc2c8a2bdfc4340a015d4cf1b1ae7ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dcb00c91b0294d3cb9112f6939867440", + "placeholder": "​", + "style": "IPY_MODEL_aefc32697a7a4d5d9592682df515c5c5", + "value": " 2.03k/2.03k [00:00<00:00, 8.00kB/s]" + } + }, + "9bec013296344ffaa74e83754ce2ae8b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9bf9c54bf2db42ec9ab5f94ba1d9ca30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_56546ff1152e40fbb7067b6ed4d30030", + "IPY_MODEL_9cf3ccaf57a9484aa477b519df7d46ba", + "IPY_MODEL_4be293e45d4544c59df10a7349fe4378" + ], + "layout": "IPY_MODEL_be0656babada43e2b836ec3b66bbce78" + } + }, + "9bfc0ad157b44512b476e8da371f4d4a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9c1a960b4bf94152a0c0451a02ea43b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9c1e926ab35a41e985743cb64c7aaaef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9c2a3b4445a3411ca1106a2bc133a364": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_79297e990e3a493b915cef5f9aa3b992", + "placeholder": "​", + "style": "IPY_MODEL_671b10e6c6da44b0b842865b7c1de182", + "value": " 2.25k/2.25k [00:00<00:00, 11.2kB/s]" + } + }, + "9c2bd07a5b884fa1997ed28aa1aeaa68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f695e19ca03b4a248c4bb4b713c6b5fd", + "placeholder": "​", + "style": "IPY_MODEL_4633a70e2bd14f8db73dfb23551b48ab", + "value": " 998/998 [00:00<00:00, 6.51kB/s]" + } + }, + "9c348660fa8a4c2d9475f95cacd5e7ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_541735a0ae0e4a1891b23d9f1d71695e", + "placeholder": "​", + "style": "IPY_MODEL_aa6f390818c44dd7b6c022dbfb969d03", + "value": " 2.53k/2.53k [00:00<00:00, 12.8kB/s]" + } + }, + "9c388a074b004f738373b518d3bd3ff0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9c3c0293a6e44978bef0e11f4f460b5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9c42e1e2f7574defab54bf292d4e7fad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0e95c3761b8840668724be7bde6c09d7", + "placeholder": "​", + "style": "IPY_MODEL_69ca60f5981d44f9bcd55a8493e22826", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "9c560d7f856a408b8160dcfb0a368160": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9c63572b045c4ca5a9a589e9fb27602d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f0206caa22374965bf0d0b6861ae8f60", + "max": 148921, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7e97d88de8f54d89bbf8aceebf2f87a8", + "value": 148921 + } + }, + "9c66f0ea87ae45f6acffa72ef63110c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9c68a395eb0348bca7361e4ff9a9da91": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_52f581c78d7e4b0fb7fdb8dfebead9aa", + "max": 1605, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9ba61d42f3634943a68a565fbdabfc05", + "value": 1605 + } + }, + "9c6c623a1cc84bb7b92813cf66941969": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9c7561a026944e4e9d25e60783110fc4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0b215b5f9204a3bacf5cc7eb3e6164c", + "max": 3732, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_02e96dd2652a402284a3be5e33ad65dc", + "value": 3732 + } + }, + "9c805251790542fdafc248dd5bad0aed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9c84e32cf5d6473b8598fac0c88e4846": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_05d8142af9b54fef9f25c67abeefc4e2", + "max": 143862, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0567b360036f458e978dc8d913f0a546", + "value": 143862 + } + }, + "9c96c6bffb7044cc83a35cd821bd84c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_495baafbca14471cbdc33cbc6152b2b8", + "max": 2117, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d17644a9931c4f58960c59c419bc5415", + "value": 2117 + } + }, + "9ca1ef94d9c541cba28cac0d044e92ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ca6daa9b9c84d399ffbac8c596077c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9cad731ed5534c35a1edd808766c18f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9caf1757f9714668aa70edf835fb3423": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b22b1b91fcff4d029d596cdea888ce69", + "placeholder": "​", + "style": "IPY_MODEL_c83d0290a9a54f1b8f92c6327cb7eaa9", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "9cb096f2bb054374bf0fd2c5a55e7037": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9cb3e2318592461a8c38094960701e1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_696c17edd8da4b91b1a054ede2d3cf53", + "placeholder": "​", + "style": "IPY_MODEL_416a06929ae943f686911aa23156ae1b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "9cb854e99fd641e18c8e5a8925225fa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5d1624fef8da4d56b7b72d105916adfa", + "placeholder": "​", + "style": "IPY_MODEL_c5580939257e44bdb8f9768f2ad70405", + "value": " 3.10k/3.10k [00:00<00:00, 10.8kB/s]" + } + }, + "9cbb5ddc1c944376a804104a984f1798": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9cc2bd9b5bdb4a169e09b025662d3e3a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ccc4edc19344872bbf0d77415708ece": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9cd82f62b0504528a18bc9c2540d182e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_13604e4f8f5a460ba70a99b935057b95", + "max": 144289, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_02e4d8b852ae4bb4a00de1a46b258d1e", + "value": 144289 + } + }, + "9cdea6f6a01b48048a7d1386938b55be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ab50075ffd04418b1be6d74f8e9564c", + "placeholder": "​", + "style": "IPY_MODEL_97e44eaa9ced46798bb1f6fe42a53cde", + "value": " 1.88k/1.88k [00:00<00:00, 10.0kB/s]" + } + }, + "9ce28b7d25c442409390a4c439259977": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_01a18f4aa93d40d78fae30056d065ca8", + "max": 2878, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_083d21d8f8ab49d19de9b712263f23f7", + "value": 2878 + } + }, + "9ce69388d0b6402480860b15cc304593": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9cf3ccaf57a9484aa477b519df7d46ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e5f450e5ad78495f8e07e6bdff5d1b68", + "max": 1177, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ac0e0e04571c4fcbbf10e8088fca9040", + "value": 1177 + } + }, + "9cf8ad9bef3b430b857b53340d46ba99": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c185a31815e148fea5f35f0f40e1f7b2", + "placeholder": "​", + "style": "IPY_MODEL_56c60580875242d1953adf88c1c4b7a5", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "9cfef1500f8b4752a3f2a049cc8a2d8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f699648f0c6c46d4a736de42c73a616e", + "placeholder": "​", + "style": "IPY_MODEL_448e718a525d4f769ebaa4547a3935d3", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "9d0de92b842e41e0a8ff241cdc27dce7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4bb21762149d4ce9b29f48b5e8d9b097", + "max": 1602, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ec7c860f22624acbbef213de8e308035", + "value": 1602 + } + }, + "9d21b565918943b38e2eba6ff19497af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9d268805b72f4093a719a2df1461f307": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d2f4c8b5f594621b3ed967f56b64f87": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d3ac651945745c19fe033679b94bbf5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d3c31165d0e401fa21251fed2069fba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d5e2a164a194da89eaf384d1ad2dd72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9d7244dd1234445a88c253f71eb7caf0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9d7538ccf3be4ba69439d5848cc9704a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9d7880e901a7475aaf05516f6034ed6b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d7b71d7298344f5ad3a1ce9edaf79da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a055713ab1e44c7a48126b982fe6d59", + "placeholder": "​", + "style": "IPY_MODEL_dfe53a0d143f4fd69cdc2326dc9be741", + "value": " 2.94k/2.94k [00:00<00:00, 10.1kB/s]" + } + }, + "9d89a975fc0244d48d83df681b13d210": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c9e4317208bc4423b010657b30da285b", + "IPY_MODEL_52f0488904cc42caac6a980abef337fa", + "IPY_MODEL_43f239bef2104e2f9c76fe2cf8703597" + ], + "layout": "IPY_MODEL_872c4e032fe741f4b209aa022b89aca1" + } + }, + "9d8bb131483c4d97ac2e29331dd2c5c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_92cde396f9014a40b024fa3241e121e8", + "IPY_MODEL_bb502cf8a86b4cf8a32c106cfd31a97f", + "IPY_MODEL_e6f00cd5115348229cdc350b70c78239" + ], + "layout": "IPY_MODEL_a5bec0a6037f49fd88e47c41ebda5d27" + } + }, + "9db51721964b4d19901b61a3e1d32e66": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9dc6b6678ce1419fb7366f4ff34640cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9dc9fc25ec3a4ff98a1e7ba774a0d222": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9dcf1c4865874fea8d415aa420b627a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9b4daf37a5c0483eae0001ccd65d56ec", + "max": 160031, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_db923c63b67547d1a33d73374dcbf4cf", + "value": 160031 + } + }, + "9dd12d42367a437c98050be5f01aeb5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9dd28dc9d46a4fb2ad803054dcfb2dd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e093daab5e2146fea51a45549e869508", + "max": 3293, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_addfa7e1ca3b4e2bbfa3bbc0774b26be", + "value": 3293 + } + }, + "9dd5ff1306064fc4bdd04ea3ead29a39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_975f3a8c3d4c4719a39301e38423a0fc", + "placeholder": "​", + "style": "IPY_MODEL_36f08cd351b84b09a97523210806c501", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "9de4ab6709124597b1dd6b8083dba7ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9de54fd4235e4155a4c2d0799245c412": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9def15835d51428785d689e709ec37c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b5ba74a593214b7181a467333d145020", + "placeholder": "​", + "style": "IPY_MODEL_3e37b53b17d04487b452b62c268e9979", + "value": " 992/992 [00:00<00:00, 6.34kB/s]" + } + }, + "9df384158c9641378bdc922e645f7662": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9df86288ad4d4287b248751a6c8cce5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_33ab172994714f3e951bc04a7c9bab38", + "placeholder": "​", + "style": "IPY_MODEL_858d122a0cc04477adc67503f01fe527", + "value": " 3.48k/3.48k [00:00<00:00, 22.7kB/s]" + } + }, + "9dfe9fa945c54cd998fa2d4957f25e40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cce19dad79874b8fb65f9f3fda418dc8", + "placeholder": "​", + "style": "IPY_MODEL_1b883b1d5cad40088cfc6e23b95a1f8d", + "value": " 1.35k/1.35k [00:00<00:00, 5.76kB/s]" + } + }, + "9e0614c14e3e4672b4a6e86cf3e2e552": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9e296deb1c234677b783bc56852c7b42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a5f696dcc26e4d749f7fa2462d03bb5b", + "placeholder": "​", + "style": "IPY_MODEL_3cda5b9f56c548bbaea1c140b87b8fd5", + "value": " 1.43k/1.43k [00:00<00:00, 8.49kB/s]" + } + }, + "9e49a3b6d992492c838ec42e5ea1628b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9e5861cfb8674136b4d69bc5949f3843": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9e5c105474504a189226eaee66d2574a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9e6607ec145142ca90e71192e179800a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9e7a0a78ada3450fbd37e107abd1c8f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7759eac59dd94abd899fe9febe971dbe", + "max": 1297, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6193324d60a34caea316a0d066e05490", + "value": 1297 + } + }, + "9e7ca22e7ff84cdcb0f9ce37dba4de90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9e7e37bee25549c3a78e377071c185ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9e817d4c3d6f458baea0e30468acdb48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9e9784655f6544eea705a0adfc874c7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9e9b1a7f1eca49d996daab4cee523a8e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9e9d11be4d00406eaceef9082a67b6de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9ea8dc5ae9b7492f90430e40dca3a741": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1a4d05c332974d63b2a69fe8d56277d0", + "max": 3951, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_df1301790fe9468991bbcf206c9476f9", + "value": 3951 + } + }, + "9ebbaef863a94503abcf6de1f7fc228c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4db13c081baa44cdb8612b31568e2701", + "IPY_MODEL_cc4027875b7a4e74a4074c6a5c00905a", + "IPY_MODEL_e42502bd9d6242c89dafec5e75d2085e" + ], + "layout": "IPY_MODEL_1c9857915e6a4326880ea40d63330531" + } + }, + "9ec1420e8b624b1b9cdbba18d1f4b4cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9eca51c2d85d428da4df8574722485fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9ecc4238df784f46a898eb74fdcefdf1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9ecd1e2c66cc42438c640a8c4946b3b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9ecf049840194fd094721e964c0e6664": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9edd4e2e8e984a5e995a2812680b2649": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9eee41b017be4bf3b9d1149b217e4461": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9eef8744155b4cb7ae5860b6bf6b6491": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f0136948a1f4042970af817e3605851": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_de08b0c3752342a99ac506e388b9a125", + "IPY_MODEL_eeb121cc12e54d4bb270c70a312e3c56", + "IPY_MODEL_1f752fc10f104cdbbe5bc2d5468cd124" + ], + "layout": "IPY_MODEL_15890efcfa6f4152aaa38b0cc7d0955e" + } + }, + "9f0c36ac258843c6be0ff57efc4cf103": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9f109ff1b251429c9923d46482b8d196": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f123d6141ad49ccb38f43cd7bb3b6ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9f1e2a3d4b3e498c9a6ecf69bf36b79b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_999d2873de7640c9938b6cf5b876284b", + "placeholder": "​", + "style": "IPY_MODEL_7d3ce71b88af4d0884574117e6917505", + "value": " 140k/140k [00:00<00:00, 578kB/s]" + } + }, + "9f22b25c1d8040438f68cb2bc253fd31": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f4ac4d5c31e475e93617107e203e2db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_db9b8cd8801d46858090ec288be02c7e", + "placeholder": "​", + "style": "IPY_MODEL_f74938a026b7449aa10ce2a84a8efe4f", + "value": " 848/848 [00:00<00:00, 4.22kB/s]" + } + }, + "9f4d6179b4f1487c9a85c9486cfd5745": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9496500e7e1b4e66b830707566c474c2", + "placeholder": "​", + "style": "IPY_MODEL_1c6a3c9c81f84623a64b82b412993f6a", + "value": " 2.39k/2.39k [00:00<00:00, 9.58kB/s]" + } + }, + "9f503e87bed04eb287322b70be8e0d77": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f552994802841e182eafd893a2e66a4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f60808158b04da5a52f67d7a4fb929c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f6711a2bc384acbbf9740b1f4cbf02e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d10106ef402045efab7c530edaea65cb", + "max": 143843, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d9820a20e140401bb2d0e07b80ca2518", + "value": 143843 + } + }, + "9f6abe2413d1474e94cb52bb9eabea90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9f7a19dd067a4484844fe79fed7dba3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9f9d2050df8a4c71bdc4c99a82e4ab7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_df8db1b8aecc4a58b1851d3061177979", + "placeholder": "​", + "style": "IPY_MODEL_8aa3fabd2cd7420dbbc259dabfa0fed1", + "value": " 992/992 [00:00<00:00, 7.48kB/s]" + } + }, + "9fb818db3a1647a893e70d948bb75b2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9fbc0601b17e41fd9245abcc184413ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1150292ed1c44625b488009ed067757f", + "IPY_MODEL_ba6b3ed9497d42b993b9a350f82e6583", + "IPY_MODEL_5656d2414d7e45fc9faee24f93e7e29f" + ], + "layout": "IPY_MODEL_ea0c6dde625e4d01bfff2a469f4d98a7" + } + }, + "9fbe5cd1b1ca4d1b8b541e03b52cd4f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9fc0489c289b456bb2642ca1f18947b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4e5f958134b14d1482d6b8ef207d597e", + "IPY_MODEL_114febdcf73243419cae836aff9fdf44", + "IPY_MODEL_306f884b5abc4b188102dff436a3668b" + ], + "layout": "IPY_MODEL_658530837bfc475194c424d442b93826" + } + }, + "9fc1d5aed96648dfbf819a15c3241163": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9fc21c801323478f8ca9abb4e4b53702": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f10086878337467290ec583e0096e502", + "placeholder": "​", + "style": "IPY_MODEL_790d48212bf24d33a50f05f77dd317f6", + "value": " 2.21k/2.21k [00:00<00:00, 6.76kB/s]" + } + }, + "9fcd05de012b4384a70ac4948b7860a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d85a4056b76e4798b79d29e7c6ff4a7b", + "placeholder": "​", + "style": "IPY_MODEL_ffbc9c4192f84b8683b343c942b14539", + "value": " 2.21k/2.21k [00:00<00:00, 7.19kB/s]" + } + }, + "9fd485d535724588b11a16a9121c9652": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_611ac37a2c4e47d5904d9011277c8b7b", + "placeholder": "​", + "style": "IPY_MODEL_9f7a19dd067a4484844fe79fed7dba3c", + "value": " 2.20k/2.20k [00:00<00:00, 10.4kB/s]" + } + }, + "9fd8f783faf04946a7aaf94263787467": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ffcfbe2dd2146e5860d7c4c35883845": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a002ca2f07aa47a6aef7f377e5fe8096": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a0065523160949119a44ffa228d4f4c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a01b623af50e4043b8adac80e083766a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a01f48d3193e4b2ba415b3436dce50bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a023c00b95f840ddb725a34ca65ed743": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a02d99b181ef49bda8d7951e6d5ec676": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3b725cc2dbb648c59ab6d43723d7d72a", + "IPY_MODEL_29adad2c196f45d79ce2a32274886abb", + "IPY_MODEL_a8eebabc6fda4dc182735236af32bcee" + ], + "layout": "IPY_MODEL_43dce7e30883469ab36a89e871e2a141" + } + }, + "a02e533683a340d6a10dc3f6052d3253": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a030cda4f47d490aa897d36cbbd3f0fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ae223a39678749acaacb2416c29edf41", + "IPY_MODEL_1ba9f609cea24bb49ae3cd94bf21cbc4", + "IPY_MODEL_de6825a69c8148fe9f0e596ad3facd50" + ], + "layout": "IPY_MODEL_70c5dea767024da2934dfc11db647bce" + } + }, + "a0394f1b136f4fc1ba214b3192c3cf4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7e855de7626040d6b9282729c89aafba", + "IPY_MODEL_fcc61b5b8895406083ea0f771522dab2", + "IPY_MODEL_32e63d065fe242ab84dffb2b091cebc6" + ], + "layout": "IPY_MODEL_810e9c19eecc494785e5eca3deb85080" + } + }, + "a04696080efa4d559d979850e0df0099": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "danger", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ae909db76bf4b328231c0204b6c75a0", + "max": 2111, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7c7143100cd54ac9b8424b519bca48c4", + "value": 1950 + } + }, + "a04af0528d04465eaa428df66a624431": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0610584681b4044a8b79a1472030721": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a069e702c2514588b1ed726912c146a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a07280451b2c46d09cfa9dbe15f8a37c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a08a9c1b38b84eb2a9e7ffe034c90a59": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a09b2e57e4ed4d40a3b88e551309d084": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a09b706f3e934d8a92a5be02dd23fd34": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0ba43a1590d4a49ac45eb7d3ceccda7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0c73459d8ce4b8d935624d3f87b46c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0c7b24983ce4e7f82bfa941fe5a0de5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0c952f15010430391ab974b834065d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e172549f373643bd805835363b7a0201", + "placeholder": "​", + "style": "IPY_MODEL_5f0839571a4045e2b7a456b6c7964c9a", + "value": " 1.24k/1.24k [00:00<00:00, 5.22kB/s]" + } + }, + "a0d21c0ed3b54eb1a9534d37b9c28e70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_96d39f5db56948fdba83ab3a09128b74", + "placeholder": "​", + "style": "IPY_MODEL_b87d690339d4426e9daeaa8cbd86d67d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a0e0b2a442ae454da39aadf9d84521cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0e59987bff248488f93700727a302fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6a5ce40024ec44b1aa513f4c6189a875", + "IPY_MODEL_b12ca0af16c1427cae2888a1ed0a2897", + "IPY_MODEL_9c348660fa8a4c2d9475f95cacd5e7ed" + ], + "layout": "IPY_MODEL_cb909adcf50b444c92900ad1c9287a87" + } + }, + "a0f21a549b2b4ccd8e0e9cce98f23129": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a104820fa8c34948b1c7048704395e69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4c7665f48580445d9bb8a6704a7bfbf0", + "placeholder": "​", + "style": "IPY_MODEL_773c8544c7464f89a3cb17576f359a09", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a108943217cb462e8c1391aae80e36de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6fcd7ea2633c44caafa1e45b540445a9", + "placeholder": "​", + "style": "IPY_MODEL_d65f89e55c0948109bf37335f499cc80", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a10b810a0a88447e9c75ec0fd6d6efee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a10d3852d2e24cb0b6e49e3778c778fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a10f7238878e4def920217070b5b5393": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a12d850a64a746b585400c29c5911364": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b78114f88854d40901d056f4c0a06be", + "placeholder": "​", + "style": "IPY_MODEL_49ce9a5421f3401da7e32730e87bdb34", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a131026f28854ddca8951192787cd616": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a14d1d78616748be8655778d83680eda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a150a36895e74e898a95c7c8357643db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a154e172cddf44c6b91bb098805f6fe7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a188ed817037446c9c321995ee51227d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c4edb71133f144e9ba8c0c8e1ddc6eee", + "IPY_MODEL_6fd21205cf1c406a9c248ac9492b6797", + "IPY_MODEL_7e88b74351354c51b4a96b214d12278d" + ], + "layout": "IPY_MODEL_3f36246ab24e480288bcee274e655ce4" + } + }, + "a18f51de5b444c64992e4f0e2bb3d48f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a193534b01c94c2b94823af00df4e5eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_63a3c3ce10c54eca97e2d210261d262b", + "placeholder": "​", + "style": "IPY_MODEL_f19699814d12423a8045111db6a055f6", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a19ba3b4da9f43c28929dfd34d57a348": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e5df13b05641409ba61803834bae581e", + "placeholder": "​", + "style": "IPY_MODEL_4183e75facff44aca6be5c79d0007c75", + "value": " 2.95k/2.95k [00:00<00:00, 12.7kB/s]" + } + }, + "a1a31f3998f04083862b188f37fc0804": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a1b34d5665ec4616bd32d387d26f4e95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_81e82920e468407eb68ca2eaf6a836ad", + "IPY_MODEL_fb26bb5b07a84b34b557a97ae4411b50", + "IPY_MODEL_fb8325df7ca848eea0865c088e8bc80a" + ], + "layout": "IPY_MODEL_efaa5a5449814220ac8506f942c5657e" + } + }, + "a1b7c1fa4ee2409eb018358e0ce3403b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a1ba962317bc4339977ead5cd1c0b878": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a1d534aed79648adb219f8dede0a5afd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a1dd76cc36d545088586749d13143a29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_df7add63d9bf48f9a0e76db054e82125", + "max": 2015, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a4022cd1798c4059945a4ff0107b4d75", + "value": 2015 + } + }, + "a1e57815e4db4e978df848a7d0114690": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a1e7edcfe50c419fac7db6a7e34e0739": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a22af8852cb449f682a4590737b86c4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a22c4ef0796a4c00a064e3f69cb8781a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7772763a98dd45beb1aee9eb265ad5cf", + "max": 1811, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b0c14b49b07f445a9ffd2b2987cd1b0e", + "value": 1811 + } + }, + "a23ef693631d4391b30bc702794e3341": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a246b909fc0c4d4b823229dec7efa4ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a277a0fcea0f4788a4910237d71c8ac8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a27891c4f6f94ad5a1b4a4f2f1f53786": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb9a9059e0724caf9bb16c46fb7b7410", + "max": 2119, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6917dcb42410492fb2c52d3530c04c7a", + "value": 2119 + } + }, + "a27cc97137db419eb8bbb9dfc5ddb4b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a29469a4b1a54828870846bbc67109c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a29b7e1a2f794805acc7bf90e6196ef2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5c8db7f280c34b74bb0d53b6c5292902", + "placeholder": "​", + "style": "IPY_MODEL_8f334e03af9d4ef18b797590cd1d2f7f", + "value": " 1.29k/1.29k [00:00<00:00, 5.34kB/s]" + } + }, + "a2a62b75ed5a4d8f9f64cb0b3c722330": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a2a9460bc8ce4550aa7fdb50150b4176": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2b7d8a0d0f334394826d1324dd86e83f", + "max": 2888, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0edea77ff5534d8e9bfcac42849de83a", + "value": 2888 + } + }, + "a2b7d8c60c574500a2eeb68dd0a71a16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a25400b974c414ea0576ac347084717", + "max": 2817, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c623acf4c31a43b999a097c6c9ae25b8", + "value": 2817 + } + }, + "a2cfcc6b864c4a4bb2a2b3247749bb3b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a2d87c52c95d475b92d9c292f3878509": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a2f1bfc43fcf409d9b902002b7161e2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_891c79c3a2b947efa2ecf0dfd7b38858", + "placeholder": "​", + "style": "IPY_MODEL_7b19664b1fd84bff82c38f3baae208bd", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a30c032c5ef7405bb62b9e77812aaf4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d6f53b2b7a884e9e99aa12878fb758f2", + "placeholder": "​", + "style": "IPY_MODEL_7729bc4a6aa14796947be4b0ecbe761b", + "value": " 2.93k/2.93k [00:00<00:00, 18.4kB/s]" + } + }, + "a30c0dacab1742bdaedfcec9525a8756": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f2a11d00ffe741898541a53c6380d7d6", + "placeholder": "​", + "style": "IPY_MODEL_707345904e55482b819c9e14b477c5b6", + "value": " 2.33k/2.33k [00:00<00:00, 14.2kB/s]" + } + }, + "a314a5ea984548d38b70e46ef4180430": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a317a3dec94944f08050518d31f07858": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e266d36c68f44d78bf07706c70dc3267", + "placeholder": "​", + "style": "IPY_MODEL_68ebb2d7311545008fe8a4cc94f013f1", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a31a1bbf62224356b73736a936470b61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a32932d55c3a4c23bd69669f49d0bf67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ee98abecc284970852f3d6b47005866", + "max": 1606, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8e36a3a3d97042bd884c7a2fbd0d2973", + "value": 1606 + } + }, + "a33024c999394aaeaa9606297e74fbdb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a35200aba23b4c67be7f477121866cd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ef032d76083e4feb85bdf35c8da65dfb", + "placeholder": "​", + "style": "IPY_MODEL_410ff15285d2458cbe90401cceabb300", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "a362d70bfc0542eeaa68040c0dbff233": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_62859520abef44129f78333b9a7997e3", + "placeholder": "​", + "style": "IPY_MODEL_3905af4eb0cf49fa8fc3c392ea2574e6", + "value": " 2.90k/2.90k [00:00<00:00, 15.7kB/s]" + } + }, + "a3853bdaebd5464e85e242b9b6b5ccf6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_39fd8512ed4142aeaa89efab81aa7454", + "placeholder": "​", + "style": "IPY_MODEL_8b8af13b8bd74d2fb7f94d548ae5db10", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "a391903778f14836b8587e5a1266b06f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a39dc2a873a840b182d2e7bea6cd23b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a39f9da3cdef42c690227fcb42334c7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_217208f6d4664e6ca769a7f3fc0fb92b", + "max": 1578, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_429b58ededa74c1bb1496c931df5eb96", + "value": 1578 + } + }, + "a3a921fa53be42b3a77cb7755a39350e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a3aefbd9a35c40dd9fa4abd7277d3713": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_30a94d2fde1f422caddc3e9d5beed999", + "placeholder": "​", + "style": "IPY_MODEL_4055f6736f2a47458667b650315f1046", + "value": " 144k/144k [00:00<00:00, 500kB/s]" + } + }, + "a3b6c1f05d8344228675a0f1352ef6db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a3fac1bc03f74425b8a7d322d7fe7ba0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4022cd1798c4059945a4ff0107b4d75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a403358c784c4ba2927ef44cf2ce15f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c792603372e841f590ef1e34f7b96f6f", + "IPY_MODEL_40153ee8435c4914b4bf840c54be19e5", + "IPY_MODEL_c10acb94d63e43a6911089ff3a8fa5ad" + ], + "layout": "IPY_MODEL_5e065dcb17ea4a4eb700824b79413005" + } + }, + "a4073c2f1fad4c4d89c16d411a96af6f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4242d64ed78443eb0f33279e0af25a5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a43213e1ddfc474ca66a773f5b9e2d11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7919864fec9746989e6f68de634cc1bf", + "IPY_MODEL_72685e4c6b724207bfa1344ac2684d52", + "IPY_MODEL_2d317ea33f824e04900d83e14046013c" + ], + "layout": "IPY_MODEL_2cfafa28af5b48809205e3921807e503" + } + }, + "a444895d47384745a8849213a2b86340": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a44594f22b004a899466afb32e7e2304": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f0564fa9e5a141da9f96b09f917ce9da", + "placeholder": "​", + "style": "IPY_MODEL_3e4be5ca63b5489998484831221d953f", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "a46b4a0c2ebd4160a469c11053509add": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a48e42a747d243d380645e58d1e7b363": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a48ea74c75704b9bb8276bb6f47ef2bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a49321ea44574436a263208736b52a11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a4a81a2217804299ac070713c40c73c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8b7652077eee4cba8a63127b8765f5e0", + "IPY_MODEL_d363108cbdb54ecf89eb39296f4321db", + "IPY_MODEL_132f3b17199f4a8a8c320fdff7873429" + ], + "layout": "IPY_MODEL_f809db31fefb4b328202f3e39013661a" + } + }, + "a4ab34c4ebb044859dc45be5842644c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a4adcf5709f84d10beda973794af0d6d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4b0f70059f04e2280215894d40bb895": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4b55b325ee24c75aea7384f9df449a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_50af639a4d214633acfbe4170c230a6d", + "max": 143019, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_809adf67a5b14e74a4fd933b5fb5c70e", + "value": 143019 + } + }, + "a4b74a6ca8d74fc492bec7e0a6ab84dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a4c988781b374782b0227a11b3c3f0bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4064a66d77274bedb1e16605f5bc3ec8", + "IPY_MODEL_2bc5245adcd24811b1811d4cf1837b28", + "IPY_MODEL_63ed5544a18d4113a0a5876e3ea0e7a7" + ], + "layout": "IPY_MODEL_6333b21ae8db4c78ace3199494f9cf71" + } + }, + "a4dbc3b303524757b3a2032dbabc374e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_022e8c080ae44707a8d1c861c563f26d", + "placeholder": "​", + "style": "IPY_MODEL_21fe88256687479f8f844383549d0f6c", + "value": " 1.49k/1.49k [00:00<00:00, 11.6kB/s]" + } + }, + "a4dc1cc1e4624ce2a9c641bfb7b0c9a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6fa6d721d66e4ee992b083165bef328a", + "placeholder": "​", + "style": "IPY_MODEL_4ddf74abf2c248068dee1d590fe215bd", + "value": " 1.58k/1.58k [00:00<00:00, 6.59kB/s]" + } + }, + "a4ecece8c4f741d3a775974952e424ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4f27eb7dd9a466ba522c2c75953922f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a501714d63a347c0acc9982bf04bd253": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a5081b80f0b24ef5ace2d992b175480b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f367ad27b8c54a0bbf4297167067ce03", + "placeholder": "​", + "style": "IPY_MODEL_aebdd27f1c014f97991e64f74100674c", + "value": " 1.44k/1.44k [00:00<00:00, 7.40kB/s]" + } + }, + "a5117978191f4af39346b7fa23bf0134": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a525657046134754ad65178125b33f86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a5442f1d91404aa8a1c5729959b1b78a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a554cf9380734e4cb1c8f9e98876f415": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a5956154ff91463cbde07384c7e43058": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e1b30d5a27d24252a9f2658225f15739", + "placeholder": "​", + "style": "IPY_MODEL_0f0310b0cc084950a043d8d9a8cc7a99", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a5b216dc00c34a8caa870311854ecebd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_09ab463826e8483a9bcc948551874cab", + "max": 1082, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_46e8c40c09d641bcb2b5923775f8eacb", + "value": 1082 + } + }, + "a5bac5639f4e48878a0527dbf60d0dba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a5bc081e479d4933a2e0c3f8b31095fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7faa17fcd1f044f383a82e155ed81ae0", + "placeholder": "​", + "style": "IPY_MODEL_204f11e188804c84b60591c68de8f11e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a5bec0a6037f49fd88e47c41ebda5d27": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a5bf39bf570742ebb1c8bbd09280310a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a5ca5b4fc262465d90574a0e4be5ecc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8bf9cb6e7e6b4135a752a89b3f3f48bb", + "max": 1431, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b79cc38d3e7a4df4bf08fbb0577f7a85", + "value": 1431 + } + }, + "a5d71addae8544d28b1cc3a5f970ddca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c5551cd49aa3480aa484602224f12203", + "IPY_MODEL_e6f9ad8fe8de40e7a85a1a6268cd6e47", + "IPY_MODEL_a95a8339ad0d4452afd1a5c173a5f105" + ], + "layout": "IPY_MODEL_d962a37947d24e6b970e79fa89ed05df" + } + }, + "a5de7082158c44828a00139b44330275": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a5ec501d3d714fc5868c7657b7a12eff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a5f677b06f7e4681a34fe65e7c2113ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a5f696dcc26e4d749f7fa2462d03bb5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a603775752b14c9b813016b37cd30aae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a6108588b46549a5a9a0c6277c880159": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a61cf64bd5534b9cbd345c335b0f89bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3617e2497f04433ba523a3712f70d6d1", + "IPY_MODEL_6b91f33045d44c45ad2b39cf2ef6c065", + "IPY_MODEL_5ff29e09c8944f44af5156960049d2bc" + ], + "layout": "IPY_MODEL_2586561289e94ae1b87882f4e2f6fb11" + } + }, + "a62f11e173bb4139892844e679b9d6d0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a63c02441e054cbb81ba3731d74089e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9d7880e901a7475aaf05516f6034ed6b", + "max": 2212, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a525657046134754ad65178125b33f86", + "value": 2212 + } + }, + "a643d065d6d24737b18d95dd01136844": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2e86b2bc2538477f9d26628a74e8f2d8", + "placeholder": "​", + "style": "IPY_MODEL_9fc1d5aed96648dfbf819a15c3241163", + "value": " 2.66k/2.66k [00:00<00:00, 15.0kB/s]" + } + }, + "a653d5f9da5b4908959e54cdb4eb2b27": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a6742cfa201d415fa808e01f2d85d9b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a67a602b89314ea5b7dbba1696f4d6f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a67e565bfebc45a28a0921b6cd576996": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_711a038bdaed47449823cc0efb7f7c11", + "IPY_MODEL_fe9579f8518449b2956936662a96b0b8", + "IPY_MODEL_33b66c93090149d1bdd0ce822790c9d2" + ], + "layout": "IPY_MODEL_b316dabebf20413e8d6f8ce0a41f7956" + } + }, + "a687dde664ec46d8a07e93b2d0bf54b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a69b64b1fca645418573f260eff46ac8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4097821a196144e2bf11b156c0cfe10b", + "IPY_MODEL_3222b784a177433a9381e4ef6076e1e7", + "IPY_MODEL_1444416034bc4dfc96ba544e3f78289d" + ], + "layout": "IPY_MODEL_0be218cc22f24797a903f6513f3515fe" + } + }, + "a69c29227c5f4f9b922a8ed902f00f47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a69ceaa33cf54c2c848c3db7ff58a224": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_193a614f1f67400e873422ff4ff963af", + "IPY_MODEL_6c9efeec4d334be6b4208b6f0110b1b6", + "IPY_MODEL_2c816d19262b4357ab9c48a42395c0d3" + ], + "layout": "IPY_MODEL_dc79398e802041d0bb94e1861145a9de" + } + }, + "a6a617c60ab24813b3c81ff5c614400a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c8597f4c79e44ba0aa2bc52679e479f5", + "max": 151657, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f64f58280fd946b38ff184d023cff0fe", + "value": 151657 + } + }, + "a6b0f67ab8fe452fa928f7c9f8cd386d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6bc6b3722d8846c0a0f60004c4715bd6", + "max": 3616, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_737202af86744c2fb223d0c4b34febd3", + "value": 3616 + } + }, + "a6b6f0bef64543b68d54ee2d2f4509e0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a6d41fdd0b1a47bf93599198f7c8675c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e20ad481fe614e738073871b4a615573", + "IPY_MODEL_e9a7f27086234fa0baf8ce3e7847122b", + "IPY_MODEL_00da453262364c31a59934f3a4881b34" + ], + "layout": "IPY_MODEL_b3d63164180d4c05a91ba70d6245fc33" + } + }, + "a6d954eec50b42b09530f5b020c6e9ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a6fa8c20b5cd47449e10cf0d88a9ad33": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a71b6719da294972b3939d1efa445a77": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a71cb92c117641cf999bf31c92be0fc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a732c0248d2843939b26637e5c385a94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0c7e75e018784c2d9c5da1e6ee12397c", + "placeholder": "​", + "style": "IPY_MODEL_efc95c5cbfc44eeebc9736da96640452", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a74e23b80a4b44b8887698a01a9825a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a7567e4297db46cd94b48d00dee47203": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a758a8738a104a8c9034e3b6a11a85b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ce52228411864d4cb04087770e4da493", + "placeholder": "​", + "style": "IPY_MODEL_c337dfd0bb00424e82eb89add2724275", + "value": " 1.22k/1.22k [00:00<00:00, 6.02kB/s]" + } + }, + "a75cb1957edd4f0c9f2c215cdbd273a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9992c49c8cf6461a98028aa9c2ec98ec", + "IPY_MODEL_73e5f61865074e8581d48098e8893974", + "IPY_MODEL_2796be89dc2644ae951336383bd7375c" + ], + "layout": "IPY_MODEL_cd93205d72674fa39c85b18eadac6816" + } + }, + "a7738e88c32b4c7b9fcee89ecb678990": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2c1f1510193b42c0aa2fe4a9534d81da", + "placeholder": "​", + "style": "IPY_MODEL_b6224f7774d04639b1c9ea5dcff42ce3", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "a775a68c52e64b45bbd9bc3d8e8f2a43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f49c6bddf9944330aa511b38fae96321", + "placeholder": "​", + "style": "IPY_MODEL_8986aa30c6fb4b02a77cfff95213cee2", + "value": " 161k/161k [00:00<00:00, 936kB/s]" + } + }, + "a776961052dd42cf9aa41b4109d0e46d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_48c36bbaaf084ade8d5de85d2ad4e38e", + "placeholder": "​", + "style": "IPY_MODEL_75997d4ff5af4d1caf9af6112e9e9d7e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a776dc42836a4f6894f89236d1dc8889": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a79555ae1d2a40ae8cc401c520aadd82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_62a1d6966c704db88256d8888c182e82", + "placeholder": "​", + "style": "IPY_MODEL_e5a6d761b2d74731899a716c1bef22c3", + "value": " 3.04k/3.04k [00:00<00:00, 15.6kB/s]" + } + }, + "a7beba8c3c424862b0ad7b3303d46419": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a7deaaea89af44a3b702a5ee241bed2f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a7e129911ec9437db9a9cc872ee34638": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_94e764a64b714c29aa16c693528dc16b", + "placeholder": "​", + "style": "IPY_MODEL_bfc7f908013148c6a85ff2c88fe0482d", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "a7fe172450f345ba92fb553662636bb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_392a59640f174f03a63276ff53628b3e", + "placeholder": "​", + "style": "IPY_MODEL_3396553af5314d76a23081b011211368", + "value": " 2.38k/2.38k [00:00<00:00, 8.66kB/s]" + } + }, + "a801ae7345b84c10b1c3ee9778f44376": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ef96f74ebf9f4f3ebfc80f450f6bb6f3", + "IPY_MODEL_06aca855e58f4047929d5c0264757ca3", + "IPY_MODEL_45b6c365018346daac253245abd6c306" + ], + "layout": "IPY_MODEL_842eb9c770864bd59a456afaab841365" + } + }, + "a80bfa74ebf14d78a4442c40c4bcae87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ea9b71c45b664bec96857265e32e9f76", + "max": 2858, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d117778017cf49ca959c91daca677c84", + "value": 2858 + } + }, + "a80efaf7b6c644159d80c65a0539a2ac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a810fb65d4d5421988b5a3d1c7a68a4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a8183f0c0cb54148a12ad28e82d0b3ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a1e57815e4db4e978df848a7d0114690", + "placeholder": "​", + "style": "IPY_MODEL_fd51777d567d443d9ddfba8ab4fda33e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a83b4ca57b54497da0a49a0e7e707b3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb5376bad63c429fa24961a5c585e8fe", + "max": 2015, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4e22dfe4811c42969ec4cf188dfdcbb8", + "value": 2015 + } + }, + "a8677b7b05094a52998b85c6ccb70e75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3411f48b35124e35a0fdb043fed644ce", + "IPY_MODEL_d05f88809b824d43813a6ca695043035", + "IPY_MODEL_b19a92ab84874e6d912fc1e88f7518f5" + ], + "layout": "IPY_MODEL_99415b66463d4b1281234edba0b1c580" + } + }, + "a87455e7f40e4b9ea51e7c3e0f61e411": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a87c971e1dd04054a56cdc1d67d2ba31": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a87d6689bd22494e850c3269d29e3a11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a8846ad7450e4d47b066f5edc49105f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a8ab7cd536ce4a5ead62b59e69bb5945": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_03bd002936fd4d9cb2964f0583dc9eff", + "placeholder": "​", + "style": "IPY_MODEL_b55a769c116b467789ac73f1666a531c", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "a8b644c28dd9451d93a2347e27509778": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_98f760db493c4cb286cdfad937d0ab0f", + "max": 2081, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9899e34882cb427b82dd4d561e7b4704", + "value": 2081 + } + }, + "a8bbd0940230432e9e219b79fb7396de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a8eebabc6fda4dc182735236af32bcee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_01e06310165f45428b5f62bd6c6a8498", + "placeholder": "​", + "style": "IPY_MODEL_ce06dde519414a5f87a6fc0f9e4f6ba1", + "value": " 891/891 [00:00<00:00, 4.44kB/s]" + } + }, + "a9004b75d9e84a6bba3a3a7705111167": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a90fbf9b912746f5a5b355ca1b1e3df7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a916d81e9245418aafc27f5e2eba13f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f79fce8c195142459a01a514b7b36181", + "placeholder": "​", + "style": "IPY_MODEL_f3aa03b83cac489fb8d7461be0bf3059", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a9181a8931ec477db9e2146341683d27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_29fac2f593f9455da71d90deeee71e36", + "IPY_MODEL_abc64e5b18894017b68fc059b5eb3697", + "IPY_MODEL_81a14bebf04047368e0cea8ac6763b32" + ], + "layout": "IPY_MODEL_c37a1636e6ee4de9b988110c589d7487" + } + }, + "a95a8339ad0d4452afd1a5c173a5f105": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a3b6c1f05d8344228675a0f1352ef6db", + "placeholder": "​", + "style": "IPY_MODEL_effc25e66a68445c9698129ae4ba20c4", + "value": " 2.09k/2.09k [00:00<00:00, 6.81kB/s]" + } + }, + "a9748915e7c648d39c3a469b794c6c13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a987b7a84a9c4ff892682a3f81a6efe4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a98e8ba84b5b4eefa73d9d1a4e9c7569": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a9a24be9ad154cdcb850fdbd169b3313": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1205bcac7db14f589d0f0f84f431d57f", + "placeholder": "​", + "style": "IPY_MODEL_52bf5f06e48648119d3f3dc3cced364e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "a9ab9c4605234896a90075edc0d1a3ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6da674a88a45457ca17b9108d2bf26c9", + "max": 2660, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_aa7154dc089843c19c4c0a51dc1df6fe", + "value": 2660 + } + }, + "a9b78dd6ef774da6b23d6e7811252db1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a9b88ca5b4de4ea49671eb941bc22aab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0e7d05e5d3f4440a6dd11154b4d4365", + "max": 1181, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_340f2d7564764d05a3187a42595701bb", + "value": 1181 + } + }, + "a9cb52e8d04a4238a6fdd59790b430aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_62a69120910e44c689ae5b32810db9eb", + "max": 1988, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_81444a1f49ee4c51aa1f86ebe9966cec", + "value": 1988 + } + }, + "a9e1f367292444edb7f6401cc1545bd5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9bfc0ad157b44512b476e8da371f4d4a", + "placeholder": "​", + "style": "IPY_MODEL_18b60689bdb84dc2aea50492d923d644", + "value": " 1.48k/1.48k [00:00<00:00, 6.27kB/s]" + } + }, + "a9f5ec07534241c381293e61189d5948": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a9fb6a3335ab4824b67d4f93d80c0164": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a9fc89b6d8e6465e9242964c09fa2afc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6751da2b1d4c4a99aff1f836409fc992", + "placeholder": "​", + "style": "IPY_MODEL_02c711c28a0b4d379731bb0216da3e2e", + "value": " 1.91k/1.91k [00:00<00:00, 10.1kB/s]" + } + }, + "a9fdcf658a3549269ece0fc56cd0113b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa0dbdf05aab437691a6eac118056bb6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "aa0fe32d79c949a1921d87f10295d130": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_902b127f72414d18a274bfb19f2a960c", + "IPY_MODEL_adf6dedd63184d018a3bec259f8621f6", + "IPY_MODEL_c6a0f0de1bf841c8884c393e6b06304e" + ], + "layout": "IPY_MODEL_fa187ea099624c1c896fd80e567ca41a" + } + }, + "aa132a34dda3426381652c40f12d9b30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0733bffe9df84cd2874ed56b5e95f00c", + "max": 1855, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6595902981044e18b324538f7d4fac39", + "value": 1855 + } + }, + "aa1d3fbd3ecd4baa96eb9f3a2ee115fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_05a8aae579e94d60b35928d5285ce5ce", + "placeholder": "​", + "style": "IPY_MODEL_0e5bcf035b224643b237ba34f243e065", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "aa395aa30e8b4e578490f1f0b2892bc0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa415c2663114618852bac94947dfce3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "aa44e35e8a8e4da881871ad03ecea5da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa4960a793b04189a258d45791fa63ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aa4fc088d39b4637b2dde476c923c292": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "aa521c976ae644c3a70ee4472709c9f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9a4adbb90790415baea4d366ac9f964c", + "max": 2200, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3b5b2674edf643858b1bcba5d5d5d9b3", + "value": 2200 + } + }, + "aa64366f87f946549b261e13af9bda5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa688f04ad0f471faf20f396f34b91c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa6f390818c44dd7b6c022dbfb969d03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aa70a29511e84ddd89b7b2e164ae8ad1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_606e28e1ecfe40e1a04bfcae2da41b8c", + "max": 2991, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f970356e24e14166868225ab53c15565", + "value": 2991 + } + }, + "aa7154dc089843c19c4c0a51dc1df6fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "aa8c2e7ee3544f3aaec33492876aaecb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa990dedca7948cda6517f293fe8251d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a95b31652c44d9d8674970cdc40144b", + "placeholder": "​", + "style": "IPY_MODEL_da865f2bced843358ce5d939228a7638", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "aaafa314fb264461bc58badc3036ff96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b5bf18e866446c6a3c9cab8dfcecdd7", + "max": 1294, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bb7dff7f83b64320814070b605566ff3", + "value": 1294 + } + }, + "aab87333150b4a13b4f4976120892b32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2de1a01f1593448baa036c0038da29e8", + "placeholder": "​", + "style": "IPY_MODEL_adda0c1704a64fd9ae3b91c6c6d4b0d6", + "value": " 2.03k/2.03k [00:00<00:00, 12.9kB/s]" + } + }, + "aaccdb222aad480ea4b53964834488b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aad8f7177c1843cea7523ad625d877fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_be0e73d8f29f4f04b1c1dad81b9e9d49", + "max": 3690, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9b8950df54de4f68a822f5e07af599d7", + "value": 3690 + } + }, + "aadff50db6924beeb69a78f22b97ecf6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aaedb86c61474006b29f63da71aabc2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ab0c72a25a084858bce1ae706363f1b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ab19de3630364e31aceae317ae1e9186": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ab239916f45046c68ebf3d4793a53fb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fec6e620898e4e77b27970bdb99fa1f6", + "placeholder": "​", + "style": "IPY_MODEL_74ab3be8e85e436a9626b53fb6f70198", + "value": " 3.06k/3.06k [00:00<00:00, 13.2kB/s]" + } + }, + "ab24fb8c0e264df08b98fb8bf194f519": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ab35ef5c44924386aff1569cb6af0b43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b5a267a5a0e045429d33d14d6f3f9e6e", + "placeholder": "​", + "style": "IPY_MODEL_511f85103c6943ddba7fa1be539129e7", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ab5b65f87996409b88467b9484e14c82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ab66085d37244be98451e64d5c6901c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ab69e778e40e45f2a0cc9ec05607e775": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ab6ce7d3577c4541903b165bc8092f8e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ab70756fd63e4f87a5c945d24fa89c96": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ab73d9a322824f27804616e239a44a11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ab76df5b65164a41b1d4557f96256969": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ab94c8bcdd0c456cb46846d9551ad130": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_edecbf56a6894732bb87d2b8f38d1261", + "IPY_MODEL_a9ab9c4605234896a90075edc0d1a3ec", + "IPY_MODEL_a643d065d6d24737b18d95dd01136844" + ], + "layout": "IPY_MODEL_6ab0cc871a6b49bebcf06505e25ee4c9" + } + }, + "abbc041f4d84458a9e045f70918c7cc6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "abc64e5b18894017b68fc059b5eb3697": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4cb0d861f56540a8904928b24e58e458", + "max": 1249, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6121dbccad4a428f92642ec6e65d23a5", + "value": 1249 + } + }, + "abcbe03edf174a8fbbd2bf49f6042d64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_43e4a79009a54ea3ae7ed50b61b4cbbc", + "IPY_MODEL_aad8f7177c1843cea7523ad625d877fa", + "IPY_MODEL_e98db5016d8d4cb99ddf18aff34c4275" + ], + "layout": "IPY_MODEL_db992127901b4babad5a6375c9246848" + } + }, + "abd6f09928ab48dc8478a698097e546a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "abe31dbaed344cdfb8c7ff3ea5d83e73": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "abf2b07cc6974215ac4194d69ec29f73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4a2f6a8c3b2427eb80b4079db2ca6b5", + "placeholder": "​", + "style": "IPY_MODEL_b2638be7860c418caea5457cd2a92fb5", + "value": " 1.26k/1.26k [00:00<00:00, 8.61kB/s]" + } + }, + "abf4bbd79b354a25a83f3298309bae0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "abf547dd8692420bb1d0cd7971fe1eb0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "abf93bd5bfc74248b0f047508caf0168": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d93d99063c6041668d595c0220c744a9", + "IPY_MODEL_50d50ff1442c4909a4ca77a875645165", + "IPY_MODEL_53e63e7f08f445cb8867e921b8ab70c5" + ], + "layout": "IPY_MODEL_fc8bd7212e0d43c08501f82b6d6d8a97" + } + }, + "abfa99231655401196439a83b0baead2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fe3a2f68cc404f3dab8ba7184ecd88aa", + "placeholder": "​", + "style": "IPY_MODEL_fdc53a5b87a849dda263479d3e3524c9", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ac0e0e04571c4fcbbf10e8088fca9040": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ac2820685566401ba284d8c2a8dcebda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac296a5ced2a45f9ab59fdfd8ec9a269": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ac2cb95dbde046aa9d43db7b59c464b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee242d8b6bbc462eb394c3bfc63e4132", + "placeholder": "​", + "style": "IPY_MODEL_13b276d614724ba185ab0bb24cafdfaa", + "value": " 1.80k/1.80k [00:00<00:00, 4.86kB/s]" + } + }, + "ac41e48101964256a68dfdf425d7216b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac4fba3d3f7843bfabd35b89a357bc07": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac6f73270ee4455eb1a985b8bca7bdf6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e954fbef94b742e697c9abdddf2cb715", + "placeholder": "​", + "style": "IPY_MODEL_98fdca05001448cdb29ef109296ab240", + "value": " 1.60k/1.60k [00:00<00:00, 9.25kB/s]" + } + }, + "ac7d94c619b04d77a2829fde422a472e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac879089086e42c4b4ffe8a012d6d5af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_64785d85833b4fe5b396af98ff8f09a3", + "max": 2418, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b704d5f212454dc190ad4722de2e9cd1", + "value": 2418 + } + }, + "aca46ad42c2443ac919ca23e81be953e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b936b4b7079f4d0ba13845986dffc3e9", + "IPY_MODEL_a9b88ca5b4de4ea49671eb941bc22aab", + "IPY_MODEL_c52bc0da45614bedae4c3dd210cdba6f" + ], + "layout": "IPY_MODEL_bb9904ff95b448b4bad7bfe3d1596212" + } + }, + "aca9a7e6b2154a1783d8ca1ff842634b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7c3e444e8fe64590bf030695dc5f0a19", + "IPY_MODEL_bc3c490a2f3e4bd38cfb76ec5e7e5375", + "IPY_MODEL_f0e6b26d3a5244ba97e583c186f328f8" + ], + "layout": "IPY_MODEL_e5cbc3594dc44154b401e165e8c4741c" + } + }, + "acb1abf03f6844f8833c068f4f885704": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "acc4a6fbc8e34b37aad2a027292e0bec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "acc624f8d2204bbda0fb948f3853a7f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "acc8fbee0bb14943bb5390759aef1b1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7d050b63b8c94a1581155239762ce4d9", + "max": 972, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_711c500b0f5b44818fddbacb4c072a48", + "value": 972 + } + }, + "acc974a385d141c094ade00b24b3fbf2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "acd3e110bd194760be3740bc9bf4d30a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "acd62fa8fcfe4b31a004e7ca0b017010": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "acd786f9c6f24ba69acab672b3fe5ea7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a7deaaea89af44a3b702a5ee241bed2f", + "placeholder": "​", + "style": "IPY_MODEL_28d4f06514824374890bfe6ad5ecc238", + "value": " 1.80k/1.80k [00:00<00:00, 10.4kB/s]" + } + }, + "acd862df9a324570a81cd07a3c1b4a85": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad1b8f9d7950486b84a880546428490b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad382687aa3341a8aace485fca4657f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ad3f71c63bde4c92a7372468f13247be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad415056e5904fe9b99866a0e2a47a8a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad423fc0f49f456d84d99bc7bac85e05": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad51e65ced884627afdd9a4605afb326": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a6f58618fde4b2bb952575edcfa14a1", + "max": 1328, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_98aa51927bf84e63b23df7074a023fe9", + "value": 1328 + } + }, + "ad53f0c84fc54f3ea17d4998a8ffb1ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad56809c41a34c59beb5d70bfde42484": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad6892eca94647e4b00fb967e56cb684": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8c3fc6351cb44622a151661416fd1c5e", + "IPY_MODEL_7c9cc0be1f4c499f917c19ed23904829", + "IPY_MODEL_3a16cf127f8a45d8b08b57a520d63198" + ], + "layout": "IPY_MODEL_d8884db089a248bdb2d6852aab9d8b09" + } + }, + "ad7cd8179de1457397ff25cf24091faa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ada008125a0145019360af60b92487bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ada08ba6373145498b6bc7a641a734f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f0e2b69f02c54b76a7a94eab5a83a208", + "placeholder": "​", + "style": "IPY_MODEL_1a797afdf1f74896bd33c40cbe441067", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "adac5619a8d44fb99499186b594d74d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "adc2821e652346fba84277f7c5959f7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "adc50e019937481e9b9cb5cea54a5a05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "add657d66b7c47ebb31d69c057a8401f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_948d3111539d4e41b406398a59bf7268", + "placeholder": "​", + "style": "IPY_MODEL_4a574bcdb772424db5ba0a591466484e", + "value": " 1.09k/1.09k [00:00<00:00, 3.75kB/s]" + } + }, + "adda0c1704a64fd9ae3b91c6c6d4b0d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "addfa7e1ca3b4e2bbfa3bbc0774b26be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "adf0af0ae16949ccab6a3c1f06c09f2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "adf6dedd63184d018a3bec259f8621f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3013fd4dbdaa4853863607e930c7d15b", + "max": 1593, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_629b2a5cc9254d0bb61c0ca476b72a4a", + "value": 1593 + } + }, + "ae001978af274e27851d362c8612c752": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_28b21116f2f64931a20aa3df2d7372fd", + "max": 2569, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_56bd67b90817485fb24a9c83ab728952", + "value": 2569 + } + }, + "ae0514dcfaf6422996b58f4758a2e0b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ae0b7ba6a557454fae7608004cbb9335": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_85d4b4e5a7d548febafd1a9e6e90eae6", + "IPY_MODEL_58d1bb2cf2b44934aca16d9dae8a1936", + "IPY_MODEL_864c3d81b819496b8e740ac80e6a6278" + ], + "layout": "IPY_MODEL_f23da968069b45669d13ed544449afba" + } + }, + "ae0c636ce5ea4de695f2b0455dd7e841": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae1ea8870df045c89e634b743261efa9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae223a39678749acaacb2416c29edf41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3d85d642b5074819af8ef0a7514ba7de", + "placeholder": "​", + "style": "IPY_MODEL_ec06ec5e802e4cf2b186000139352f76", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ae281bbaaa36459cb4427759b0eea03c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ca13c002c76544a299978e64bdab50b1", + "IPY_MODEL_3d977bf927ba4a4098d3f5fe23c4ea87", + "IPY_MODEL_ba3aa09adeee4bbfb978bcae08fe9371" + ], + "layout": "IPY_MODEL_c9c72f7e147248f29fb6addaf425c1c1" + } + }, + "ae295e86738f4ab4a9b02bd83a2f4ea7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_85b8e2d840234716bbcfe4f73beb2b6f", + "placeholder": "​", + "style": "IPY_MODEL_4fe79bf246af45f3a8e7cac84db1b20c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ae2a76eb4b164b5ab30af49670ab58dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae467a6858c342948a07e3a391a26b28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ae4d4584cb4742558cdf869950c01feb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ae7001499fcf4bcbb08d6e54fbb6f264": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ae77c161404b498781430c15b76ec082": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae793e432d89407cb4d60d63dd71094d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ae81e46fe13c4661a591f2d99a0b0231": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0b4fd1a2eee54afdaa62ef4495d02137", + "IPY_MODEL_df086d8c0cb742b6aa4f57debfea6c40", + "IPY_MODEL_2adf073866e24f0193516874d72bf02f" + ], + "layout": "IPY_MODEL_f2dbe76cb2414a56849aad020092c4e2" + } + }, + "ae83e4a09ef64e2bb11c45af559bf330": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3cc1f29405c4401193045f26ca4db796", + "max": 4143, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9688a3cd4ba04b0289bb7e9c2a834570", + "value": 4143 + } + }, + "ae853d56c0d5470ab3fba373050d64f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae85cc83ceaa492085de672255f930a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4205553b0e554cffb9106618a11b2e3e", + "max": 144251, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e2393568f777497f8d3d8cc14fb3b01f", + "value": 144251 + } + }, + "ae87cbbdf21042d9b1942439721e9f85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7f832cb12d074230b8cc4caea6f7de29", + "max": 2068, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f7b16989eaab49b589a2fc06691c1f44", + "value": 2068 + } + }, + "ae92f3922b784d01be2c17a2b477d4aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aead74362be04990acc1f4aa32ae5cb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4b5c5f82088a4e3e96fd710ac7fb6804", + "max": 2828, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4f771aac4ddc42389777155adb6660a1", + "value": 2828 + } + }, + "aeb5f958d51a408387ca30e504e1dbc7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_29609c1b85d942fc9a498fa4ab8d253f", + "placeholder": "​", + "style": "IPY_MODEL_3e602a40d27f48ba9fc6689923742dea", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "aebdd27f1c014f97991e64f74100674c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aec2e4055a0345758b5ad7db7f76a65a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aece75a26f4f4c24bdd5d19456e2d8ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_472113698d514c6aa13d682a0eb57a2b", + "placeholder": "​", + "style": "IPY_MODEL_5edab9a599e04f1cbe8b20290a7d36f9", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "aee2cccbaa8246219166962ad6ccc7bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aefc32697a7a4d5d9592682df515c5c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aeff5d495dc44af0bd348d3e0ab32725": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_11fda33510f74bac9477b39b4da897be", + "placeholder": "​", + "style": "IPY_MODEL_0a0114ca8d52405284a8a89806466a4d", + "value": " 1.53k/1.53k [00:00<00:00, 6.02kB/s]" + } + }, + "af0801968f534aa0a0a3f87c9dd65730": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8885d8b4fd5d4e94856ebc886a06c5f6", + "placeholder": "​", + "style": "IPY_MODEL_8066490a19a24cd882fd9f9598e64e1b", + "value": " 2.49k/2.49k [00:00<00:00, 9.50kB/s]" + } + }, + "af0874fa72cd430abc3555aeece4b6af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "af0b19592d5e48a69c3cd773456ab8aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "af0e3f638b6b4296ae310f94952f98d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "af18181dec4c47948fb5945af2c485cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "af20536a5f0940f68e9c481f0d0542b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "af33fa9fab8e476ba156a25e8c582907": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "af4a4f7a959b4901ba2e4116e7313ada": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "af6c8f77e12d4c12acf0bf775fe01593": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_17706829472b436abc5db5d28e1b6f70", + "IPY_MODEL_6954938ed5614d20ab0ed770e1ca3111", + "IPY_MODEL_ea24566834b3461d883924f88551d0ff" + ], + "layout": "IPY_MODEL_924909e490754eaaaff0b4feb0d82cb1" + } + }, + "af794ef1d4024cceb47c6ab47b97c401": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_983a2f4b1b6843cf91ed56e08a40a76c", + "placeholder": "​", + "style": "IPY_MODEL_bef105cecc1842c1a162fc0b3f8ad6bb", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "af82a4e2020a4a4c944f0a88c71a0433": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9718fb2003634ff5953ee265ed117c2a", + "placeholder": "​", + "style": "IPY_MODEL_248eb841009c48a6baed859e30300eea", + "value": " 157k/157k [00:00<00:00, 673kB/s]" + } + }, + "af833213000441949d3c3e99ec6982d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "af83532eb170482c852fb9ad46ea8cca": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "af956ff21ece42d9ba3ca201e8e4e1f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "af9c8e3dd888426ea6c8705f9d35ef07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_93c2da8fb1d643d9b5d0325937b0fca0", + "max": 2379, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ec7a8abc11b84779b381dac1411994f5", + "value": 2379 + } + }, + "afb2a6a73c994f97a4ef0185d4801923": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9cb3e2318592461a8c38094960701e1b", + "IPY_MODEL_63d3f242dbc44a1c83a35b2c510cbc55", + "IPY_MODEL_2a41fcc681b04b2e960e336fa30cfebc" + ], + "layout": "IPY_MODEL_da387d8342964cd1a827693a257d4ab5" + } + }, + "afb5a3ba74734511a1f44cab31c7c95a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "afd2809614f14c7c934e4b9571a35610": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cf04531926f848188d4fe5e4e03f0c5d", + "placeholder": "​", + "style": "IPY_MODEL_b76640a5455c43f2ad441db03ee635e8", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "afd313075fd446e7bfec4507dd73c6bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afd51824b65c4af7b09b5a5fd61041e5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afd555f66fc64c1b845ad3228d6780ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "afd7c3480e8647e9a8337bdcb17cb14d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afd9cab7fb264639ad7c49d42eee3009": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aff1eb7929e247689c749ef336f46c58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9e5861cfb8674136b4d69bc5949f3843", + "max": 1436, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0dec35999a1e48cb8428cd89171a32b5", + "value": 1436 + } + }, + "aff81aa125fd40a687b62b3552df3bf5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aff9d0794d6841398d14b2a1f0d9f7e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d8fdd7df34d24a62816fc7a0441bea3e", + "IPY_MODEL_3e6760076b8f4807aa2fa110736f87d9", + "IPY_MODEL_98937268e0894b1fb565637bffd7ff5c" + ], + "layout": "IPY_MODEL_12ee8921cec14375b5a3157ca0d5413e" + } + }, + "b01e73494fbe4c20898ec9aa777fd853": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b0257016f562414da9755ee75cd96ce8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b033c21d550a40f78576fd05b472028a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b04dbfeef9564345b9a68f935ae38b0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b050cbf900d54740a37905c5c53cd1e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_760be2183fed4dd6ac46ee24698963c7", + "max": 1400, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_57521c2433e147caa1370de0c92c256e", + "value": 1400 + } + }, + "b05597d33b0a4e19bafed4309d3bdde1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b05aa5d3adfa49559d457b3d6404c6e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b084e5da24aa430f9dbf471fb7f35fcf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b0908f8f45fa4cf1b0c88d08a65422a9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b09429590a9340b1be5d90e502ae158e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d73bcff2a617473393b7670f91b0defa", + "placeholder": "​", + "style": "IPY_MODEL_3b5e991e83f94bd59cc53d48a00bb520", + "value": " 2.77k/2.77k [00:00<00:00, 20.5kB/s]" + } + }, + "b0b019c301b14ba7a60f9d961987f508": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b0bb12259d034c9fa7333a1b66ad58e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b0c14b49b07f445a9ffd2b2987cd1b0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b0d23f9cc30e4faaabf2059c05817238": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b0d463f8d60d4e4180089ee08f481e56": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b0e7c268ac084512ab6d32ef7e0ce554": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1039c64ccaa4f118836a8667b80885d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b10974f4526446fabb3229dc28e22680": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6a03f9fc01db4612a06038e7d6d7cc22", + "placeholder": "​", + "style": "IPY_MODEL_c614269a9df945e99d8cf4dffab45ddf", + "value": " 3.24k/3.24k [00:00<00:00, 13.3kB/s]" + } + }, + "b11a79d42e944b4d9668c2e33f4f8231": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_de67248ca49b47858330606605c2487f", + "max": 2258, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ba25d08ed4064abbabf1bafec2535084", + "value": 2258 + } + }, + "b12ca0af16c1427cae2888a1ed0a2897": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bcb5590cd15041f096d4c6cacf2d67c3", + "max": 2532, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1deba361256048eca68d3f6993e5aa1a", + "value": 2532 + } + }, + "b13285316c7d41b8ac878682dc6b931d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_082ba06713e748b8992c318d9af5ccc1", + "max": 3061, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eb244c124dbc4725851fa704d867cbcc", + "value": 3061 + } + }, + "b1400e96809a4cf9baeb3a2584db7303": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b14026892058453092e6eb49a8a3df3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b1581cc0e14d49d5a69f7ba9680803bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e124657421f6473b932c7a1d1c049037", + "IPY_MODEL_38480dfc49e840d1be3e20bfaf5ac319", + "IPY_MODEL_fcf9dc46152b4f569405ab0f37ab9244" + ], + "layout": "IPY_MODEL_fc702ad76ff34672a01729ee02bf6ca4" + } + }, + "b16ff13822834f5aa21035aac507df48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b182fe9680b64f23b3afbac97fd4c0f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b184f455b61442b28789c234f97690b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b5395e6c7f484f149a3335de0fa55e85", + "placeholder": "​", + "style": "IPY_MODEL_28b8c374df66454db75cd09eea67fa58", + "value": " 154k/154k [00:00<00:00, 384kB/s]" + } + }, + "b18fe007b08348899503b4288c504780": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b19a92ab84874e6d912fc1e88f7518f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b21842877ca848fc8d3ed7d59df8897b", + "placeholder": "​", + "style": "IPY_MODEL_191d5a5733ba40a7b932a301768e0336", + "value": " 146k/146k [00:00<00:00, 605kB/s]" + } + }, + "b1d3f484cfec453baafe3b00fea00c4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b05597d33b0a4e19bafed4309d3bdde1", + "max": 147205, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8a60d423c0724c918628f0e411249f83", + "value": 147205 + } + }, + "b1d73df453df4827ada377cc4be5183f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1eb53ce8e254ab09c6383706762b49b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a635eee177f422d858be701b9814b94", + "placeholder": "​", + "style": "IPY_MODEL_6171608533a34f86b875fe6c323a0437", + "value": " 2.87k/2.87k [00:00<00:00, 14.4kB/s]" + } + }, + "b20899b847ae47dab69e74a6e10f5389": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b210043b913d4294a7d182416d5b2797": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b21842877ca848fc8d3ed7d59df8897b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b221363f91944c6f8e23151b76055ea7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_789b7210015b4d63bd5454262b25ec73", + "IPY_MODEL_ecd829b411514fdd81bbd8234054de48", + "IPY_MODEL_77ab8254e226454bb4d8ce7646d700c4" + ], + "layout": "IPY_MODEL_89b2ee299a8541bea9045c704bcde56d" + } + }, + "b2294a87202f4b0c8ec80385ec750f76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_17c8ab8a55554848a08aa16a35aa8aba", + "placeholder": "​", + "style": "IPY_MODEL_427cdad308b849e5b837c9c94355aa7b", + "value": " 3.03k/3.03k [00:00<00:00, 15.7kB/s]" + } + }, + "b22b1b91fcff4d029d596cdea888ce69": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b2411e11c17f496c8deb29fb6f1b9c0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b2518b296c494e1281101c951c40e287": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b257c4621768447fa1cd6aed710a44a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6df688419ef24dcead2e4ff2b2a07f09", + "placeholder": "​", + "style": "IPY_MODEL_41530e820f9143b0a835746197d12b70", + "value": " 1.85k/1.85k [00:00<00:00, 8.16kB/s]" + } + }, + "b2638be7860c418caea5457cd2a92fb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b274be7f34db49bea53b23be229c1b32": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b278b0a32be645f3ad58525671aa1548": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a327a4c7a074fd18e9435cbf3e698b1", + "max": 2363, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_56450bafb1834336a8d779a203086b1c", + "value": 2363 + } + }, + "b287d6f0e12c4bc3a2093ab012779843": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4b0e6771efe64989af671cfcb3f66b48", + "placeholder": "​", + "style": "IPY_MODEL_318a3fe74f684821837b4ffeb21b498c", + "value": " 3.83k/3.83k [00:00<00:00, 15.8kB/s]" + } + }, + "b29172ba8d2e45adaf373d5db694522d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b299407cb23f4f1d8eb2db78755c344b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b29ca17e19ff4ed1ad78fb2528c05904": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_339047f777524df1aca522fbb12dad5d", + "placeholder": "​", + "style": "IPY_MODEL_5207475c3bed43fcb6c07951cd768569", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b2a08d62d0574350953945a3a347095f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b2a3e1ea3e35495396586c9bb6612bae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b2b48ed771dd4097a1ce338d1aea6f5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b2eb392907d94ef889512f7da56cafc8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b30f6ff19f5449e18c07a963b5915415": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b316dabebf20413e8d6f8ce0a41f7956": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b32f43f96fe94edf99bf9dd8ab0aae30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b32ff28415fd46ce8edfaabd1c87a650": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b33134184dbf43978011e8403ab2e1c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3327e47019d4616a7ca85b202db7600": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b3410eb21b404d8a852857f1b240a0c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e2cab2451ddf4f76accec6ac264c0447", + "placeholder": "​", + "style": "IPY_MODEL_8443849c16094053895558bfaead7659", + "value": " 1.70k/1.70k [00:00<00:00, 6.47kB/s]" + } + }, + "b344060f72814dcf9699341cb9b876df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b34fe0603a1f4c02874da6449327920f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fd1aa8a0b57546a39c13a8f31b325cfa", + "placeholder": "​", + "style": "IPY_MODEL_087cdd1ae39f49b88d452fe2968e2f55", + "value": " 142k/142k [00:00<00:00, 830kB/s]" + } + }, + "b357c02a391a4f8781548af1c6fb5718": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b35c07cc8db2420e866669e084bfbb90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b375e07ef95441f48d0f468b0a52cfd2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b37be9d7503e43458715ee9668753803": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b37fde9d2e124e9894cd1025cbc0383c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_86e7460160d64d98b2627e98a4a085f5", + "IPY_MODEL_0e39742b92974e33bba83bb16a45eb13", + "IPY_MODEL_d6a73739aea745f898b25fa0c271efd2" + ], + "layout": "IPY_MODEL_06738b4db47c4393b276e539c72ae21c" + } + }, + "b386370360cf4e33892b687862608dc5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3980dc0d1d94ad28c9faef9ee05aaa9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_aa990dedca7948cda6517f293fe8251d", + "IPY_MODEL_29bc6cef0e314f9388488a0d8d80dd2b", + "IPY_MODEL_d0ad8fb873a142d88e5886a48839a8c8" + ], + "layout": "IPY_MODEL_13b2e6e825cb4d6cb448da961ab9065d" + } + }, + "b39b3240183b4a05a08895f8e7c14194": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b3af31b05d6e4c7993dc08198bc6d93d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b3b2a040f7d74807841ad84d0393997c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_aece75a26f4f4c24bdd5d19456e2d8ec", + "IPY_MODEL_9d0de92b842e41e0a8ff241cdc27dce7", + "IPY_MODEL_5f532bb26c3b4fdeb3a111bfc41f23fe" + ], + "layout": "IPY_MODEL_f615b1ec8fd14f0082713b8e1460533a" + } + }, + "b3d1ee7c117141c6aa460fb53c56da8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b3d63164180d4c05a91ba70d6245fc33": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3dc6a8387214a01a06114794d703c9e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3de576813b14de38f89db60e0c49cf1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6570b52d1a95485f9bd5500bb15f8517", + "placeholder": "​", + "style": "IPY_MODEL_a5f677b06f7e4681a34fe65e7c2113ef", + "value": " 978/978 [00:00<00:00, 6.47kB/s]" + } + }, + "b3eea6ca7f894fa6a1f9aed4b8eafc28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f16fa3d75a474a47b1f661a039410985", + "placeholder": "​", + "style": "IPY_MODEL_330677bb089b4de0a5e042b951a19530", + "value": " 3.03k/3.03k [00:00<00:00, 12.6kB/s]" + } + }, + "b3f03cbb9fe0401b80f26ee76fcfd0b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ce69388d0b6402480860b15cc304593", + "placeholder": "​", + "style": "IPY_MODEL_1cc41f3588c7494387fa0295c2c8f215", + "value": " 1.66k/1.66k [00:00<00:00, 10.1kB/s]" + } + }, + "b3fba0e16a354f22b940c7181a08d243": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b40faf9b18b44ad5b4a6e4a2be38cf39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_acd862df9a324570a81cd07a3c1b4a85", + "placeholder": "​", + "style": "IPY_MODEL_6dc1a941b2f44d2fb7bb039dc5e03601", + "value": " 1.61k/1.61k [00:00<00:00, 5.19kB/s]" + } + }, + "b41246a8aabf4aaf812d29e09e0c0fc7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b42b2e4fe25b410b9e7ce51b16edf8d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b449ddc400014715af7237869e6c5567": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b45658d7a59945cea447882dc867a770": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b46b02dbc6f34dd98195713c624471ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b47270e5e9784feb8f7752e8888927c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a14d1d78616748be8655778d83680eda", + "max": 4207, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_559905f16c754d4ba900e8a002d87b24", + "value": 4207 + } + }, + "b474f2b8907d4e83b2cf9bfb394dcda0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c61e356f3db6499eaf616b967ae1c890", + "max": 1608, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_675a467723ef4161ae86e82a45fbfd54", + "value": 1608 + } + }, + "b48f119dc0b447b697a4e125d7ce0b36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8760b16760f041e3b5aa630be43eedae", + "max": 2215, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d9905df7b6ed4f1f93256f69ba242fd6", + "value": 2215 + } + }, + "b495b71f90f4431a8d15ceb13ae8d5b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5f1271a20c694b568d553d0ef906f15b", + "placeholder": "​", + "style": "IPY_MODEL_144785230792473c9c554d49ef18f9aa", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b4a8ec780a5b4569bcc04df214e448c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b4b895258e9b422dafeecdaceeb2fb27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3411aa885bbe42ec9d08f48074be56fd", + "placeholder": "​", + "style": "IPY_MODEL_9c805251790542fdafc248dd5bad0aed", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b4bc10fc49a04c8f8d39e9f2d61c3ef7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b4ceb3a8465d486e80a972e9ac93b212": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b4d6252f0c9b46179634422fe0e4f92f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b4f5fae9786b4d9fb163991e3be54c65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b4f962905fc540cc85a6f7e708f9fcaa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d6199ab758264d16af5b3e1ded35b173", + "placeholder": "​", + "style": "IPY_MODEL_58e13a8b67ab4a70ae330d35717a4d74", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b503052ef57248f983c73ca6c1280484": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b511e4beeb7841beb230e4e21e7b0e16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b51203fe043e48dd9d19dc0aea097a22": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b52dcb671cad4df0a7c2dc9798a46936": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_18b5bd8a862f405e8bcf24aedb392da4", + "max": 145891, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0a26f814a17d47cb80d2d85d3e821879", + "value": 145891 + } + }, + "b5395e6c7f484f149a3335de0fa55e85": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b55a769c116b467789ac73f1666a531c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b564f507f4d84871b56bee9953cb79d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b567a99fb082499ca6a4089340e4b314": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_90b3b8a2d6df4a28a95156ecf39f3c0a", + "IPY_MODEL_8f9ff5fb7184412a822437f995b9a2f5", + "IPY_MODEL_37b529fdf4604b3bb69265f6c431590c" + ], + "layout": "IPY_MODEL_3f3f619ae72b489983b619a272824418" + } + }, + "b5863460c02b4b82865ab1dfa44c04b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_92f38008cde74333aaf64d1243975398", + "IPY_MODEL_1036a13bdac94bdbb81e9374587edc4a", + "IPY_MODEL_fcfdac0592d441369da12d686d188469" + ], + "layout": "IPY_MODEL_6ce24022b1be43b7bc2348b33d0d55f2" + } + }, + "b586a727e32546d89b3871a51188fa05": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b59d266125ec48d3b03ede7c4217db79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7b27d909b86949e4a325fcd38dfe40d1", + "IPY_MODEL_2fe11668421548e7826fdda090bc611c", + "IPY_MODEL_cc01261a4ede48dca4fe7cc1a2bd4e10" + ], + "layout": "IPY_MODEL_4e1cd2b55f154f85a4f723cb10e84078" + } + }, + "b5a267a5a0e045429d33d14d6f3f9e6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b5b0222e1d454ba1943c545df7a61953": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7c5fe9b9a6884fb7903de40ea1b2d5e8", + "IPY_MODEL_f0df7d96d03e428c97deb46b431823ff", + "IPY_MODEL_9cb854e99fd641e18c8e5a8925225fa8" + ], + "layout": "IPY_MODEL_15c967b450e6497da41f07464ad7c2d9" + } + }, + "b5ba74a593214b7181a467333d145020": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b5c0e68b7f5347338a5098b5121c7088": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b5d0baefff55495b81cff08f92557872": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b5dd77b187cc4b5faa8bd1a7cfdcdc28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5283b89484d54504824bcc6bd654712f", + "placeholder": "​", + "style": "IPY_MODEL_39730d854b854e67acad34c7d9255ffb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b5efbfd7d17c4a81a862b29bbc28237c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b5f908f95c0841bcb2f2212e6a267aac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ec03897d36654ea3b51075a3d853c4a2", + "max": 3257, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_349facce7317406881291744c94e2ede", + "value": 3257 + } + }, + "b6224f7774d04639b1c9ea5dcff42ce3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b6246a96d8274da9a3059264071deed1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9238be051b94470d8d316e82d018073e", + "placeholder": "​", + "style": "IPY_MODEL_a4ab34c4ebb044859dc45be5842644c1", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "b62db11c33a348499a3903433b6bbef0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cd3946450a324ad6b93fc81c7cfb7175", + "placeholder": "​", + "style": "IPY_MODEL_61b3301098924573b017c19968515e01", + "value": ".DS_Store: 100%" + } + }, + "b6557df1ca5047d08b2fd07072128f80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_256c4d61caa24ec5ae2c4331b930d3ca", + "placeholder": "​", + "style": "IPY_MODEL_08c1353aad6642549dedeaf9a4710bb5", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b664b000df014a02bc6da52555c7c4fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b666b28931334e678c8b2697e71e8083": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b66a41cd131f4a6c8a1583dba66c47a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b66f74ec2b9c479cac3308f76cec5e56": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b67213ccea524540acefe25cfa0cd48c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1d19c60b557f4a23b9dcb99b6de630d2", + "placeholder": "​", + "style": "IPY_MODEL_f184a346582c4c668d61255195819161", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b68a3780c1bc40dcb5344809bc1c6ef9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_422b4276e0eb4276b9d2404e59e34e12", + "placeholder": "​", + "style": "IPY_MODEL_2290d80a142043b5a37f751614e537f8", + "value": " 1.69k/1.69k [00:00<00:00, 9.00kB/s]" + } + }, + "b690e33f0a484e5683e5c550332345ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b6a05731b0c6417da7ba0bd127871f43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b6a2683f9222477ea23ae1600761813f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b6c3a65023034159a1f72adfba1356b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b6d30f6b81314beba915cc21e19b28f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b6d9067231fe4020909b1ddc0e3c448a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5ca1861157f94cc59cc1047946843433", + "placeholder": "​", + "style": "IPY_MODEL_bb1bb5c9603e4791a0ee7385e9ba9df9", + "value": " 1.75k/1.75k [00:00<00:00, 8.47kB/s]" + } + }, + "b6dcd954a6bb41f2950c551b41fea9b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b704d5f212454dc190ad4722de2e9cd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b717eb2e2d0040ddafc6f659ed3958ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_865cbcad459c4622bedd25f1702b3445", + "IPY_MODEL_35cd36691ee1402eb35aec00b2119089", + "IPY_MODEL_5f961c0f618b437d8bd00f748050ff39" + ], + "layout": "IPY_MODEL_6a6d4b44db38442fb3465ccbaf7b7a28" + } + }, + "b72f017a4ab949d0b809b53894856a26": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b7457a88b76c48378e7b7016fc4b4388": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b75f5cbc33a443c9bd4e44605fc43d5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e41baee4b88a4510affbedf7f261d987", + "placeholder": "​", + "style": "IPY_MODEL_abd6f09928ab48dc8478a698097e546a", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "b76640a5455c43f2ad441db03ee635e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b76ba822f51542dba2cad82e44273c5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b7867d678d9844ae94671576cc31bb88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b7949d49a1464751b3db6b3aa21d31eb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b79cc38d3e7a4df4bf08fbb0577f7a85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b79ee0b6069f44c8958469a468b1aa62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b7add1a9c517400bac9784247b1d25b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b7c41a260de94704941f5794e15f9a09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b7c48abd60534407ac443e32d73a75de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_505c7490a43f46c9a58fd7e256c0048e", + "IPY_MODEL_2c72551ff6a84c558573331440a578f7", + "IPY_MODEL_900c46ba2cb44abf95b63b891e7a50a0" + ], + "layout": "IPY_MODEL_42dc24e5274f424097339a2850433bf1" + } + }, + "b7cdc2cc94bf48adb73b4c6cfb34d046": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b7d3877f07c64f72b29004a37d50da24": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b7ed71970f0745e8bee51d4ae7fdeddf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b7f79062781b494486c5848b9cd7fbcf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b800b2df268b4c0da537e6c3f097c56c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b845fa96fd7b4df0a8c261ae34b6327c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_56c7b57e8b994f18b64f36bba0f9f89d", + "IPY_MODEL_167f1d0bd1ec47b7b1d6cad6d471367b", + "IPY_MODEL_3b976ba713c54a4c9d95396cc00198c8" + ], + "layout": "IPY_MODEL_fec324a8cc5a43d0b340be5e0c7d4ccf" + } + }, + "b867b656013046dc86058ad83c6f87db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b86ef56ee80c483baa00b71932ffe0ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_11ca189002434c3dbe4cf56bed9bb0f5", + "placeholder": "​", + "style": "IPY_MODEL_46a6adee35a84debae6839b4becab087", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b872846380484bf5adcba65d064be216": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b8737489d8bf41779ec2c10d17476192": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b87d690339d4426e9daeaa8cbd86d67d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b8855ec149d549dabdd9cfb36f649018": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4ad0cc4b1ce746b6b721e425c350aa81", + "max": 2193, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_daf463bfb9a449b1a4d91c58258eb039", + "value": 2193 + } + }, + "b8940c9c0e4440a0bec6a23806e4bf63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ffa7844fd78e4a6cbef5ca1c90881ea1", + "IPY_MODEL_978df93a979845939a26cc7971a2f83f", + "IPY_MODEL_761d1cba2f3c46cab7a3a40c992563b0" + ], + "layout": "IPY_MODEL_005de857d9ff405dab7274b6ffc00f30" + } + }, + "b8970f220949466cbda6ba58f3ce9a4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b89ccbb8531b4284a473467e58831a2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_675cb3538a3a471ca12b6540cda4d5cc", + "max": 3044, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_869f6687a0e8493f92449dba665f1c9a", + "value": 3044 + } + }, + "b8a1ff02048849eeb486f1dd16a82fff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8af11e195b9497d863249d47b9eb8a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2d4253bbfd284d69b2ffc1f78abf6d93", + "placeholder": "​", + "style": "IPY_MODEL_20301f0dca754f1e80cec7b5e66a3557", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b8bcfc4df9254d38b81f2598de5a2109": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8bd0e490e5a40a38c82d110eef54114": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3344ba7c5e1a465f85ce6970a0c26053", + "placeholder": "​", + "style": "IPY_MODEL_13e5efd6f0e445a59fddf182d4d72a98", + "value": " 3.27k/3.27k [00:00<00:00, 9.80kB/s]" + } + }, + "b8be353cf5d74c6998f6ab6e479b9d6d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8c7fbe05ef144998ec1d714476f1e94": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8c9633b4522422b9b0502c30d9211df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8d4814532984393bfdb810f6fa56b28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b8e6afffc605482eb8af694e4b371be0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f9d479aae4e84d2a8dc12ffdd928f828", + "placeholder": "​", + "style": "IPY_MODEL_68e4808635cc421e9f0ceb0a501bec6c", + "value": " 2.77k/2.77k [00:00<00:00, 18.7kB/s]" + } + }, + "b8e6c99e368e4f8985c87018626e7a8c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8f70251d3ec45229f1219a73e33180f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3d35648b2a06499a8790a771948b0221", + "placeholder": "​", + "style": "IPY_MODEL_5de8752bd7a246069e740e6d0ade163e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b8fc580683c84d259506c346957ff2b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b90567b033e941348bbb0a7c2eea7395": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b92e8a9367bd4ee3a1b0362a6e68a88b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2af502fc3c774f418576b1b40f0803e3", + "placeholder": "​", + "style": "IPY_MODEL_670017b025e3411283b7c559b2cc2b64", + "value": " 1.74k/1.74k [00:00<00:00, 9.66kB/s]" + } + }, + "b936b4b7079f4d0ba13845986dffc3e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e032e765018e424490b81daa056eac03", + "placeholder": "​", + "style": "IPY_MODEL_ce925091733c49049f696828bdc83070", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b94135dc08114fbba0f1f81831cfac08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_78defad018394d35b496df6106c0283f", + "placeholder": "​", + "style": "IPY_MODEL_33b98f31fc1b4af3afcbf8672d5117e8", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "b94647eca1aa4a00b1f67a2be7e0ba29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fd6576585e9e4463b847e0bab3946adb", + "IPY_MODEL_ccbfacda857948c0b4f09d3df3322245", + "IPY_MODEL_2ef1bf1c12f74d14a047effd50899693" + ], + "layout": "IPY_MODEL_38709d30d142487083fee9bdfd03db1e" + } + }, + "b949d52f9bd84c6bba13a96a042a6543": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b959aba56e8a4fdd869eaba75c4354bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b959f3694f3847d6a91b953e34619898": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b96609c9a1484c6fa152eea60542a0bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_87cc0cd59b194b2cbd895d1ad0e5b00e", + "placeholder": "​", + "style": "IPY_MODEL_2f697746d845482c9833b58d0bd2c2e6", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "b96785226f554e718d823d7fdbd1e9e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b96861a8db3e4eb2b8f00c69ee2540c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_15e1df0c562642a8bf05b7f069d8e1c3", + "max": 1172, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bebafa92ea3c49aeafe76fa92aa0fa4a", + "value": 1172 + } + }, + "b96bc2fa30d2439ab9a9d9b48d4e9b2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b9743b9cc376401b9227e5fd30cfd859": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e77ee40efe074359a4dffdfe594d8f99", + "placeholder": "​", + "style": "IPY_MODEL_1ceec0263e8c442e86a360e2d563020d", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "b97bdb7dadd64688b11e90b91a0ec7fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b9a55d0913804837bbaaea37d931e958": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b9ada14843f24b4aab07b939e54df6ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4dcf75be8bcb48c9bb04d02e7835b7fd", + "max": 3471, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0700330a7fc34fdea9a6f70205ec654c", + "value": 3471 + } + }, + "b9b4a047ab9041ab9e5ee8d6e6f3fe7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1cc663e9cbea48968f817ee138913749", + "max": 1276, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_92b292aab77842fe968c882a7e0471a7", + "value": 1276 + } + }, + "b9c4dc4a33554a3cad92316dd2864fb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_868e0848780d47aca276551d813bbb95", + "placeholder": "​", + "style": "IPY_MODEL_75e7368792d24984a87b240693a4f816", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "b9ca2330edf24111bc9fa9c2b1e67d50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ba0124f48230482a80747400bfc4e78a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba06006190c84c2eb1ad1da547509a3a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba099c3e19c44479bb4cf757cededf43": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba0df14ee0b44b09a1e69885df1f7995": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba12aea1417442b78ee9190e4672a1d8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba13901a13244c8c8ca5ab418b0ccd1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_39153594a3f6468285cea4346288f79f", + "placeholder": "​", + "style": "IPY_MODEL_6d5d50937fec4e869af3027e10bcc14b", + "value": " 2.84k/2.84k [00:00<00:00, 9.66kB/s]" + } + }, + "ba208cf7d95d4d63af1ad614769232ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba25d08ed4064abbabf1bafec2535084": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ba25e2f1573e4db2906c81dea2ebec98": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bbef6a3d536b4652bd494b1dfb4e4e4f", + "IPY_MODEL_e0cdf250916344d7a097dfe95d8f9195", + "IPY_MODEL_9c2bd07a5b884fa1997ed28aa1aeaa68" + ], + "layout": "IPY_MODEL_adc2821e652346fba84277f7c5959f7b" + } + }, + "ba3266b8748540ed81f8789130cc0ef4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5b467c34846a427491e16a04ae9868c9", + "placeholder": "​", + "style": "IPY_MODEL_fca3d305b6d44be292d61da5d5758c93", + "value": " 141k/141k [00:00<00:00, 655kB/s]" + } + }, + "ba3aa09adeee4bbfb978bcae08fe9371": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1d49491520d649fd9b4329b50a883a4d", + "placeholder": "​", + "style": "IPY_MODEL_ab66085d37244be98451e64d5c6901c6", + "value": " 1.33k/1.33k [00:00<00:00, 4.65kB/s]" + } + }, + "ba3d6a45b7d1447da5a7dd3008e6a78b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ba48de07aeed4697aa7323831b79d750": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba5f9e12ab2b44eeb3017e14cf3e9447": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_21aa5d5853da440387073b9c229cde0c", + "IPY_MODEL_b278b0a32be645f3ad58525671aa1548", + "IPY_MODEL_0565994e84cd46ce85735c1639228023" + ], + "layout": "IPY_MODEL_99d463a923bd457781dc42af2f2a13ee" + } + }, + "ba6b3ed9497d42b993b9a350f82e6583": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eac0d8bbf8024e89b6bd091bc8b6d702", + "max": 1394, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f60e4bbf22a54d52814e2b3ba38b4d13", + "value": 1394 + } + }, + "ba7f63e4892345fd9ef1c8d763edf7f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba81602624e34f989ec8fb6fa451f8f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba8b5413098341bfb324c639a02e3f6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ba8bde966c714a46b4f5b8c01490903a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba9a0d642608444d9ed79428755832af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba9b848f4d474008828724668ed7c379": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b9743b9cc376401b9227e5fd30cfd859", + "IPY_MODEL_be7a2d8ace98495993788f4bc0d9fc15", + "IPY_MODEL_e1d53d337f404774ad0919c688c62833" + ], + "layout": "IPY_MODEL_ba9a0d642608444d9ed79428755832af" + } + }, + "baaa768e58b24cc3aba2742d243bfa02": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bad5e9000b054c5081bb923fadd9af44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb0e99d505134397aa59a6d1182cc423": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a35200aba23b4c67be7f477121866cd6", + "IPY_MODEL_01b39090431c47728c0895ba7e80a649", + "IPY_MODEL_a362d70bfc0542eeaa68040c0dbff233" + ], + "layout": "IPY_MODEL_a5bf39bf570742ebb1c8bbd09280310a" + } + }, + "bb0f0cc855a546fc9b764d958f889139": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb0f547a7db84fdea1318f7ae7c11a1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bb138676c226420e8043b0c883463791": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb1bb5c9603e4791a0ee7385e9ba9df9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bb3f00f258d84b9e9d65262e3d40a745": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f8ded9aac1dd4d6789b9596ef45a9c3b", + "max": 145296, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b6a05731b0c6417da7ba0bd127871f43", + "value": 145296 + } + }, + "bb406c47f9244eea826f96adb5e959ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_19b1eed1066f45b78fe217c00042ff18", + "placeholder": "​", + "style": "IPY_MODEL_86e55605bb10452d9c52fc5b701b74f0", + "value": " 1.09k/1.09k [00:00<00:00, 4.84kB/s]" + } + }, + "bb502cf8a86b4cf8a32c106cfd31a97f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2a697f42d7dc4d799d73207053a19d61", + "max": 157024, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9dc9fc25ec3a4ff98a1e7ba774a0d222", + "value": 157024 + } + }, + "bb5bdd15f06c4f02a9298924ab8a7f20": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb60c8b3a81e480eb0ffba3159aeff94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1a4b66e9f9b34380883550c3be934133", + "placeholder": "​", + "style": "IPY_MODEL_de6f144ab2664881a43ac3780522030a", + "value": " 1.72k/1.72k [00:00<00:00, 10.8kB/s]" + } + }, + "bb6a8c5460ef476695a8780e2b192a7c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb7092a8385d4a6a985ca01f8baa524a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb7dff7f83b64320814070b605566ff3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bb9904ff95b448b4bad7bfe3d1596212": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb9af2faa50b4c1099f51d373230c310": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bba3beeef2244558b4a605f35ea4a741": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0eb4ccfef406472c9898fcc1979aa57a", + "max": 1751, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9c66f0ea87ae45f6acffa72ef63110c2", + "value": 1751 + } + }, + "bbb2cee2cd2d4320acd238a4f7c009ed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bbcce8f46aa743b6a218cd2db676a82f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bbceaa7f16734639b4b054ed3f1c522d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bbcf9fa5eefa4d63aa0cf6afbb065cee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bbda0fb504b24aff98a806b32013f512": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bbef6a3d536b4652bd494b1dfb4e4e4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4fea78b98b84dbbbcbd40d5726c9b5f", + "placeholder": "​", + "style": "IPY_MODEL_546e20ec0b984914afb29f8b6a71fb49", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "bc1d164c9d2c4b02b1af8d05175635bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bc297997dc2a440d898fedf9c1c1f4c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bc2d2f21f35a48cf9089003b9c3fa7ed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bc3c490a2f3e4bd38cfb76ec5e7e5375": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_296a2329da3644b396755e465d4bae36", + "max": 2909, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ec956412a5b84f85a670ca0ced92d068", + "value": 2909 + } + }, + "bc5f39e1079143a3ba807425805b370f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bc86c9aa71c44bc69d89115b7632f19c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7bb5f31d145b4a25af71437bb03bb7bd", + "placeholder": "​", + "style": "IPY_MODEL_e2ee1110dce44fb09fc1f23dc2ce7735", + "value": " 2.19k/2.19k [00:00<00:00, 13.6kB/s]" + } + }, + "bc8d67c7aab543fca997ed56dc824d76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bc909e7e9c774a28b65573791e15250a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_91bcdff17ffd48bd986ebcb4b2485bf1", + "max": 147633, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_88a8dd0ad1cc48f999c3d6e758a3d6f0", + "value": 147633 + } + }, + "bc9ab3ba05b742e2a51674b644d105af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9eef8744155b4cb7ae5860b6bf6b6491", + "max": 916, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_388ff01ee5e046c19aa0dd442cca1fc2", + "value": 916 + } + }, + "bc9c520f5d994af1b4181992f9922f0d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bc9cf702054c4f1382498ec1be39d2d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bc9f7bdda4dc4cd39e13fc584a2e62a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_42b3d85437484faca5480a96ed3d36d3", + "IPY_MODEL_ac879089086e42c4b4ffe8a012d6d5af", + "IPY_MODEL_bf87e3cdaa7344c69c196924b36b4cf3" + ], + "layout": "IPY_MODEL_5d88f21e62ac43bf9b9b7eb410df7efe" + } + }, + "bcb0c02826554995945534d0002fbed4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bcb5590cd15041f096d4c6cacf2d67c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bcbd82c60b544100a19c14d41255a8c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bcd64c896f704b6db7ae5ce81f213223": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bceea450405f448d9d03347583fdeaf9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bd062fb984ed4bcda05857a27552aac3", + "placeholder": "​", + "style": "IPY_MODEL_2cdb9a56c35e4118b6f16e9a2de6cead", + "value": " 2.10k/2.10k [00:00<00:00, 13.1kB/s]" + } + }, + "bcf32df668804a8ea521169f30cfad42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_962d27159b2141bc91566958f596e196", + "max": 1488, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dd967403e42a4dbfb93ec6c6a46553bd", + "value": 1488 + } + }, + "bcfbf1d686254a63b36ea711bea4cdc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_19ae31b26f9a48e7b8f2bd5881e1cc08", + "IPY_MODEL_04fdff7c0d5e49b0a097ce6a4024372d", + "IPY_MODEL_1936402d787f42ebac4f2cfecb33c345" + ], + "layout": "IPY_MODEL_f824b4b94cb84389b485b34398e670c6" + } + }, + "bd062fb984ed4bcda05857a27552aac3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd0eafc04a8c43bdbaa51d818a802388": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bd1421d8c6eb4be7bfd40f8e5e0fc6e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bd1b9f84838d46a9adcab33387012438": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ed8fbda2464c4bb6ae5a391552cc4b64", + "IPY_MODEL_a5ca5b4fc262465d90574a0e4be5ecc5", + "IPY_MODEL_9e296deb1c234677b783bc56852c7b42" + ], + "layout": "IPY_MODEL_6c8e1f1b2e4b4fe38882eb4326d80a87" + } + }, + "bd1c9137a75642f0aa01b71916b27fd5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd3b0404b995407fb78fa52edb575f8c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd4db47095ba4e01abb77dfac5c57ed4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd69e7c9e36f41509fed2f85da918473": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd6d751ad5ba49a2b7a0ad10c0dc66c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fd32a19ab7ac4d0c92d49d3092d61458", + "IPY_MODEL_6d998b76764d43429c732c6d21f14e62", + "IPY_MODEL_1f435fbe53dd4da18204f1f046bd2e34" + ], + "layout": "IPY_MODEL_46791dfc604c4cc6a3a138244da4c6ab" + } + }, + "bd7540c552e74a3d920a18b8405ccc9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bd7fa21e95b24b0abb2de38b9cfe2147": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_020af0b9760e446eb2cf88026e904b78", + "placeholder": "​", + "style": "IPY_MODEL_893d4dbe226e489a810128f31bdd2cd8", + "value": " 2.45k/2.45k [00:00<00:00, 13.1kB/s]" + } + }, + "bd83eb416973436598beb07b59903dde": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd8cf72edf164cd8bddf6f319164975e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bd9d694785e846359186258904396689": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bdc04e14ba9043aba0b2f310f903075a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bdce12075bcb4c479dba90fddaf4ce63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bdfced5e609c4779aaf91e0f4f43329b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bdfd36cb7e374b3681fb266dbee612b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be0656babada43e2b836ec3b66bbce78": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be0e648b134f4dbb8f2e5b0813cc4ef3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d080400dce6e4604a48010bf8c6e2962", + "placeholder": "​", + "style": "IPY_MODEL_16f686da39b84b35bfd4eb5601faee9a", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "be0e73d8f29f4f04b1c1dad81b9e9d49": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be15f2850db8476781260346e0d7b5fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1600f0ef839a4afb9795fd90db1f4966", + "max": 1698, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f8e70a7c172646d5a68d969bf6969f50", + "value": 1698 + } + }, + "be2cf26ac0184ba9b54293a6d3379167": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "be40367d709c4ad9848930f5a776911d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be49a16b47dd4ceea53b56bbf4385784": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be4de179efbd4950964a1e026ce9bc5d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be4e9de04e6242748fd5ae5a31da7f88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0438f4a3c8ad4adca3ee475960851b1f", + "max": 4400, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b511e4beeb7841beb230e4e21e7b0e16", + "value": 4400 + } + }, + "be4f95e2630d447bb2acdf947fdf71bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be5e4e8ad18a489b837f6662f9972010": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b62db11c33a348499a3903433b6bbef0", + "IPY_MODEL_cfb817849dbe4efdb9f8341a2ad402ab", + "IPY_MODEL_2a5dd19b4248459b98516d0391d58644" + ], + "layout": "IPY_MODEL_403d9ba1bd304003a252a52e485d5392" + } + }, + "be62e18e754a4de08d5f30f97cf79ae8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a23ef693631d4391b30bc702794e3341", + "placeholder": "​", + "style": "IPY_MODEL_c3f56fdf61b44a99a6ad4619e155a311", + "value": " 2.07k/2.07k [00:00<00:00, 10.3kB/s]" + } + }, + "be65c4260b4541488b70eb1b4787dea6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be724ebc65b64260953679b9f776e942": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be781b23cd414a2baa88313779bc0fe5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7d6538c795a449cbb04a94e40e235d0e", + "max": 1208, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0a4e81744b0e456a8b081f8544091628", + "value": 1208 + } + }, + "be7a2d8ace98495993788f4bc0d9fc15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6ac4109c1daa4374a21dcb8d1e4364fc", + "max": 2048, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_85d0edeccce24bea85e23bf112d9b645", + "value": 2048 + } + }, + "be7f021ee6ef4ae0b73df6b88e516c71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be88a79d954240eaa239c8c0020fc2c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_84580ffdd8ae49d8879ef702525074fd", + "max": 1352, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_886c51a5f8fc4c73a6987bc2984af18e", + "value": 1352 + } + }, + "bea9a70017a549c48261a35048c2e74a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af83532eb170482c852fb9ad46ea8cca", + "placeholder": "​", + "style": "IPY_MODEL_857828ca78dc491a9e258caf184c2298", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "bea9b9fa2c9e4f6bb87d6a3edabace91": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "beab17e991394579bbef6ed9d83244be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "beb0655ab8a64e2e80059d1f8aacb155": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "beb18ab72b1f4fdf88a3c0f15372a095": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bebafa92ea3c49aeafe76fa92aa0fa4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bec3b37f03564ceca215a2def93c33cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bed7434bdf3e4833bc71893b42a0dd80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bee1220061ad42feb4be374175fd1830": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "beeb71cc4ea14bd0a822a036b37a4592": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c31e4fd10a6d439aab5ee805f361b036", + "placeholder": "​", + "style": "IPY_MODEL_ae0514dcfaf6422996b58f4758a2e0b1", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "beed816c63764d22be2fd53a45dc039b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bef105cecc1842c1a162fc0b3f8ad6bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bf02cdc273034377b9036a0ae032084e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf1da7da12a84906a211045165dcf641": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf2b1d5dbe1545a3b64feaa37285ebd0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4afadea01a9e4a4e9ba9af48e4e53ad3", + "placeholder": "​", + "style": "IPY_MODEL_b3d1ee7c117141c6aa460fb53c56da8f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "bf312d3c031f4d2ebaa8b112d5b22bca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_be4de179efbd4950964a1e026ce9bc5d", + "placeholder": "​", + "style": "IPY_MODEL_2338c3c6b9fc4d09881d28ccf8c426d1", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "bf408370c4f54f4d96f2e18437c20e71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf4552af87cc48c2b480d013e84d86d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0308a4d940154b7cabce8cf179abece9", + "max": 2649, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1efae3f086e849ef8a308dc87cd2d4f9", + "value": 2649 + } + }, + "bf6ecca851ce43cc96f4a125965e97d0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf7e5b696bc54f51bd5d4879d87be432": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bf87e3cdaa7344c69c196924b36b4cf3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_55639364685b4d35b6f13aff9f732ca8", + "placeholder": "​", + "style": "IPY_MODEL_01920f56af194167b7addc4cc5f16ca9", + "value": " 2.42k/2.42k [00:00<00:00, 13.8kB/s]" + } + }, + "bf8bb047f98a44ac8f7f8b29fe678b94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eadd5ef140d6486aa8bb46289b65cc0f", + "max": 2211, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9759780fd719462cbbaccf0799c2b8c4", + "value": 2211 + } + }, + "bf90427669a4439f9484e2428d47e5c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf94ffea970642e4845a4df6220e6964": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2c91627643c44c3685d078dd213e9b9e", + "max": 828, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8950e1dfe5834495b7611aef0ffe125a", + "value": 828 + } + }, + "bfbea7345d3d43a0b5fa8eeb768abf4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dd1bb7d3b0d14d498c0490622edf23ff", + "placeholder": "​", + "style": "IPY_MODEL_02fcb0d88c904bb39dde59f4f2f6bce8", + "value": " 1.38k/1.38k [00:00<00:00, 12.9kB/s]" + } + }, + "bfc367718b3a4398ac976b974219a620": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bfc7f908013148c6a85ff2c88fe0482d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bff84c29edf7421db8440f54b2ab7758": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c0069eb4c22a4379a9e6945261a146ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a04af0528d04465eaa428df66a624431", + "placeholder": "​", + "style": "IPY_MODEL_714e2f7146f34f74867a15318d405ab2", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c02ad2a576c747b9ba4c85172ac47e19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_861ab1d8420f424aac692ddeab51b18c", + "placeholder": "​", + "style": "IPY_MODEL_e654b581409a4207aba66013cdb48b8a", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "c03d9f9145ae4a8a83b8342b9048cd99": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c04af8a840ad47b1b5c4fba66a5d79ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a9fb6a3335ab4824b67d4f93d80c0164", + "placeholder": "​", + "style": "IPY_MODEL_9ecd1e2c66cc42438c640a8c4946b3b2", + "value": " 2.40k/2.40k [00:00<00:00, 10.8kB/s]" + } + }, + "c04d72b024404853b78a6f88f2a42f19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e018bb6171094723bf9a8470fa148346", + "max": 141663, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3573fe5ee5b5458d8012a482eeec2921", + "value": 141663 + } + }, + "c04efb5e88264a6f9130749c0646570b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c05699467511476f90b07f0ea65fc765": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_615d2606e1f0456181d763820aa52769", + "placeholder": "​", + "style": "IPY_MODEL_07a3b2c7fb364350824c32fe5cb7147c", + "value": " 145k/145k [00:00<00:00, 800kB/s]" + } + }, + "c06e9e4ba9254bec8278078ee7e7775e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c070787b236d43bb9f171e342590f41c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c70253cd65f6442cbbf5254d72b5f261", + "IPY_MODEL_35f4d899d0184802ba0f0f5106e029ac", + "IPY_MODEL_f2af6b2e16e2430a910d404c5e857a17" + ], + "layout": "IPY_MODEL_b8bcfc4df9254d38b81f2598de5a2109" + } + }, + "c076a02490fc464b879ad88808260d95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_45bdccae192e4a1faabbecd639f198d5", + "max": 161577, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4e95b9638bdb491982cbbf4f0ce81dbd", + "value": 161577 + } + }, + "c0807b89c95e453abccd63628245d78e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9509d791074c4df898e874250d5c02db", + "max": 1984, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_803f505e745247e2bfcac7211eded872", + "value": 1984 + } + }, + "c0874e3576ef406d8df9cd4ca2c150c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c096d81ee2be4c908662598a18d37d8a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c0b54bcb1dee482584d66e5a0e8e8e99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c0c3c5bc54f448bda196c43d48684ab9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c0c64543d33b4c148925d71162600e44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c0d3470e31f94eda8c560a6368c3a68b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c0e4efbd70324a98996b1a1a1594cbd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d7b3756c9e6147cea5538125f25ca8d2", + "max": 1480, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c4022db453c14ca6b008c7fb25e77eac", + "value": 1480 + } + }, + "c0eddbae201345169cc00e0f9ffb2a15": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c10acb94d63e43a6911089ff3a8fa5ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bd4db47095ba4e01abb77dfac5c57ed4", + "placeholder": "​", + "style": "IPY_MODEL_f0895f18c0da4b90b4f512e8b8788a72", + "value": " 849/849 [00:00<00:00, 5.31kB/s]" + } + }, + "c116305c4b1f46df87446a3a512b3141": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c11732e19eab4817abc311cf85c304e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b2a3e1ea3e35495396586c9bb6612bae", + "placeholder": "​", + "style": "IPY_MODEL_e5edc206686a425485cce4d8ae935256", + "value": " 142k/142k [00:00<00:00, 556kB/s]" + } + }, + "c11e04bc998b41b3ad81f37e4506c3cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b5c6bbb95bd4296a41ce00bd4a8bfae", + "placeholder": "​", + "style": "IPY_MODEL_adac5619a8d44fb99499186b594d74d7", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c11fb150fa6147ffa31a0964e7fbb8f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_71f3a8fc5e994acebad8260bd23e8e76", + "placeholder": "​", + "style": "IPY_MODEL_c4cbc3f6b294464d886736c73580a6f7", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "c13202aff8274856ab4128fb35913902": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c13e282bb7a847768c0da638e4b91f46": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c13eda6cbdc741baa9a847976268c171": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c13f0a80c3ca4f4b8f32a3d26a947a25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c14ee38c2bc44bbd8e5323752fb9848a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c156f220afd542d0a75f5f6d1e5411e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3945e07b4af44a4bbd9ac01f6f893123", + "max": 2217, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_86489bac14394b8c940cde7001c5e893", + "value": 2217 + } + }, + "c16f67e36ce548448ad86eeba27ecd1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c17148e748a5466f97365200e0f98fd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c185a31815e148fea5f35f0f40e1f7b2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c1883383a9cb4b9fa877803c398ead1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c18d6534ee49436ea08ae8951450bfcd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c1ab6633cf624305a625c741e632b3fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_46a45e153d81488584699e4c27a89231", + "placeholder": "​", + "style": "IPY_MODEL_c9aac88e8b7c448eb0cb3de46b284f82", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "c1af3ffba23d45d49c4b1d9563438c33": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c1b67442a2fa499c9c350c4ba4720b51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c1bebf21bb444352953a3cacdc606e23": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba12aea1417442b78ee9190e4672a1d8", + "placeholder": "​", + "style": "IPY_MODEL_ec8e0fe983ec42d5bd3bed1d81aafd27", + "value": " 1.24k/1.24k [00:00<00:00, 8.49kB/s]" + } + }, + "c1c8a352cf154a49b6bb920293e1ddea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c1c97e126c354ab3b0eea70ea6c39a27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c1dffdddd1ec4c0bb33835bf345033d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c1e29e6a71e0461baacd4cfeea0c8ff5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9517dea5a8d44435970ec50b7a407089", + "max": 1743, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f7ba9a7029d44aeab247c71190495f84", + "value": 1743 + } + }, + "c1e5165a5c70489499bee1c729d8117b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c1e680bdc4084555bf4a73a72e2d6e3b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c1edc767a93c47b48c51de7126bf1cdb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c1f8e73cb9f34a5b92c8c2a617fa6dc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c1ff376e907d4656977d3a723e914a5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c204094eb081482f95afb1ecc48377fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c5b94bf0783543d8af288140564df66a", + "max": 954, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9f6abe2413d1474e94cb52bb9eabea90", + "value": 954 + } + }, + "c2277045edf74a138348b1d5a7cec66a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c22ce55dab2b4e59b9809847e7d7e9df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c22d593ce97b4728b4fce67f2001c843": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c2316a0e4bcb425c9c75e0ea293f6c8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_84a247af39964f8885ca472109ff094b", + "IPY_MODEL_8b761b8f5fa34054866db1eb00a38cb9", + "IPY_MODEL_f26513e75ae4488a8fa09b72399a1e75" + ], + "layout": "IPY_MODEL_3be6f93332f64d66a93e7023351748ed" + } + }, + "c244af504c334c6d9ffd7dd328000a9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8b10b1cdab3e4a4881061a10c0add9af", + "placeholder": "​", + "style": "IPY_MODEL_738f32f7f29c44fc88066afc920457d6", + "value": " 135k/135k [00:00<00:00, 215kB/s]" + } + }, + "c25617f7d10f47d6ab3972d1439a0548": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c26f635152e54e48b0714f4394ddfc66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_05f26ab0b7d94e6dabd18b30de0bc14b", + "max": 2074, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_25abd36934d04ef990f2ae87a5836986", + "value": 2074 + } + }, + "c27879d218a442eeb220673c712fe1f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2d65710feb964e83817a1b9b762842de", + "max": 3324, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_70e04eefe5dd459a9a18af04e155a109", + "value": 3324 + } + }, + "c27ceab22e2e4983aed6df11096ed3a5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c2a4dd41475c44a1904cf725622864de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d63e8b07d7c543b4bf4f85bfd010cbf3", + "placeholder": "​", + "style": "IPY_MODEL_a71cb92c117641cf999bf31c92be0fc9", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "c2c3eb6d0d194e61a340900c2e98c393": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c2c8218d6d1c40cca4afdc72104fec54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_68055bb469d2424b9eea59b44a755198", + "max": 1900, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e924bcc461e04c2db33bfa15293c4a36", + "value": 1900 + } + }, + "c2e1c1049c1c421fb53eb8579a1a8b65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c2f58a4439a941c4aded11da214cb744": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9256e2daccde404895734e3e0468ea6d", + "IPY_MODEL_8225206a8b614e489527fad31a974531", + "IPY_MODEL_151f64e20fcc4a5aa97553c7b130a0fa" + ], + "layout": "IPY_MODEL_7599031563994e95abfedd0170aaefdd" + } + }, + "c31e4fd10a6d439aab5ee805f361b036": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c31f162026164533bc4c5dd42b3520c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c32129459ddf4a97951d6a96abcaf1b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c337dfd0bb00424e82eb89add2724275": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c33e0db529044578b14c8d10b9c4190d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c35b86b1875f4dccb345dd0057ff5605": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_83a101a5bc874246a44747da93d117ac", + "max": 1892, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7da794f9cd444197820a9e3a0a6e576d", + "value": 1892 + } + }, + "c3716f7708ae49a797bb6fbbbc10debe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c37a1636e6ee4de9b988110c589d7487": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c37d059570b342889c841df8cf244fa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_72465fa73f89458292847e5bcb53491e", + "placeholder": "​", + "style": "IPY_MODEL_d8747ee5646246e292692d5aaab1eaca", + "value": " 1.79k/1.79k [00:00<00:00, 10.7kB/s]" + } + }, + "c38245422961435d8fb1ec5335ce22d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0a3c589d48ec44e7b039c9d128cb5f2e", + "IPY_MODEL_398cccdf1e314eda8b1d85f57c7b1234", + "IPY_MODEL_c1bebf21bb444352953a3cacdc606e23" + ], + "layout": "IPY_MODEL_097b1cc7856645fcb3aea38ab440004a" + } + }, + "c3848f3665ad468bad4c813b4398e548": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c3882d431db44709a74650b8bb03d7f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b560b2f81a04ee9b6d204d0a2524e4b", + "placeholder": "​", + "style": "IPY_MODEL_5c8021f1bf2142beb5a1d0038ac7bdbe", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c3acc06aa55f4df3a770ecc55a306815": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e9a2de02811e4f56887b01c30f02ac51", + "placeholder": "​", + "style": "IPY_MODEL_c16f67e36ce548448ad86eeba27ecd1b", + "value": " 932/932 [00:00<00:00, 4.78kB/s]" + } + }, + "c3c4fe31d72f4d29967b9fd178341241": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c3d4150fde5a47f9b83a1bd1bf68d2f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_45d0d1d948b54d359090f1f570012089", + "IPY_MODEL_a63c02441e054cbb81ba3731d74089e5", + "IPY_MODEL_9fcd05de012b4384a70ac4948b7860a0" + ], + "layout": "IPY_MODEL_c5873f8980424c34acaaf254d9c921bd" + } + }, + "c3da20fa05724f81bbe043b2017b27f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c3f56fdf61b44a99a6ad4619e155a311": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c3fb3ca7a7ce4c5395593d2d94f945ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f981887397434c4c9bba40a250a7ac8b", + "placeholder": "​", + "style": "IPY_MODEL_45741bce027a457b83cc085a1c3fc013", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c4022db453c14ca6b008c7fb25e77eac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c407f4fe5cb14426a78d480f28e66a30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c41abfdf452141569448aa044de4c481": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c43417504dad41b59ed72863f5e3ce1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1969d59825aa4c298883f22e1ccdcd54", + "max": 2412, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e55eb0d4fec84a3a81cceca3bb82d30f", + "value": 2412 + } + }, + "c43cca7c76384876a5e4255135bc7309": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0a76f93ef5fe46fc91004fcfc3a8ac9a", + "placeholder": "​", + "style": "IPY_MODEL_c5a7cb8786f3453a9d05e5ddf5c10d6b", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "c44cccd8e2ab45f19ad7d271401e06ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c44cd5ed2752484fa53cd8b4af42ba1c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c464d830cf8948408d793a6c6a6c81e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_403b836d310e41039cb80c3d8cd77945", + "IPY_MODEL_f4b76e10cadd4277981ebe18d21f8b71", + "IPY_MODEL_1121fcd8821e4ff1ab73683cd46c9612" + ], + "layout": "IPY_MODEL_dacea59f6fe14dfdbf080a3d063541ab" + } + }, + "c47096409ac24697b860571df8cbffc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c47fcc389d584f40864f9ab6fb480242": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c48f5699233240ddbd4eb746d2d59ebd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c492bc758cad447ea4f204d02fa2764c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c4b692826e584f789a219386a4248f31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_12cdf1fe8a7e479f9d8afa07fe809134", + "IPY_MODEL_c2c8218d6d1c40cca4afdc72104fec54", + "IPY_MODEL_c863724058d64741986f51322d4319ff" + ], + "layout": "IPY_MODEL_cc46b45979df4d5584efabe5ddb2c65c" + } + }, + "c4cbc3f6b294464d886736c73580a6f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c4d1dc2d0e4240b8b8b908b5fc616f26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c4dd31ea213a4515a0021e4104f0ea0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a0c7b24983ce4e7f82bfa941fe5a0de5", + "max": 1978, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_38845db0c07148ba90661f3de1d70d7e", + "value": 1978 + } + }, + "c4e4f530bb884842964e08bf5006843a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c4e524db2e8643ed9a45bbcf4581672f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c4edb71133f144e9ba8c0c8e1ddc6eee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e6553793625b49e8aee0b121e8414223", + "placeholder": "​", + "style": "IPY_MODEL_d11de86c48bc422dade29737e90a7f54", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "c4fb51361c464b91afa99862397b8a84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_62770dd8a2b04e529316441b16850179", + "placeholder": "​", + "style": "IPY_MODEL_6ca81a825c48465585e484e98aac4b6b", + "value": " 2.85k/2.85k [00:00<00:00, 20.0kB/s]" + } + }, + "c506519abe3f4a1f8afabe353a3d90b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3583b97d25949b58e5cd6413408f15f", + "placeholder": "​", + "style": "IPY_MODEL_f9c88e446de944d3a3efb22ebd9f4cf1", + "value": " 147k/147k [00:00<00:00, 903kB/s]" + } + }, + "c51354ccdcb14c98aa1d9cbccbfaff79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c5278bc3d2ca49638527682fecace4e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_06b8b132e39b48ce8aa20465ee070cd5", + "max": 2491, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2956a54be4104633a8e31e0717d24a2f", + "value": 2491 + } + }, + "c529cfdc7dad4dff811298bb138a8b97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c52bc0da45614bedae4c3dd210cdba6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_753dbe1f1ba34123b437b70193c4bf07", + "placeholder": "​", + "style": "IPY_MODEL_364f72a7e52144fca869ea16333285fc", + "value": " 1.18k/1.18k [00:00<00:00, 9.14kB/s]" + } + }, + "c53d36886fa540799267425cb3be0342": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_03404444b2684883ad91197cae0c1e92", + "placeholder": "​", + "style": "IPY_MODEL_a4b74a6ca8d74fc492bec7e0a6ab84dc", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c5551cd49aa3480aa484602224f12203": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_069e63a0a00a4016a7a4c9be0842e9ec", + "placeholder": "​", + "style": "IPY_MODEL_8cb04f6989e14865bed858a1892abf6c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c5580939257e44bdb8f9768f2ad70405": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c567fa5d85ee4e64bcd6b4da0a421641": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c56d921398d1480e9c80206949b9c08a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c570c506922040a8ac4330b0c7556f16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c5771d145aa04999a35ff5addd71ed4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d2738e72b7614faf9396c432676ce314", + "placeholder": "​", + "style": "IPY_MODEL_397594d082d14bf5a4030aa2aa120ba8", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c583d56c14f94f08b0b0ce233b3c4ae7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5873f8980424c34acaaf254d9c921bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c590759fc37a4093b3de2d83259a34cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5a7cb8786f3453a9d05e5ddf5c10d6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c5b94bf0783543d8af288140564df66a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5bdec7e08474a1b8a87cb6fd2b68c32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a0d21c0ed3b54eb1a9534d37b9c28e70", + "IPY_MODEL_5d3a54b73c3f40eabf2c9b871c22d410", + "IPY_MODEL_595689788ca64f949c58d7ce46ede92f" + ], + "layout": "IPY_MODEL_be40367d709c4ad9848930f5a776911d" + } + }, + "c5c8f9e3c2d943d0af713ef724e90071": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5e7b33fe7d14ce3a3a1d99d837934a0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5eb1952a28a49bdb987939943b668f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c5f16f6583ca43f3a99d7cf34765ed57": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5fa37861f2749bd89b3a7f017fb92c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5fd885067e749d6aaf115899c68c793": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5ffe939c5664e33b86b850da956d3dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c60526e17b6b41e485827c409a328a1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c614269a9df945e99d8cf4dffab45ddf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c6150c52a5404e0bb3196f8c17a9e579": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_997a74646ea24f0bac09aebdaaf254df", + "max": 3091, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_caff28f1358d40b2995a3729c637a652", + "value": 3091 + } + }, + "c61c7f0f97854497a3cdc76f673b0abc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c61e356f3db6499eaf616b967ae1c890": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c623acf4c31a43b999a097c6c9ae25b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c65c28fd14a449beaf200db6a9e284c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c66cf75f12cb441f8aeac6c020e3262c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6a0f0de1bf841c8884c393e6b06304e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d3e97fa349a04d9da75dbcf6f6a1244e", + "placeholder": "​", + "style": "IPY_MODEL_81596d1078bf447480e1db2ed142a1cf", + "value": " 1.59k/1.59k [00:00<00:00, 6.39kB/s]" + } + }, + "c6a1e83c20a048e4860a6c8fc154efd3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_aeb5f958d51a408387ca30e504e1dbc7", + "IPY_MODEL_7fd36c3cf1c34770a663322eef572e30", + "IPY_MODEL_b287d6f0e12c4bc3a2093ab012779843" + ], + "layout": "IPY_MODEL_fdf8e6870ffa4579b00c22bbe2620249" + } + }, + "c6a1ed2fa5b04cfbb497c5729640fb9e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6a44d40f573407c85757f73ca5bcb99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6b67314d33d4f80be89b7d72ad56da9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e180e5dc5ca745a6b5bece7e91939277", + "placeholder": "​", + "style": "IPY_MODEL_4435594e85874832a7fa374c5cdd9852", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "c6b83f48af614a1c89f335ba38c0cd1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f37afcfe2f34897b3d2053ca4a9ce54", + "placeholder": "​", + "style": "IPY_MODEL_e348d66b67c941c7ade77f3e4ff50be8", + "value": " 1.28k/1.28k [00:00<00:00, 4.77kB/s]" + } + }, + "c6bba8a3b32049eeac5519856d75fe46": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6bd95f5ae76489dba22b8115b42a867": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6c5ade911de4d96951f449465e3f258": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6c75944dfa54067a9e441f8dd1094f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6f48cf55f214ecd86369c1680dc98bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c6fc05bf3b97420b8387aa4e0070b11d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c70253cd65f6442cbbf5254d72b5f261": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_01da0dab91e24917af98d06a45820b10", + "placeholder": "​", + "style": "IPY_MODEL_5549743b07b543a1b1c855324a367257", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "c70a2b1f5e84460791dadb42552b7c4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c70dd4ecd67d4097b935c1f1234ff990": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7156892facc44629bb0399d8adf3529": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c71829aa97cc42f9998a0b51c5b8eaa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c73c975bdd98426e84d00e8023c2bb7a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7415f8e69034c11adbc661d82b25648": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_973d7c138beb45b1929b98e1876ff22d", + "max": 2115, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a49321ea44574436a263208736b52a11", + "value": 2115 + } + }, + "c75adb86248a47499d610ea621ece670": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c77ffae0cf7b4a33a66e2c79d3027ead": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c78ea08c3ebd48cca598e85df08a75f1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c792603372e841f590ef1e34f7b96f6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c583d56c14f94f08b0b0ce233b3c4ae7", + "placeholder": "​", + "style": "IPY_MODEL_ee3b15fac27348a88d0b82367e4572a5", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c794b72e895a4197ad4630b4a6305261": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7b2862db4b54568b981e8d87b6605e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c7c024031bec4a73be1773834cc0f319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ec1420e8b624b1b9cdbba18d1f4b4cd", + "placeholder": "​", + "style": "IPY_MODEL_15129b72af6f478b8a9fa9fcb59e260f", + "value": " 2.19k/2.19k [00:00<00:00, 8.97kB/s]" + } + }, + "c7d3528c02ce4ff684151ede09caf8d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_995e62c504a94235a05526bec728d6b9", + "max": 160274, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_66ca62fb35254c3e963e32110af2192e", + "value": 160274 + } + }, + "c7da89e613fb4b08a96238ac7aa0574a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c7dcff06fa2f41edbc53d69e7f26b369": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6a8f6c3c23d94ede8a0ead126d9d5e72", + "max": 1632, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_db8fc4e2f1a44b4dbfccc5eeeb76c93a", + "value": 1632 + } + }, + "c7dcff929bb64f5bbe4eb42f21e2fc1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0fe5b14c29624c7e96084a1f2f2ee72e", + "placeholder": "​", + "style": "IPY_MODEL_0c2134cbd50a4077bc5d8336d8dc679e", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "c7ddf498565e42bda9e4f5d7c0cef479": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7e2d8f0ece94a9b93a85029d8689f51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7e90fd7f8a040888ba3b9d23a5d871f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7e97a2a55ef464e959c2dccc4bed1dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b8f70251d3ec45229f1219a73e33180f", + "IPY_MODEL_1ab5547c72cb41909b180e198caf0c88", + "IPY_MODEL_d210b7a9c039491b9f6c0dc2682790ea" + ], + "layout": "IPY_MODEL_45051e1d31974b6fb0e467ac10ce3a06" + } + }, + "c7f388b47b714f65856ee75a3787c9cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c80ce5513b01458c95e695336ccec17e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a1f89254da34a10ac8379f86a84006f", + "max": 2437, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9a49fad6fd9a401bbe72ecdc53600952", + "value": 2437 + } + }, + "c8267273c5f344349591e6fe7bce37fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_df310f7b3ba9426fb1ef628f21173a9b", + "placeholder": "​", + "style": "IPY_MODEL_9c3c0293a6e44978bef0e11f4f460b5c", + "value": " 1.92k/1.92k [00:00<00:00, 12.6kB/s]" + } + }, + "c8348697c2354c35b551a457e1a73c4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_95a1cd8f701643bc8fd80f96e6d427bd", + "placeholder": "​", + "style": "IPY_MODEL_c4d1dc2d0e4240b8b8b908b5fc616f26", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "c835facedd774d629c0daa17ac523783": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c83a643bbce24ea89a4a47a3f404cd9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c83d0290a9a54f1b8f92c6327cb7eaa9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c83e1ca6f1314387aa15dc1f416d2b47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dbaa85ceb9b043b9b431a7324c1e910d", + "max": 2412, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5cce75c5b0864cf7b046a3c2fd4df724", + "value": 2412 + } + }, + "c841984e31be49ddbf848d796834f26f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c8541974093a405e8395c2c4640cdd9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c8597f4c79e44ba0aa2bc52679e479f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c86157b3c73a414998f23e6c0508f7c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1ca405bf5b0c4021814623f5afd1267e", + "placeholder": "​", + "style": "IPY_MODEL_1a5e0d59bf9440de850f5172318bf211", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c863724058d64741986f51322d4319ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_282caa93353744cb9d452a3a900e05fb", + "placeholder": "​", + "style": "IPY_MODEL_85bab1c7f5ac442289d5a33a3df3f312", + "value": " 1.90k/1.90k [00:00<00:00, 6.70kB/s]" + } + }, + "c86c380eb83b4f0ab6dbc4df2a084705": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f43bb05bb1e2467ea677416b3c7dc8fa", + "placeholder": "​", + "style": "IPY_MODEL_21b759c31ecc4d0980d395966e2be711", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "c87bde0fa89f4324af8a25d20e76c938": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c87dc2aa0b5f4fd3916ce657b80a4343": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c896042118f547d3b78107822160ca18": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c8a7f5aa666f403391f84606faf7f427": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f32c31282c6a40eca98bb8c597c84e7d", + "placeholder": "​", + "style": "IPY_MODEL_bed7434bdf3e4833bc71893b42a0dd80", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c8b11d29da7b4b53bb2d062c36ef0bef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c8b404eca0674c74a4d140b118489e8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1a5827b00aa542d8bdde30e86b93985a", + "IPY_MODEL_ee457b092ce64cd09fcaabaf7a171132", + "IPY_MODEL_0371ac0d584041f6a8c33817983b2ed9" + ], + "layout": "IPY_MODEL_7d9a49ae500149beb8034f206e29b47c" + } + }, + "c8f2ef5a48474332aa101f4c2bb1a7a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_18929b9d2aed483cb99a48411c60f82d", + "IPY_MODEL_1ec37d32d52c479181427d8c49a91e67", + "IPY_MODEL_77159464773a49c4babc2c72c5bd13e6" + ], + "layout": "IPY_MODEL_b96bc2fa30d2439ab9a9d9b48d4e9b2a" + } + }, + "c900e50227914f2bb9db1c40318feb44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5819a8aaee4c4b18882e3be8725bc5a9", + "IPY_MODEL_2b946063ab7e45adbc813a0adc85158f", + "IPY_MODEL_9527e89f4a70470a9fc9b32996f3f111" + ], + "layout": "IPY_MODEL_1ccb1eb2c476405084193ff4e4bf3ddb" + } + }, + "c901fc79a360401d95d7e5e427aa823b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c90c5085c5ec4bd792350ccc070253c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c919bd8270f14ae7bce0114c4cd62184": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_22782be099e14414a4c615a2ca47ebd2", + "IPY_MODEL_45918d4478d24e7e9004738e38887738", + "IPY_MODEL_27296e3b0b1f4d8a9be49178319e9461" + ], + "layout": "IPY_MODEL_5a96d28d01aa4a969232462b72756f10" + } + }, + "c92455b735b0418c9cd6e5e10c36e59e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f3acf59d433f4799b501037b09eff5f1", + "placeholder": "​", + "style": "IPY_MODEL_8c37ed2c336a4a9f862ca31f11548864", + "value": " 161k/161k [00:00<00:00, 916kB/s]" + } + }, + "c93189251c7d4086b3f1a4cdb9f77e9b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c93dddb837ed4cf7a788d08f28354522": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c949d09fb8e848a78aeccc6171f6600c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c952a796780a4e9b8542ee5be0369cd9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad1b8f9d7950486b84a880546428490b", + "placeholder": "​", + "style": "IPY_MODEL_deab6bf13175467db6e8acaec098035b", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "c96066bfcbe043f4aa6eea66c6fff226": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3e669aca35d54873bc72b0a03f514c3d", + "max": 2886, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6ea49c02074b426199376c0c4a42bf7f", + "value": 2886 + } + }, + "c96515ebcca14702906c983b363468be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d6a8a759da514fb588385848a3d512ee", + "IPY_MODEL_43123af979564fe195009350fe94948d", + "IPY_MODEL_a30c032c5ef7405bb62b9e77812aaf4b" + ], + "layout": "IPY_MODEL_9111d5ef4738417287aa45b65b4f5c8e" + } + }, + "c96747fbfb4d4472bb1d62cd4c0751ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ae92f3922b784d01be2c17a2b477d4aa", + "placeholder": "​", + "style": "IPY_MODEL_f407e40bddd943d08fb8f58bed5a0ff0", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "c97c47fcc62645689f51111088f9f246": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c97eca7ed6204b028c20215b29eceb2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_25c1274f6b354d429aecdc4932b0ce03", + "max": 137277, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_afb5a3ba74734511a1f44cab31c7c95a", + "value": 137277 + } + }, + "c98234cd0f554dc79fb32f705b9b4ea9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c994d17ba781415585b9498a4a4cf1d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c9aac88e8b7c448eb0cb3de46b284f82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c9b1e44685464b9db6414fb2b2a695e1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c9b2e4ea93e347e9a29809bc2434f234": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_16cddd0e52ec463a9c28f3c6caaf11ab", + "IPY_MODEL_c6150c52a5404e0bb3196f8c17a9e579", + "IPY_MODEL_7dcc3afe44e241f29a55bb9c07946ebe" + ], + "layout": "IPY_MODEL_f65025277a0a46029d696e795cbb9267" + } + }, + "c9c6993e5263437988d645e92a22e70d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5e1de30f3ddd42a28604a1ece9f7ddae", + "max": 1537, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7008bc57522c4ff09c04fddd50fa530b", + "value": 1537 + } + }, + "c9c72f7e147248f29fb6addaf425c1c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c9cb89bf13334051902c98a1e74fff5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_268a460f1cb545fba4d22ae97dc1f039", + "max": 146954, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_731768b877c748b9ae5b90c7f02fe7bc", + "value": 146954 + } + }, + "c9de3b1a3b2f465d84bdc26bb9b71790": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c9e4317208bc4423b010657b30da285b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d9c8907cb7844c7fab58585526a836d4", + "placeholder": "​", + "style": "IPY_MODEL_94bb758a893a43bab4cb9f82bf6f9eb0", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "c9fbaef0c4b0473dbe4e519934de6ed9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ca127c8431f04c578552af9b988d8941": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ca13c002c76544a299978e64bdab50b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5c7318815fe2427898e241922059327a", + "placeholder": "​", + "style": "IPY_MODEL_ec46c84b1e534bda8c6b9298c9984839", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ca245600186e4f7baced971a91a17503": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ca36cf37211445008fcc696068773b86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c70dd4ecd67d4097b935c1f1234ff990", + "placeholder": "​", + "style": "IPY_MODEL_b3fba0e16a354f22b940c7181a08d243", + "value": " 1.54k/1.54k [00:00<00:00, 6.66kB/s]" + } + }, + "ca37f584479c44099c55ace2d313f978": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ca3dd5c183dc4b34b017b25f3cf83750": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ca401b39379d4134a068b578d99cb821": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ca4c3aa868c946378a049164f9d30f2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_21e0554943e5403f981c592b6a89a3a7", + "IPY_MODEL_fec787b9c15f4bc3afdd6dd37a018bde", + "IPY_MODEL_10b53a03e27a43faa87a3179a7a87689" + ], + "layout": "IPY_MODEL_383acf4f7c4a4908bdafc74a2b403dd6" + } + }, + "ca61e1813cf247caba37415f5459f85f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b449ddc400014715af7237869e6c5567", + "max": 1780, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f69ef9469c3b4f10b79fc2b81635e220", + "value": 1780 + } + }, + "ca7166c73ced440faf99617cf0e288d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_59985c23f5d14808ae3db618294c2016", + "placeholder": "​", + "style": "IPY_MODEL_c0d3470e31f94eda8c560a6368c3a68b", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ca9580472a8e4ea89ccd5d5a9b283429": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_89bae1fb93124c98ac2a0389d56f4f61", + "max": 1571, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_70fd1b06cf0745e88093c031296ce6af", + "value": 1571 + } + }, + "caa2ebd94bdd473cac086ec402e12b6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a732c0248d2843939b26637e5c385a94", + "IPY_MODEL_1f3be65e2d014cedb87d1bf264b37735", + "IPY_MODEL_6892e2538365410a8242cf658fecbf70" + ], + "layout": "IPY_MODEL_002c3b704a86437c8966b319145cd7dd" + } + }, + "caa6010721ec4473a6c0db3f4761f59e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cab0659d8f6b497b82d081908eda3cd3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cabf215ae0474c86b210fc9ab717f296": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cac3f95654bb44099151e8fbd1961563": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cad0e5ebe1ba47b1bb1d2087ec579fa6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cae27f673c7a4a46ac0bce77f93b454c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a64c2127a0e478ba4366d1accca11ea", + "placeholder": "​", + "style": "IPY_MODEL_f563428b3b7247a99b348e31fe7a7494", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "caff28f1358d40b2995a3729c637a652": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cb0a5ac17b95490bb2450a1a5308d06d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_979dde537ac942afa423bebef7139811", + "max": 3431, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fc41f7f8d8ea41a69f5b1a3bd163166a", + "value": 3431 + } + }, + "cb1474c42a1146589780c70eff7d59d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1d8379c3c5de4eb1a361209a7a30d2a2", + "placeholder": "​", + "style": "IPY_MODEL_2028362fbd3e4b7290f69218dee78a84", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "cb311f0ae36f40a09b342be157e6c979": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0125c239fc174223acec4bb677d868b7", + "IPY_MODEL_366b2659634249a1bbac4a6b3f08b536", + "IPY_MODEL_d4985234898047aebd8809164ff81acc" + ], + "layout": "IPY_MODEL_61af5b7c652b4dbf9c5156eb12898c81" + } + }, + "cb465eebf9fa4b0bbf068155625c1f7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cb51bbb510b7481e9d073979c8d88687": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6d52eec42efb4a779b9b4c4435f82759", + "placeholder": "​", + "style": "IPY_MODEL_30b5325eb02d43dbb5c99e253bdf450c", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "cb5376bad63c429fa24961a5c585e8fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb5d676255544cb6be8b0ceecc8d47c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb687ea1b5d34f0da0e79667f19fe48d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c9b1e44685464b9db6414fb2b2a695e1", + "max": 3612, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_998610555d474d9cb1735592bbfeb035", + "value": 3612 + } + }, + "cb699ef843914f58b7250ed8ba718de4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba06006190c84c2eb1ad1da547509a3a", + "placeholder": "​", + "style": "IPY_MODEL_6de25f0085d048eeb3f5c2d5c7f76c1a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "cb734c170b1547a38f5c33fb55f3c172": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_936e6e3e12cf47dc8bfb4ce22e8a400b", + "max": 2499, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4c2b0057d8694f65a198a96327c953fa", + "value": 2499 + } + }, + "cb7a6b4c465d43f4b26ee95741aed6df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb7ad53d65454658a5f3384dfa739efa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cb8853f2ee704ada94741acecb905f91": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb909adcf50b444c92900ad1c9287a87": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb94a5d2b2ab4830a641e0950c2f0552": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb96ece3c1bd401498759cf125e99c54": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb9a9059e0724caf9bb16c46fb7b7410": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cbba9078289f4cf984823ccac354dd7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e6a93481a3a243f29dc2293be877daa4", + "max": 2388, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_13f32eed7e2a46a7ac6e614d70b206cf", + "value": 2388 + } + }, + "cbc364a8cd1a4e5c814a2db329c4c446": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cbd20dd0898d43ef8d4411306a7a227f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cc01261a4ede48dca4fe7cc1a2bd4e10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2b32497264b1410a8e207b47dcb1d95d", + "placeholder": "​", + "style": "IPY_MODEL_c570c506922040a8ac4330b0c7556f16", + "value": " 3.79k/3.79k [00:00<00:00, 17.6kB/s]" + } + }, + "cc083d0afa6c405fae5e8aae709ddfc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d76f16b36e7542918a7bbd13e130a591", + "max": 145815, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a10f7238878e4def920217070b5b5393", + "value": 145815 + } + }, + "cc0abc38b4c04034971b230a90d24e5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cc20fc6519d84f39aeeb0d5693019563": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cc3766fb4e1041dea9679e6672f17622": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cc3b6f81df554c14a6be3888affb0af4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cc4027875b7a4e74a4074c6a5c00905a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6b17552b0f68420db3b5d8712297e035", + "max": 893, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cf758c1b22f449d190f287d784f951ae", + "value": 893 + } + }, + "cc46b45979df4d5584efabe5ddb2c65c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cc54925a9f1c4ff697a629e797357f31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ff943dccaf404c2f952170598cb4f258", + "placeholder": "​", + "style": "IPY_MODEL_6bbbd40b98454bd8a689268fd4b80b04", + "value": " 2.42k/2.42k [00:00<00:00, 11.1kB/s]" + } + }, + "cc855260b4f34f41b8d9d0dbc0062d0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4a3fd0e8f5b447329efd14db2642bc2b", + "IPY_MODEL_bba3beeef2244558b4a605f35ea4a741", + "IPY_MODEL_b6d9067231fe4020909b1ddc0e3c448a" + ], + "layout": "IPY_MODEL_7e341ab3c084491cabc4ac7d3c47ead4" + } + }, + "cc8a5f5b8e2843aca6bb76c912a1b2a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cca151cf00694cd18299b072ea55d66a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7933eb2238024efe9c6395f5ed48faeb", + "placeholder": "​", + "style": "IPY_MODEL_e3b39ae261f44490b254f0b04793d172", + "value": " 2.49k/2.49k [00:00<00:00, 15.7kB/s]" + } + }, + "ccae6fa6959941388bebe42ec4987923": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ccb309bb29744c109375491b802c15a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_45efbd54be8d48a7b7a31837caadfc1c", + "placeholder": "​", + "style": "IPY_MODEL_d00b84bf45df49bf8a2dbc4942455c00", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ccbfacda857948c0b4f09d3df3322245": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_35cb4a907ad94715820b0203e479ca84", + "max": 3379, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4ed995bd19744b4d95d68a454333b2ba", + "value": 3379 + } + }, + "ccc45185b7344187b888110d97de25a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ccca8768d22948d1bbfcc5ed06ad0d7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ccd4c67781a34a3f93c902e4a68dde4c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ccdc1916eb784768a4d81f6821d5f356": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d177877399ce45c6b8cde4eaeb727bea", + "max": 2720, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a1d534aed79648adb219f8dede0a5afd", + "value": 2720 + } + }, + "cce19dad79874b8fb65f9f3fda418dc8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cce9727cd4f74ff68aa2c89bf17400c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ccecb63f36be400f9736a4182e55bc8a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ccf8f612bf244ef5833c3253db6daa82": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd0feecdb4224b43940eda034ca2693d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd232763b3134435b768f541be1c28f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cd2617817afb49b5a012f489b0371e69": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd2f28a173d24b8f9cf464ad0f25e5d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b02421447534ae79697cb6516c8b736", + "placeholder": "​", + "style": "IPY_MODEL_0a00d897c63b4e00b5f174c0e575e93c", + "value": " 935/935 [00:00<00:00, 4.60kB/s]" + } + }, + "cd3946450a324ad6b93fc81c7cfb7175": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd557ddb18fe407cbea3e040deadaf42": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd587eb0243b48ec8806f40e8140f228": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd5a8e8333a04b58afe5907f51a82555": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a44594f22b004a899466afb32e7e2304", + "IPY_MODEL_2627b23cf6fa4383a2f55400030e0469", + "IPY_MODEL_014b23a00e6f428491cba865604ff46a" + ], + "layout": "IPY_MODEL_ca3dd5c183dc4b34b017b25f3cf83750" + } + }, + "cd60ca7e71e54497926001bf87e757f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd826ad130c44cf09ea99dcc76ca86e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1fd598b71dc5470d884e21af866af101", + "IPY_MODEL_cd9515b3c83146a0a452d3ed26aa4edc", + "IPY_MODEL_2b79dc19cd2c4d5ab6c94cdd776d78e1" + ], + "layout": "IPY_MODEL_a246b909fc0c4d4b823229dec7efa4ae" + } + }, + "cd8c4982cf254353b7ccdac836cf4275": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cd93205d72674fa39c85b18eadac6816": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd9515b3c83146a0a452d3ed26aa4edc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e535c5e7c89d4741bd869dd43f96096f", + "max": 2102, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_728a7dce1de34c139acd19513aadc8ed", + "value": 2102 + } + }, + "cd95f6c3488a4b908f9e34a740f2eb0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cdaf6e1fbf5d46d880b651d7d4ec8538": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_22b1cd4dceb24ee6bacfdaa6c427d395", + "placeholder": "​", + "style": "IPY_MODEL_315b8e7898e841ee8f3282047776acc5", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "cdc40c0f19294fc3aa0a42503b402cb0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_25c9c21dfb6e41e7a1b28f1e1c527e25", + "placeholder": "​", + "style": "IPY_MODEL_4986fa3df0ea4c60a3bc344044720b44", + "value": " 145k/145k [00:00<00:00, 669kB/s]" + } + }, + "cdc5211ce9d94995abb8879405746904": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1629020a95e84495bae6c9142567cd8d", + "placeholder": "​", + "style": "IPY_MODEL_1d1b145fd5ee4894865ba15bc1791845", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "cdc6999fd92846bcb4713fd6769f94cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cded2235eefc4e579efe5fda26667253": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0ae625615547449d93713980ea0d26e0", + "placeholder": "​", + "style": "IPY_MODEL_8f31392dcd0140b8b729c9fc3fd664ad", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "ce06dde519414a5f87a6fc0f9e4f6ba1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ce08a6817ef54cabbf210ee909e2f2af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce0ba92e50384a2cb33e8cb3d2b3608d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ce14866c3ead43c1addd4c77d46d004c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cdc5211ce9d94995abb8879405746904", + "IPY_MODEL_068044c6658049d6b614b4e9a4bf7e04", + "IPY_MODEL_b34fe0603a1f4c02874da6449327920f" + ], + "layout": "IPY_MODEL_50c6b777f30f4795aabb33dd79f6c56f" + } + }, + "ce176c4434164e659fec84666574ac80": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce2d235e06e74c799c54ab59ab82d431": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce31eb91e42d466086f152eafb08560d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ce36c6f6935640ca84a3ef86c33af3fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_75588186399a4276bef1133904e0ead3", + "IPY_MODEL_4b1dd1a136b54ffab95dea189d09352e", + "IPY_MODEL_8a942bf0a5824b0c88f65e6e855ff907" + ], + "layout": "IPY_MODEL_9c1e926ab35a41e985743cb64c7aaaef" + } + }, + "ce432f32652c404395d10836b9f912be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce486005dbe340a59a1db2e9a7f4bb3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c8b11d29da7b4b53bb2d062c36ef0bef", + "placeholder": "​", + "style": "IPY_MODEL_67145440b5c645a09e521b006308443b", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ce4ef0f5a7ff4bed9d9d8b3134301cd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0a4f51ed635845a9898bf10ce22dfeec", + "max": 2253, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_989ff5a668f8463584fd4dcea6db98db", + "value": 2253 + } + }, + "ce52228411864d4cb04087770e4da493": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce62dd489ab14bd282712c24a64f300f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ce68f59ca7574579848a01e2e1ccfb96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1cef7843877747958ce01ec9a8aab266", + "IPY_MODEL_a27891c4f6f94ad5a1b4a4f2f1f53786", + "IPY_MODEL_dbadd2683e414e54bf131c4d6fa11406" + ], + "layout": "IPY_MODEL_3f5b507fdea54d2b81c4b1758338772f" + } + }, + "ce7018edd3ce44d8bdc9fb38319dff9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ef3aeb961663495fbd207b5757db6343", + "placeholder": "​", + "style": "IPY_MODEL_d1c1013073ca405388899bf963ded9de", + "value": " 2.07k/2.07k [00:00<00:00, 11.3kB/s]" + } + }, + "ce745b09329248399a765025b75c643f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ce775da2cb8d4cc3a8ec3138876ab68d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_674fdcdb0c88452d86b0c256a0f674b4", + "placeholder": "​", + "style": "IPY_MODEL_2d01c9607e73479188aeb5e2ea0a696e", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ce7f5b0643464ddfac992f595329723b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce925091733c49049f696828bdc83070": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ce939c5e58eb4a12b9be042028be662f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5ca7bb7fff6f421fa3b5f92dd46edf68", + "placeholder": "​", + "style": "IPY_MODEL_7738fb82cb004ab887d7ee39505f372a", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "cea15cd46db54d4797d05d9c7eb185fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cea631b1e43a4311af460178a190ed2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f15e0f9665e645ed84e37f64b7b491d2", + "placeholder": "​", + "style": "IPY_MODEL_9888fd84cdd1468c93eb6758b7aeb523", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ceb5edaf93fe4ab786ec99e8632b129a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9db51721964b4d19901b61a3e1d32e66", + "placeholder": "​", + "style": "IPY_MODEL_54a4e71297384adca75c0ceb1eebb9a4", + "value": " 145k/145k [00:00<00:00, 1.06MB/s]" + } + }, + "cec3c832bf3d452fb29f2a98610e108e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ceca50bd3c434f418d09e43b81924879": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cecc508fc930433886c3c49af458b433": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ceccd55dc2124f619637fffaa35f379f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cecf7c866d044eaa9647d5a5b1d1a29d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c98234cd0f554dc79fb32f705b9b4ea9", + "max": 1905, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fd67f25388fc48feaa28eb5df9a04c36", + "value": 1905 + } + }, + "cee77b29e5c242b3aaab8e503bdb1abb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cee7b93894614e798f6469539401f8c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_423e8c411d3f40d99c168e3b9d4db274", + "max": 3369, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_598d7fe487c447cc94c9be4e963cfd4f", + "value": 3369 + } + }, + "cef605e1bc6b44c3a36af2512d0770b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cf04531926f848188d4fe5e4e03f0c5d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf0f23f206e3445c99d665846c02a5fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_472e3fc5de534e3fa2e503379882d5b1", + "placeholder": "​", + "style": "IPY_MODEL_9edd4e2e8e984a5e995a2812680b2649", + "value": " 145k/145k [00:00<00:00, 569kB/s]" + } + }, + "cf1f454dc1e94365be7bf9221084a7c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c5f16f6583ca43f3a99d7cf34765ed57", + "max": 3400, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_de8ddb31de4f4432bf61ad8aefeaad7d", + "value": 3400 + } + }, + "cf2a46ac1ebe4339a139117f2b42dec2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f307e2f6478b4fc789004976ffe32f4c", + "IPY_MODEL_c5278bc3d2ca49638527682fecace4e9", + "IPY_MODEL_cca151cf00694cd18299b072ea55d66a" + ], + "layout": "IPY_MODEL_21a3e1707154403c9e48b60244eecd51" + } + }, + "cf4e9bfcd2c041deb173a4195a22453e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fb8d79a8e0b04b36b0cdd643ab9254ee", + "placeholder": "​", + "style": "IPY_MODEL_dae01322124c43078ce9c276bde9e7bd", + "value": " 1.96k/1.96k [00:00<00:00, 7.46kB/s]" + } + }, + "cf4feaee0b9d470eaaf9a1e4411266dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a317a3dec94944f08050518d31f07858", + "IPY_MODEL_197701851a114dcca2368d1d30142058", + "IPY_MODEL_d9fa15aaef1547ebb3fe7052f276b165" + ], + "layout": "IPY_MODEL_b666b28931334e678c8b2697e71e8083" + } + }, + "cf58057d0a034c4490264ce8e98372ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cf5a1406c5a34c1fa0925eef8de83c69": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf65342324874e23ae647d1903f048fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cf6594f705a84902b05d325f85b7a573": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cf68f5c3b9ec464b94062bdb586b889b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf714f31bf274847bbea87b92085aeff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf758c1b22f449d190f287d784f951ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cf8e5847d3ff4662865a01b63b869243": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cfaf1f68cc1a48f6b9c20b6459ea9b37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cfb817849dbe4efdb9f8341a2ad402ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c78ea08c3ebd48cca598e85df08a75f1", + "max": 6148, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0104c6ba97754a46a99fe06a6e6f88bc", + "value": 6148 + } + }, + "cff76d4a2fa64f0bae9c0e04ea38a3b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d00b84bf45df49bf8a2dbc4942455c00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d00fa9dae0ab4bb0b2e25f4bd07e11bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d01f7c4c191e4edfaf5bafe992c996af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_26175bd407004f1684f00f22bf88106d", + "IPY_MODEL_8978fe8657a64ea5abcf75abf14aee2d", + "IPY_MODEL_1a426fc388744824b68d86e594ae2eed" + ], + "layout": "IPY_MODEL_d4d948480f434c7ebd581e3162378f2e" + } + }, + "d0405631405f42eea78c4c6d892c4ee5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d9be92e4a9c4524a6b74c50f062682d", + "max": 1600, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7925d5dceadf42a5a29af6f3979e393c", + "value": 1600 + } + }, + "d05f88809b824d43813a6ca695043035": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ceca50bd3c434f418d09e43b81924879", + "max": 145749, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e103e8f1e3554c1cab49f6d54ee6c7f6", + "value": 145749 + } + }, + "d06840deb3eb4c219b464a10500579bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ce176c4434164e659fec84666574ac80", + "max": 1964, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_13e761ff03d24deeafe189f1757d47b6", + "value": 1964 + } + }, + "d075453ed9fe422d99e3a736bf5c0a15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d5562ed23a114aadb06bc25034ac17e4", + "max": 1767, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7dc6a715f9c6467abdce237373511692", + "value": 1767 + } + }, + "d0801a77bfc548d2adef21577c4ed7a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_92f31bc1769b42c8b9b4d371f62234e4", + "placeholder": "​", + "style": "IPY_MODEL_b37be9d7503e43458715ee9668753803", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d080400dce6e4604a48010bf8c6e2962": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d085833ae2ed429d9e588dd512b42d00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d09389a2ecf041d3818238008e80215c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d0ab4ad19b904923b7565504355ade78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_31ea8a97fb354507907fa43f89d4fcc4", + "placeholder": "​", + "style": "IPY_MODEL_510e96bf54c3442ab231aab7b8ceb767", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "d0ad8fb873a142d88e5886a48839a8c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f60808158b04da5a52f67d7a4fb929c", + "placeholder": "​", + "style": "IPY_MODEL_b97bdb7dadd64688b11e90b91a0ec7fc", + "value": " 2.81k/2.81k [00:00<00:00, 10.4kB/s]" + } + }, + "d0b641c72e6e4624bf25713c71c66a8a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0b9e56f256a4a1ab6df79243c236308": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d0ce5632a9c649b9b1afd2f378f81c83": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0f0804e62ce43ad933e87f71dea17d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0f5bacb12d24c0db1f87b2fdac2a78f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d10106ef402045efab7c530edaea65cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d117778017cf49ca959c91daca677c84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d11de86c48bc422dade29737e90a7f54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d121308bda2c4b48ba790d78f1456d6a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d1284fa44f114d7c85d3cb3ade21dabe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_87a7ba046c3e4f35b5b03bd4a17f61d6", + "placeholder": "​", + "style": "IPY_MODEL_c4e4f530bb884842964e08bf5006843a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d1334f08bbfb4d9da2dcc4a1188c8107": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4df2babcacf543a4bafdfe423bc0ab64", + "placeholder": "​", + "style": "IPY_MODEL_ab69e778e40e45f2a0cc9ec05607e775", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d1463a44292e48e99a710141a1fcc7b2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d147e8ca162041158a745954cea654aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d14d0cc426814ddfa449391f5bbac10a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d14f5a07b62841db926213d91a7d08bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eef85cc094024d30ad0a7de80ccc53b4", + "placeholder": "​", + "style": "IPY_MODEL_a5442f1d91404aa8a1c5729959b1b78a", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "d161dd30c81049958a9a7eba84f4634f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b285f6af8b24e75b975ce0c9b8b123b", + "placeholder": "​", + "style": "IPY_MODEL_5b5aa0ded13c4fcc819b8bc093bf128f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d17644a9931c4f58960c59c419bc5415": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d177877399ce45c6b8cde4eaeb727bea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d18243d711ea476d96d6dd3a0cf4bf5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4e69ffe0ad4d44778fb29be4531e9fa4", + "max": 2768, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_17207df0a55c43d08c88a74cad9aba26", + "value": 2768 + } + }, + "d18904f9840940d096745c611ceef186": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d1964f3928684dc29fdbc733231071ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_048c01d5b8a64e9694c7b892ddeb6204", + "placeholder": "​", + "style": "IPY_MODEL_d5b7267ae8a743599e8a5ee01c31a1cf", + "value": " 2.99k/2.99k [00:00<00:00, 14.6kB/s]" + } + }, + "d198fc60fd8e4d9c9f79bcd7db99dc78": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d19fdcaf3445439d9489079f609e0649": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d1ae94393e0f4baf95e7de1238b97955": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d1b4c13f70fb48ed9951c0ec1746e189": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d1ba3f91d3314e57a0665e7ebc97d73a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_308c9ca0ae8e427e88ab81f3fd3bde52", + "placeholder": "​", + "style": "IPY_MODEL_17c24ef4d2594af08c19c82562fb676d", + "value": " 2.12k/2.12k [00:00<00:00, 8.08kB/s]" + } + }, + "d1c1013073ca405388899bf963ded9de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d1edb52dd2ba463dbf8a20f31fdfc6ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_700a1c6943ae4f5f96b93773151642a9", + "IPY_MODEL_f16c678ef24245579a2bb067591661dd", + "IPY_MODEL_01d35f7f44cc47f7ab08b2f5de78615a" + ], + "layout": "IPY_MODEL_8c6cc91b64f341f0ba4f3497a1ee05d2" + } + }, + "d1ff791cd051406f976c47eb32a7e34c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d209f6e7c21e403a99cd2b90940f475b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_97ebc4e559654238866b044ca7f88b5d", + "max": 2882, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4ca372abda9049ddbb85ba8f356a5925", + "value": 2882 + } + }, + "d210b7a9c039491b9f6c0dc2682790ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6893aaed7c2a413aac9c6dd97f26c46a", + "placeholder": "​", + "style": "IPY_MODEL_8f438a5a09214277abde6a013bbe1d5a", + "value": " 1.48k/1.48k [00:00<00:00, 7.94kB/s]" + } + }, + "d213346f2edd4d7f984ee7dbce71c906": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6c31124106fe46849ff1c67d970c2e15", + "max": 1611, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6d11d3f316cc46f88289ef87d6478bce", + "value": 1611 + } + }, + "d21f6dd0c4e947dea7ccfe2e895effbb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d23e4120db2141708ed8a84ca30ffb9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d24ca3cc2e3a4480bcafa2b1836947a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d253eb92e95340e496034142f14a8cce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d262cddadcc442d7994598a7f7a2648a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d266bcd201f3492daaf990ca77c8cd45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_33ff7fe45e2a47329cb12ef9ac249df4", + "max": 142011, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_325d6ff893a24d28bb361732dd77e157", + "value": 142011 + } + }, + "d2738e72b7614faf9396c432676ce314": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d2767986dbfb4ba1a5b63600fe2ca96e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a8ab7cd536ce4a5ead62b59e69bb5945", + "IPY_MODEL_70c2eb47a4f64ff8b2a1707b89b9d78e", + "IPY_MODEL_82ff4a7e2d054626bb9524035c2d03ed" + ], + "layout": "IPY_MODEL_372705c704964458a65732e506cec9b8" + } + }, + "d276e62ebbeb46deb8be6990e53e11ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d28b9098969742b293eff836ef84f8b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_18cb15ddfb524b1d82011977eb6b25ac", + "placeholder": "​", + "style": "IPY_MODEL_654d3e75185c449788c666cdb7dda252", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d2a626b99e964bd6b3d57d3d96ae4a1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d2b1fd42d62b42489bdefe9ff00c8b49": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d2b4370c7538435faddcc9cb4dcc7ab0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5afdad692f22438baf0c32de49108f16", + "IPY_MODEL_17f1ffc7a70146ed87363cfdd6251a61", + "IPY_MODEL_012989338b0d45288ac27e53b7cc6e5f" + ], + "layout": "IPY_MODEL_d00fa9dae0ab4bb0b2e25f4bd07e11bd" + } + }, + "d2d678d891b4456991b5d74227dd37e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d2e439fc631a45fbbc484d2c5e168d4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d2e45d8be17349268176e3b39a30387a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d2f24be24b00462eb9ec032237656aa6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f0eb4659ed924d29bd570ae7940cc743", + "placeholder": "​", + "style": "IPY_MODEL_c6f48cf55f214ecd86369c1680dc98bd", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "d302064d0f1f4a5aaf74ae5225dcedba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9295716322b940bfa1cbf1920fc2d384", + "placeholder": "​", + "style": "IPY_MODEL_8897bf1b444b4a8387118b18a8c98f83", + "value": " 144k/144k [00:00<00:00, 373kB/s]" + } + }, + "d30250e52d914046a7c0ed9b05016490": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_afd2809614f14c7c934e4b9571a35610", + "IPY_MODEL_8b237999d31347ed9d2db43e8f0bb5f8", + "IPY_MODEL_62937a230f5b4133995f742b5b64df87" + ], + "layout": "IPY_MODEL_cd557ddb18fe407cbea3e040deadaf42" + } + }, + "d32abf7f0ed745928969370612856ef5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d32eef1d67374892be8ef54bd0d6434b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d32f7fa974234068a016255aa1b7d2e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d3510d3e1b7a479facebb4e52ae9c544": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_387d35969ed745c4b70abb3ffa436666", + "placeholder": "​", + "style": "IPY_MODEL_5adce2e795b24325ad49b710e0a33449", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d35eeedebbf442f1a8be699bbc580b1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d363108cbdb54ecf89eb39296f4321db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1f3fdb74456441db87b9bc9a8e60f2b8", + "max": 2234, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4a32b74086534fc188d53de257185bea", + "value": 2234 + } + }, + "d36c2747605844fcaee17b3004b5b43c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_509a9e60d0d9479f8dd0419139d92789", + "placeholder": "​", + "style": "IPY_MODEL_42428ab14a624fae98b65937aa0ea4a5", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d37c0b78a1e440f184ebba8e948cc2d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f2c0fa1c90204130a1721f26ac0a7db3", + "placeholder": "​", + "style": "IPY_MODEL_655c34bf80394282bd54721ef2b4d7e0", + "value": " 2.44k/2.44k [00:00<00:00, 21.0kB/s]" + } + }, + "d37c1e8b356e498288ea1638232abd34": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d3af9be9ad27414e8008f571cf3ebf79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_670e16768f8b4bc9ac6f1961cade05b1", + "placeholder": "​", + "style": "IPY_MODEL_d56f635b95f246419a4cecbecacc9387", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "d3b5967279e8497b9edc9012143c424c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00e1088676374c2386aff9b6da6f96e7", + "placeholder": "​", + "style": "IPY_MODEL_428d5839d2f0455481448c2278ce0bb0", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d3be718e9bbf48f59ee4849f54df704a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d3c30112a6404d3d923dd494370b9bae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3af9d3fc4ea4467b90da091b80e7ef87", + "placeholder": "​", + "style": "IPY_MODEL_16c06221474144558cd8fcd720d4f16d", + "value": " 1.49k/1.49k [00:00<00:00, 12.6kB/s]" + } + }, + "d3d524db77ba48f6be0852305cf1b458": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d3d5c2205dc742afba4054f2a1b68cd3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d3e337bbf6d9488abc7f74cec7e9f2ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_77e4c526c8b843e5a9a1cfdf351b18bd", + "IPY_MODEL_a04696080efa4d559d979850e0df0099", + "IPY_MODEL_988013979fe64b25933544bb25131efa" + ], + "layout": "IPY_MODEL_ceccd55dc2124f619637fffaa35f379f" + } + }, + "d3e97fa349a04d9da75dbcf6f6a1244e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d429fd2732ae4a73a27d895af5be480b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d440c497c97d4788a75a8d0cfe34ea67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ff42df4b5e74285945d7a2db9631c92", + "placeholder": "​", + "style": "IPY_MODEL_662a7fcbedc84beebde9eeacac2ea9aa", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "d441e4b6fe8c41d1a4ecef83b38ce374": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d442acd44f6d4fe695b5144915f6e41a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d444597519ee48f4adc99e2328c76217": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7118be5d336742708e524cf7687a18eb", + "max": 1421, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5c8c4f8e307d4f918e25ff4cd2a32570", + "value": 1421 + } + }, + "d452c3340473448688d6d4c35ab4d1ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d464fa16a30f4552ba234466d4112267": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a054d4acf434761808a4937e123efc0", + "placeholder": "​", + "style": "IPY_MODEL_2ee9236490b34d2b8a5341a8bfcdba0b", + "value": " 2.77k/2.77k [00:00<00:00, 17.6kB/s]" + } + }, + "d466ff71e3284ed0ad4bb17e15d02f6c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d46d0b45d75d42ae80fb0934df94839f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_83e117c0bb4448e6af42a8331a8fc197", + "placeholder": "​", + "style": "IPY_MODEL_18b00497179a4eadbbf1fea82b9db639", + "value": " 1.79k/1.79k [00:00<00:00, 9.07kB/s]" + } + }, + "d48d0e6491c844268ab8deaed270279b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d4968b7af0e042a99eaf6f35ea29d629": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_afd51824b65c4af7b09b5a5fd61041e5", + "max": 2008, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_989a922a017b41c8b7cae6618980c845", + "value": 2008 + } + }, + "d4985234898047aebd8809164ff81acc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7414155e2886401cb1a3eea5c77b3393", + "placeholder": "​", + "style": "IPY_MODEL_240477e06c1441d7a61d6a5ad7b98b87", + "value": " 2.11k/2.11k [00:00<00:00, 10.2kB/s]" + } + }, + "d4a340f6d7ce47f2a3a39d1ebacc0adb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d4a89c25b37a4de387641810dcb7591a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d4aae0c8bb8b474ab66c6fd8e119bd9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_837a00ff5d7a48659990b369a9666ddb", + "placeholder": "​", + "style": "IPY_MODEL_874c585cea7d4b32a1e8793027906d07", + "value": " 1.78k/1.78k [00:00<00:00, 8.78kB/s]" + } + }, + "d4b84cea652847cc952b26fb4aa89186": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_862f8e4fc5484d2da771f88b4f6c3559", + "placeholder": "​", + "style": "IPY_MODEL_e8555a5be08e4b478ef1f68f0cbd438f", + "value": " 3.11k/3.11k [00:00<00:00, 14.0kB/s]" + } + }, + "d4ba3cb42cda4bd2a56aaf788e798901": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4b1e4c4e96d340b48fd0f866a0d4b884", + "IPY_MODEL_7e4eb7d314174c70b74b3d03cc81dbb5", + "IPY_MODEL_f3697558905c464dacc82f384fde10a2" + ], + "layout": "IPY_MODEL_c6c5ade911de4d96951f449465e3f258" + } + }, + "d4bde992e9b74d1a9ceb388ef3304963": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b2eb392907d94ef889512f7da56cafc8", + "placeholder": "​", + "style": "IPY_MODEL_0b82ee4e0bc84f60afee0e9780b3e8fd", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "d4c3fe1a3cdb4c1eaf96880e22504529": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d4cbdfde9b974fea82dff073024389f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_43c6a5c6fb234c388305e7dc66303854", + "IPY_MODEL_a32932d55c3a4c23bd69669f49d0bf67", + "IPY_MODEL_fa4032a61dbd4f16b4a367a5ac75f5c6" + ], + "layout": "IPY_MODEL_470e97a1d0e347e5a7f639c706d97afb" + } + }, + "d4cbf7b34bc44d85a82bc4c3b52fd6fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d4cccea318f34c43ba23bd7c40fe2f88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d4d1e8e45b354055ac38af9904f4fdc7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d4d948480f434c7ebd581e3162378f2e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d4ed6ec091f6478fb4401c8c52281ddd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d4f3deeaa5324f93aaeab30f2f05da61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d4fea78b98b84dbbbcbd40d5726c9b5f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d50257c1f5d0427dae7b2fe8a4fe88c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f7abde07763948c4bfb6ac22bc315396", + "placeholder": "​", + "style": "IPY_MODEL_2677204dc7364e668c87a0a0aa6c0a48", + "value": " 2.88k/2.88k [00:00<00:00, 14.8kB/s]" + } + }, + "d5113127f8ad4a6fb2488ee504a25dbe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5431356f56241e5bf80fbc688c41f73": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d54495aabf234fd1935b4ed3a5193d3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d54be3e6e32841e9a5473596cae59c75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d5562ed23a114aadb06bc25034ac17e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d557682ad0ce4c27b548d2180bcd1c4b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d56c8ec4fd58428fa7d0640dd5574dcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d56f635b95f246419a4cecbecacc9387": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d5833b120b314f8a98924a8cb27868ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_15f2d48096af45d9b769a50b6a4ab578", + "IPY_MODEL_c7415f8e69034c11adbc661d82b25648", + "IPY_MODEL_d1ba3f91d3314e57a0665e7ebc97d73a" + ], + "layout": "IPY_MODEL_0b57285b70364fd19c5bc75cc375134c" + } + }, + "d5af685d1ab44c68a579163759ac04e5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5b7267ae8a743599e8a5ee01c31a1cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d5ca6ac4b8314c7db61bc4ebd23650cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5ea69a6aab042f6af76551310d6ab8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_95d4ce53218a4ef79283c20926fae78b", + "max": 1205, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_777f681b6f474921a3b73e8d10106cea", + "value": 1205 + } + }, + "d602b09472534aa48a0d94b04d079cdf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_373ae998d515477dabe1eb536dd58624", + "IPY_MODEL_ae83e4a09ef64e2bb11c45af559bf330", + "IPY_MODEL_9534a63875e242f1b2b13af0b31816d7" + ], + "layout": "IPY_MODEL_da3861baed744d34a53f61011f4fe75e" + } + }, + "d617ddbd4cde4902ab416968878981e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d6199ab758264d16af5b3e1ded35b173": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d6199c19fadb446bba3d7ede3aa916b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d621bfa2510b478598c3fd4ef7a947f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d62f67a4fb844ede957243419fdf9e1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ef22120b94db49318db350f6178cd35c", + "IPY_MODEL_8326e2b9bc944b0caf80efe0d50ba919", + "IPY_MODEL_5f3a422f97ed48388bd3745ba5bca476" + ], + "layout": "IPY_MODEL_0a51bcd8039f429b9003cd2804ed76ad" + } + }, + "d63273f594814fb3aff95df413c338ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d63cdad1d350479599cecd0c72944e0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d63e8b07d7c543b4bf4f85bfd010cbf3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d648fd15283b47ff882c151408a5ded1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d655eee7f0ed44988ac7d918f962985b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d65d2bf8a99847199d53c43e16c46d20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_11a89851f2814f939dafc786864b03ae", + "IPY_MODEL_c156f220afd542d0a75f5f6d1e5411e7", + "IPY_MODEL_2f932d6b4f10499ca7c2bfff0f38c4f1" + ], + "layout": "IPY_MODEL_ccd4c67781a34a3f93c902e4a68dde4c" + } + }, + "d65f89e55c0948109bf37335f499cc80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d6797e8299584b68894e67601ac431f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d69cf204b3684821a597b8aebeb7e5fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d6a73739aea745f898b25fa0c271efd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f9255e6ce5e40c39eb801752197a771", + "placeholder": "​", + "style": "IPY_MODEL_071d42de9043414ebfc3d7de9a5ac10c", + "value": " 2.41k/2.41k [00:00<00:00, 9.39kB/s]" + } + }, + "d6a8a759da514fb588385848a3d512ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_24f0f03c9ed543f8817f7bcc76737caa", + "placeholder": "​", + "style": "IPY_MODEL_4fd71fcecbc74b8bb53f122f838c793e", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "d6b4b9872384434b85f67d1f3b7dafc8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d6ca1b792f674c81a6a8a30dbfb66e24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d6da603baddc4c3bbcbba0db6d7afd7e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d6e8730caa2248238e2cac6765950b34": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d6e8b7b419a640b8947e9b05e6f251e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d6ef07639e8f4d3388ee95c58eed40cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d6f31f58b4a446299159c27299535d80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d6f53b2b7a884e9e99aa12878fb758f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d6fec610c3224c419d2694869b0a6f10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_236a2d0ab9cf4eafaa1eb35f54920bc0", + "IPY_MODEL_552c3f2d03b241bcbdb1f11c7afdd287", + "IPY_MODEL_31f8516600844de38d00806d681ec637" + ], + "layout": "IPY_MODEL_2132b6d5a15f4d89881cbb394bfe80c1" + } + }, + "d7082d2746c74767bf35c618caff15b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d70a783115c4448e9222d9eede0471b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d71b1be9b7794ef8b9465cc02f44316c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d71e896e26a94d7781b9c3193e2241ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d73bcff2a617473393b7670f91b0defa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d746aa10e0be4dd39e9efc21fb70d6b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d75ddc5a511549d6b0bf969e54750bbe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d71e896e26a94d7781b9c3193e2241ae", + "placeholder": "​", + "style": "IPY_MODEL_75f08770242141369d6d491ab224c70c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d76cecf652654375ba46be482773b6ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d3d524db77ba48f6be0852305cf1b458", + "placeholder": "​", + "style": "IPY_MODEL_007782fdcc4c446c838fa8771901bbbd", + "value": " 1.84k/1.84k [00:00<00:00, 8.25kB/s]" + } + }, + "d76e53b527c9492887746c7ccf775d39": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d76f16b36e7542918a7bbd13e130a591": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d77b230b79784fe7b3b858ce417d6c43": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d78b844780e14002acb30f69e980c192": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7acf9e837e14fd5983814b71745ed42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_071fdecd03cd40aaa13bc852216d1c63", + "placeholder": "​", + "style": "IPY_MODEL_c5ffe939c5664e33b86b850da956d3dd", + "value": " 3.61k/3.61k [00:00<00:00, 15.2kB/s]" + } + }, + "d7b03d0ff6734a8d8d8d425337c3d491": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7b3756c9e6147cea5538125f25ca8d2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7b6642466ea4eaca7b640885879b6b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7c00a8d7c8c420781d58d113062f8b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6419e0020ae74fafaf0d28179cbafa0c", + "IPY_MODEL_0bd45c0dd70d4332bc6e7645f63579df", + "IPY_MODEL_71fdffc88b4543fc9059ec6506c461be" + ], + "layout": "IPY_MODEL_2ea89892c44249e5b119d03c5b1fbf0b" + } + }, + "d7c263e0b0ae453da00e5094137501e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_52bd1038069e4cfeb6943f67badab77f", + "IPY_MODEL_c204094eb081482f95afb1ecc48377fc", + "IPY_MODEL_85f0f3c11f7f49bea563d4c01962c8f6" + ], + "layout": "IPY_MODEL_e65969f558374d459ad7ec6799ff8a1f" + } + }, + "d7cef50cbc2d4858aba263fe99c11b78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b66f74ec2b9c479cac3308f76cec5e56", + "max": 1336, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4d3f5faf6d9d4944b4482144f681092d", + "value": 1336 + } + }, + "d7d8f5e64dd14d3b89a4fddd50f4dffe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_37802aff6cad42f1ae03a3a7e3651438", + "max": 2186, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4f9a8f0310a747cfb9cfc3b3572dad38", + "value": 2186 + } + }, + "d7dacd89818d48018115f7fce3066c8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b586a727e32546d89b3871a51188fa05", + "placeholder": "​", + "style": "IPY_MODEL_11a9d9113d2e43a98cae2ad95c72d599", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d7dcd452badc4766a2341f5ecf5ac795": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cea631b1e43a4311af460178a190ed2c", + "IPY_MODEL_4c7057afc48c46ea8371abfbbcc969a4", + "IPY_MODEL_5596e4e09d15429491c5f1184b403185" + ], + "layout": "IPY_MODEL_c7f388b47b714f65856ee75a3787c9cc" + } + }, + "d7e7cacf1d9c4b098f3510eccbe34ce3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6e9e9238e16c4a0296cab55149d649c9", + "placeholder": "​", + "style": "IPY_MODEL_16aaad1013fc42d38ea88e9417609e69", + "value": " 2.11k/2.11k [00:00<00:00, 9.17kB/s]" + } + }, + "d7f1c0e0da3541be9e571f6e7a49040a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e5cfd5a146604c668e24f8fc55becf47", + "placeholder": "​", + "style": "IPY_MODEL_362b418191cb4ef39f48f158c37b5fbf", + "value": " 3.26k/3.26k [00:00<00:00, 10.9kB/s]" + } + }, + "d7f4110550b94c6aaf5423fd3cad0e7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3ddd4524bb95451c83865d08333b5a1d", + "max": 1962, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_52b624127e134d68990cdc71af29e67d", + "value": 1962 + } + }, + "d8036381b400416fbf32efa7bb05ba83": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4e524c74f89642e199b70bd9cdb1a54e", + "max": 138070, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_178bfac7e854437d8180a5c8b599e82f", + "value": 138070 + } + }, + "d803fa06eed4414db4e9d722dc67c57d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d8078c6773cf4b7ca7804534cd5a0cba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d80e9d142a3a4a75987ad3bfea830771": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d837ac8063484b6ebe22ecb2d537ff7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d8394b6239dc4907b335e7efeaa1fa94": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d83f0aa56d114892b47c33184fe85a22": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d8538bd32d9b4ff0916eaf719a9f475a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d85a4056b76e4798b79d29e7c6ff4a7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d85fd50b02ce47f086b033460bda9208": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d862b0b27438481a83d668b11fe9fac4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d8713724803d4a6b850d2afceac5d3a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4c94cee472d84d348b0bbf26ab1e248e", + "max": 1791, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_105c2bfb3f314ddcb5b4e5cb6a4b0a7c", + "value": 1791 + } + }, + "d8747ee5646246e292692d5aaab1eaca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d884afc2644d47838540b22aa0a9da25": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d8884db089a248bdb2d6852aab9d8b09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d89565b61e5343b3a1356c2f479e3dd0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d89f62be730c456e9b34a5fd02d83316": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d8ab2b181cea4fc4a7bb97c1eb8bc7cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0a29de0ab5de4c1fa8cca8a7ce6f857a", + "IPY_MODEL_be15f2850db8476781260346e0d7b5fe", + "IPY_MODEL_b3410eb21b404d8a852857f1b240a0c1" + ], + "layout": "IPY_MODEL_6323d7df641e4b48a1d7228d35861ed7" + } + }, + "d8bc89c72995463b900f8a6d114b80b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d8e3d099fe7248c6af1adb5547cc635c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_400b3b5681ae4f8c94c21955bfdaa569", + "IPY_MODEL_9dcf1c4865874fea8d415aa420b627a0", + "IPY_MODEL_77966e966386466f9321c900b3674941" + ], + "layout": "IPY_MODEL_a22af8852cb449f682a4590737b86c4e" + } + }, + "d8fdd7df34d24a62816fc7a0441bea3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d14d0cc426814ddfa449391f5bbac10a", + "placeholder": "​", + "style": "IPY_MODEL_f352b51866434fe8b11edd075a0353aa", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "d907e26889f1401db3934a1886fb368c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_034789b74d524b518b02b3502f875ce7", + "max": 1357, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_697e4be28fa744e7a724d151a78208b1", + "value": 1357 + } + }, + "d917ca86776d4f92ac6b30f89472053d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d927bb346d2a4b75bb27c482fc0b5b8e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d93d99063c6041668d595c0220c744a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_168e69bd264d4d47b02623d7d603ec20", + "placeholder": "​", + "style": "IPY_MODEL_f4ad3b4e11ee4015a301e1141b3ac3a9", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "d962a37947d24e6b970e79fa89ed05df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d9820a20e140401bb2d0e07b80ca2518": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d98ea71308cf40109ed36b4c1635a2e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d9905df7b6ed4f1f93256f69ba242fd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d994f55c7db846238861463b2201d3e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_983bda56ec4a44bdb276fceeb85eceb3", + "placeholder": "​", + "style": "IPY_MODEL_e5996fa272ce44aa8fbb5f4a6fa7c3b8", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "d9ac82bf717e4af6941bb516bdcf6955": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d9c144c0790a4b7086db1ee6ceade9f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d9c8907cb7844c7fab58585526a836d4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d9e6f2d52360454cb270f7448657c2c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f45fd850cc3d43adbf08551faa65ed08", + "placeholder": "​", + "style": "IPY_MODEL_7274b6fbe1044d45b9e7d8693f1b4281", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "d9e9d80c1777436ab58b74c66bd48b41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d9ea6034361440efaba8146a8a6769f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d9fa15aaef1547ebb3fe7052f276b165": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1ac996908628418296ed0355e057c64b", + "placeholder": "​", + "style": "IPY_MODEL_0db3f74843da49fe87da0ad618c53a73", + "value": " 1.68k/1.68k [00:00<00:00, 5.02kB/s]" + } + }, + "d9ff27b011c34b7086f48c9cf1a47ae7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da2c53a00d6248208f9ad345e75aa150": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "da3861baed744d34a53f61011f4fe75e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da387d8342964cd1a827693a257d4ab5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da38efb4261d40898cc85eb703016446": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0dd49b92d5bd4d82abcf3b5a573c1647", + "placeholder": "​", + "style": "IPY_MODEL_e18d31e05b19451c97cee5244a86759f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "da44e30c8cbb4a5c896ee7df535d4cef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_de958d4d25074acc887cb08e66574b99", + "IPY_MODEL_ca9580472a8e4ea89ccd5d5a9b283429", + "IPY_MODEL_8a7a94e67a8a48bb9073f7a8d3b7a483" + ], + "layout": "IPY_MODEL_6783b9b46c3f4dce9e050b827fa02181" + } + }, + "da6bb26751454da288bb793f4a912a9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "da6bc2f534ac415e82e18c292336dbe0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b75f5cbc33a443c9bd4e44605fc43d5c", + "IPY_MODEL_79fe4426be464d77ba9c8a536abbdc75", + "IPY_MODEL_77bb6310118f414e82b3e04c26f7a9db" + ], + "layout": "IPY_MODEL_23cb8996ef78407faf318b59f23cd6bc" + } + }, + "da7f060ebb7a4b94ab7863a902c8f51f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da865f2bced843358ce5d939228a7638": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "da99bca13e9d447d8d9cef70563d720d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "daa5f0bbc5e745ec99cbdb39d0ac2b2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_399ab74da9084db1b7310fbfb3da8c47", + "placeholder": "​", + "style": "IPY_MODEL_367f0c5a38b64ea0b614bbe3ab980af2", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "daa82228c7da48a79184961f633b0ab8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_89c2503ef7df40059cf183248b113543", + "placeholder": "​", + "style": "IPY_MODEL_09aa2168bd4c43828c16b2f0c5f4e20e", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "dab6d609cd404d2180a7c7dca67875bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dab780965d9c489783a19913f4a4ccb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dac26fd01f2c48e2bfd34d29214215e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dacb3aacafa048f3bb480c9e7af3536e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dacea59f6fe14dfdbf080a3d063541ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dacf28a2f6494c47a9a5b648a4b5e4a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0e97bec3fbb949a78e5fd14a4a2b2f3e", + "placeholder": "​", + "style": "IPY_MODEL_cf65342324874e23ae647d1903f048fe", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "dae01322124c43078ce9c276bde9e7bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dae9b945dc294e37b0475c4a7503656c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e8e1a23a16e74aeca193e9b14915c7aa", + "IPY_MODEL_3275d7968d50450382296ee73a829610", + "IPY_MODEL_3f3989dbbf904374b281d4632ea267df" + ], + "layout": "IPY_MODEL_337f2d6c4c784b44b63e6c8083839a25" + } + }, + "daeb5c72addb426fa88e92721e283cf9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d557682ad0ce4c27b548d2180bcd1c4b", + "max": 3136, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_819fcd9c775443b09298197f30a6af31", + "value": 3136 + } + }, + "daed743c2dfb47f5853c02a083d42049": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "daf01ac9d2e74a42b74ab8b4fa0a9a6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0313e3f03b0a42a38edc3f7223f51d8f", + "max": 1746, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c1ff376e907d4656977d3a723e914a5b", + "value": 1746 + } + }, + "daf463bfb9a449b1a4d91c58258eb039": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "db43107a7bb3438082df4ce7e54c1a62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5a25aa44e938493da0b62d80da8b2c47", + "max": 1842, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bd9d694785e846359186258904396689", + "value": 1842 + } + }, + "db4e5816dd86453a935f75f62db8f361": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "db69e36f912e48eb8f1ede1cba4bf965": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "db6a14194a9f4d40a15e527a4049e783": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "db6f99ece1304644bc9727fa60b4b926": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "db705faa34174449846e14481434f3f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_305c85559af84ac6b305cefa8f396f55", + "placeholder": "​", + "style": "IPY_MODEL_c13f0a80c3ca4f4b8f32a3d26a947a25", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "db863cf3def04823a00c16404a7c0eca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5ae7ecf154294e1eaa04bf8aadb430b6", + "IPY_MODEL_aead74362be04990acc1f4aa32ae5cb3", + "IPY_MODEL_8a9a416b9ef84f04865a148fb0c5f71c" + ], + "layout": "IPY_MODEL_20ee3493aa4c472bab377d3413bd570d" + } + }, + "db885bb8aa2a4173a80919ab7de6c762": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "db89e8927d504b21a9a19be41d3c3df4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_beb0655ab8a64e2e80059d1f8aacb155", + "max": 3601, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_92c5e2bc61f648c08f6834fcc2a2c75f", + "value": 3601 + } + }, + "db8fc4e2f1a44b4dbfccc5eeeb76c93a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "db908a3686d54e28bfd7aed1c7c1b4bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "db923c63b67547d1a33d73374dcbf4cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "db992127901b4babad5a6375c9246848": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "db9b8cd8801d46858090ec288be02c7e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dba338b8fb8c4e0699edf233f60cbfce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "dbaa85ceb9b043b9b431a7324c1e910d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dbadd2683e414e54bf131c4d6fa11406": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dd726bc7f21e414cbece7748610b5bdc", + "placeholder": "​", + "style": "IPY_MODEL_31ffccf70010499d8118657557ccdbcd", + "value": " 2.12k/2.12k [00:00<00:00, 7.40kB/s]" + } + }, + "dbae04d9f1a14342b7c9dfaada36b596": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1f3071ec2fe94beebd2160cc73b8211e", + "max": 1891, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e6bd84d34ae644e6b2b1c33945476eb4", + "value": 1891 + } + }, + "dbafbb90e2484566b915f8986b0c4fb6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dbb46cc39a66473f9a7405c2d846d84f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dbc66e0925314a68b45780855e1a83b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0627fd9b7490432e99c080cbebf8fc36", + "IPY_MODEL_fd824eef122d4f8db3b9fe87d5fef620", + "IPY_MODEL_b09429590a9340b1be5d90e502ae158e" + ], + "layout": "IPY_MODEL_81850d089ab44acc9ec0cbc102f7436c" + } + }, + "dbc92b7f013d43488e13e5748d168183": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dbcf378fa4b049d4a0f093be89c83397": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1ca5008e1b22475398ba03f370cb6323", + "placeholder": "​", + "style": "IPY_MODEL_1745bf56de50436c8b967695ac34b12b", + "value": " 828/828 [00:00<00:00, 4.12kB/s]" + } + }, + "dbf026e5b2e84b0b9678b0adc2696b1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dbf60ccb291446b88295f630798ed21b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc19366078a34360808f76e244eb12a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_786450970b1c4d93a25e3414836cf346", + "max": 1429, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_edc3b8cc74e447c2b9cdef4e4d2be6ed", + "value": 1429 + } + }, + "dc2b2ace1fc643f6bab6f4056d5f0735": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dc3cee8db6854af38e650ae8c38eea5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dc412b80b899423f849e9d95e1c530b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc5770e4285f48aca5bb350c1fd31b9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dc7492fc0ac541e28b3c9fc471d6574b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fa71f690ae9943ca8e28d2720268a70c", + "placeholder": "​", + "style": "IPY_MODEL_d2d678d891b4456991b5d74227dd37e8", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "dc759eff8425436ab6a21f15f2144ac8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc79398e802041d0bb94e1861145a9de": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc798efb048946f8a161ecfb9032213e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dc90934fda5647968c6ca8cf319ff14c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc928f6a9ddf4dbb9255eda2b18144e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dca592953f724355875fd340de7c9756": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3889299440444a18a7af6685dfb477a1", + "placeholder": "​", + "style": "IPY_MODEL_0e333c09461147429a9610175d0e8f77", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "dcb00c91b0294d3cb9112f6939867440": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dcb69f18dc794ebaa9b9c5a5c8d33432": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dcb6a05f4be04268b4e1bee9ba3c1780": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dcc037743f4743c0a25e7e54283e18d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dcd603d32ec64a018111d189002008d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ff8eb4374e1e44fb8b564f8d4e52ecf8", + "placeholder": "​", + "style": "IPY_MODEL_5b3b31dd4acb4e6a87fd4f7c69274361", + "value": " 2.43k/2.43k [00:00<00:00, 15.0kB/s]" + } + }, + "dcf58967aad74f3ea9f25ab3d8abfa4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dcfd39188f28408481579f4d77217fb2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd07e7bd9bb949e0923baea7292a073b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "dd08d2743826407da595d192e1bf9021": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f6a03c43118f477880c47bf55498be96", + "IPY_MODEL_c35b86b1875f4dccb345dd0057ff5605", + "IPY_MODEL_6e1d6f0806164c3aa18784562dd51d3d" + ], + "layout": "IPY_MODEL_dd4d7c7a651347e894be9d93bd6c1886" + } + }, + "dd0c8b3ab974434ea65054e53e974032": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd108e816ce641c190d7fe6105facbe6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dd1bb7d3b0d14d498c0490622edf23ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd2b570eef794b2daea111d4a445b8ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_34a6b2bebea04eb78d48dcba0db0aeb0", + "IPY_MODEL_7c7818be3336437ab670db3a68d2a759", + "IPY_MODEL_1948097dafc94717a5a080d42d943143" + ], + "layout": "IPY_MODEL_0be7e5412b9e4db38d42374ddb4242f5" + } + }, + "dd33d6238c2e4ee2bebfe51aba511025": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd4195136b5541ad88597b0646225451": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b45658d7a59945cea447882dc867a770", + "placeholder": "​", + "style": "IPY_MODEL_77da7311330b489f8ed1c087b385a257", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "dd44a5d7f4f34213aede9a73a6cd6bd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1258857563f24c4a86e32a9abdc6c74c", + "placeholder": "​", + "style": "IPY_MODEL_cd8c4982cf254353b7ccdac836cf4275", + "value": " 3.28k/3.28k [00:00<00:00, 17.4kB/s]" + } + }, + "dd4d7c7a651347e894be9d93bd6c1886": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd4f46b54ba24ed28c9ad64ad2dfeb2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7e9c2086b82c4e3aba3c320818e5b68e", + "max": 2989, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eb57a4ff28e24ffba1958e853d576b97", + "value": 2989 + } + }, + "dd4f54b7d2b349018f0f57ccf6552c4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fab78a9268c24ee99cd244f52fc9f1b8", + "placeholder": "​", + "style": "IPY_MODEL_ee15d375e4d2443ca98e579f208a8ed0", + "value": " 2.11k/2.11k [00:00<00:00, 12.6kB/s]" + } + }, + "dd61191a424040fbb50d7765105fc4e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d262cddadcc442d7994598a7f7a2648a", + "max": 1384, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3d40d42b7a1e464cb38f88932b3c8631", + "value": 1384 + } + }, + "dd6586d423a34b59843b61cb7701b384": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a8183f0c0cb54148a12ad28e82d0b3ac", + "IPY_MODEL_7b4b632386f349d7a48f84c1bda8af91", + "IPY_MODEL_8f46a01987f34ba8903e4166df4bd1ed" + ], + "layout": "IPY_MODEL_9595c62e1ccc44cf90c12775184acc68" + } + }, + "dd726bc7f21e414cbece7748610b5bdc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd739f90e2ee4fc9891ca9ee0a19c527": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "dd73fbfe76504370b6f322147daa0755": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ecfda1335f9746308a58ea55ec92079f", + "max": 1611, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_314277095d02468cb3d0ca9b865c27fd", + "value": 1611 + } + }, + "dd78463cf9054c22ba20a3b531ae1623": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dd845b6bb54744849872e6236e7d3a1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5cf07f84b6214c8a811b77008140f7ea", + "placeholder": "​", + "style": "IPY_MODEL_c60526e17b6b41e485827c409a328a1e", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "dd967403e42a4dbfb93ec6c6a46553bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "dda804296531400b92f710544b4a6665": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ddaa4ee3621649cf8dbc95b4171dcd55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c86157b3c73a414998f23e6c0508f7c2", + "IPY_MODEL_3cff5c7f37c94cb9bd741345bf3fa9e0", + "IPY_MODEL_181ffc76250948e6afbfae10abe3159c" + ], + "layout": "IPY_MODEL_6140667453774c64ab247e4d068f9249" + } + }, + "ddc68f1f747b4321a4608a4706c6feb7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ddc6bf1450c64c828e697e027b3fb7f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_baaa768e58b24cc3aba2742d243bfa02", + "placeholder": "​", + "style": "IPY_MODEL_3a2b4bf19f6e47848ea4d3aa2f07fa04", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ddc7cbba56c149d585eace18855f7347": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4d95239ec2ad4a47ae415a5b11f10736", + "max": 141124, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4ad048f86bbc487aa8d61a2eb6e868eb", + "value": 141124 + } + }, + "ddd7bb5d7d5e4621873a428ab3d83672": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5b743257287c4ab1bf5a7a9e89803e37", + "placeholder": "​", + "style": "IPY_MODEL_f6904857e05f48948922d545d247ec10", + "value": " 2.44k/2.44k [00:00<00:00, 15.6kB/s]" + } + }, + "ddee7392845e472e8efe9b36b3f8a3da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ddeeab54b32f45ad8fdd540f656952c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ddf496118e3146849339a46c0d32b2ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_051a96ee0c0f4d8bbdebd0918b7d44c0", + "IPY_MODEL_0fbe58ee92dd44dbbdc534a453768424", + "IPY_MODEL_ead71620cbd645d59593252e79916502" + ], + "layout": "IPY_MODEL_4a3d9ba0d94e494797f2b2e8f5198d33" + } + }, + "de00cb298152433f941fa68d31bfbffc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de08b0c3752342a99ac506e388b9a125": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_40aa83f9debf47928ad4dabbe4ccbab0", + "placeholder": "​", + "style": "IPY_MODEL_9c560d7f856a408b8160dcfb0a368160", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "de1e51c943fd45858469e29cbed94b41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e91953d1c7fb4aaca76034b576a121f0", + "placeholder": "​", + "style": "IPY_MODEL_961e85f7828343c99f66f4a4f622fdd5", + "value": " 146k/146k [00:00<00:00, 350kB/s]" + } + }, + "de34c19800154cb6b4ed11eaf33f65bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de3e017777d54010bf3b6147b66b594e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "de46250f8aa84fc090ae3f37e32193d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de67248ca49b47858330606605c2487f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de6825a69c8148fe9f0e596ad3facd50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e42ab30f418c4d23b2cd82485b6a921f", + "placeholder": "​", + "style": "IPY_MODEL_65d5bca6d6964361ae038b36f23337e4", + "value": " 140k/140k [00:00<00:00, 316kB/s]" + } + }, + "de6f144ab2664881a43ac3780522030a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "de7aa6a765c54d18809a8a2b58c7e227": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de8ddb31de4f4432bf61ad8aefeaad7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "de8f03b25ca94ffe8077e20df7d1967b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_092cc02b3d4949f0a77a1f25d39a2369", + "IPY_MODEL_0b3fb4a52d3f4d59a341bf9664c8b46b", + "IPY_MODEL_dfb8e22130bb4ad2bc9338135fd86aa3" + ], + "layout": "IPY_MODEL_c5e7b33fe7d14ce3a3a1d99d837934a0" + } + }, + "de958d4d25074acc887cb08e66574b99": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_73264053e79f497f9184cc75908aef28", + "placeholder": "​", + "style": "IPY_MODEL_3333c904bc614fd58af32cea35e4eb5f", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "de977a60a54c457f9c0571746835654f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c9fbaef0c4b0473dbe4e519934de6ed9", + "placeholder": "​", + "style": "IPY_MODEL_2e6ab02d05b0443b9415efa72c062ef9", + "value": " 1.97k/1.97k [00:00<00:00, 8.02kB/s]" + } + }, + "dea15bf3041945059a2ad724f5c12019": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_531ae837eff94ad989cbeaf6116a2276", + "placeholder": "​", + "style": "IPY_MODEL_93fe0e0226ed4d7388258bee55f536c9", + "value": " 1.13k/1.13k [00:00<00:00, 3.33kB/s]" + } + }, + "dea1c001a43349d8b9801bb127653076": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_075bf93e35a14601be6ed1e99e61ed01", + "placeholder": "​", + "style": "IPY_MODEL_af18181dec4c47948fb5945af2c485cf", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "deab6bf13175467db6e8acaec098035b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "deb6b57816f044e280d1a6bc206a7b5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dec9520bf7c0404387c17bef8781b0cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ded490d1955e47f1ad33ad1b7e7cf040": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dedf80be58c54a6da1c024afc9be3a32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "deee795d156749d296b3c0475a872a1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0a2805e5e95f44fdb4cbd60e5aecb4d8", + "IPY_MODEL_4d5d86847d4044738c18f2d4e3e5c947", + "IPY_MODEL_92b6da65975542aea2a390b30a414cc3" + ], + "layout": "IPY_MODEL_9281680943994fe1bbb59624f1ebbbcf" + } + }, + "def124b279af47fb88d91e33ab62ebc4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "defb5252e05e4b5b84e86be225f04784": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8eb3f632caf94726b74d3ba56caafcc8", + "IPY_MODEL_6008afea184b4e23b2d9863d57203b65", + "IPY_MODEL_d4aae0c8bb8b474ab66c6fd8e119bd9e" + ], + "layout": "IPY_MODEL_91c132d65da14d3eacdd43ebe591387a" + } + }, + "df086d8c0cb742b6aa4f57debfea6c40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_be724ebc65b64260953679b9f776e942", + "max": 2271, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a1e7edcfe50c419fac7db6a7e34e0739", + "value": 2271 + } + }, + "df1301790fe9468991bbcf206c9476f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "df13bfae0238476481f11e406bdc6735": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df181c39777545fd949c761170fdc4ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "df21408f81894b0e9773841b032a4632": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_31526e89cc614d5cb3e1dc81e4e49e75", + "IPY_MODEL_c97eca7ed6204b028c20215b29eceb2c", + "IPY_MODEL_18ff23700ce44ed9b132db20359bbf58" + ], + "layout": "IPY_MODEL_3b66ca787dd04e7794ed906659c24682" + } + }, + "df310f7b3ba9426fb1ef628f21173a9b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df43ab139ad4421bb62c16850c1b3a25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "df67fe085e81460e9e2100737fe88cdd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df6e47df5f1042fc911d69fee7433deb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8e26198a49994576afbd7eb0f9412ee6", + "placeholder": "​", + "style": "IPY_MODEL_641c9ba762314f4fac3489c1781f7334", + "value": " 2.01k/2.01k [00:00<00:00, 13.3kB/s]" + } + }, + "df7add63d9bf48f9a0e76db054e82125": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df85c2cab46649aa9604ba9fa519898e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df86ceb0fc2848dd9416f3456e38e36f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b3ec0d4e403446c88c4557f5fb59c45", + "placeholder": "​", + "style": "IPY_MODEL_3aedc62ecff24e26ae6706c70d9c4366", + "value": " 2.91k/2.91k [00:00<00:00, 22.5kB/s]" + } + }, + "df8db1b8aecc4a58b1851d3061177979": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df8e996799894e29b5db260b70e363ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_762887e0b0dd4e8e956b648a15e54046", + "max": 3590, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5c910c3f183d405e96797799331bbd5d", + "value": 3590 + } + }, + "dfaa9a62a39544aebbcf63bc8a19e0f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dfb00b49cddc4183b1cb820a86dee1f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dfb8e22130bb4ad2bc9338135fd86aa3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_443a05b71fb3435596f9a44c30940595", + "placeholder": "​", + "style": "IPY_MODEL_3f28a2e2d5e2426c86816aa1d63ab7e7", + "value": " 1.65k/1.65k [00:00<00:00, 6.54kB/s]" + } + }, + "dfb9359a4b9342a8bace9fdca7aec63e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e00ac383f49840c8986215e923446034", + "IPY_MODEL_6313f5c999e34e278260351647241e88", + "IPY_MODEL_aeff5d495dc44af0bd348d3e0ab32725" + ], + "layout": "IPY_MODEL_efb7296509b5446eb0e2c170706abe28" + } + }, + "dfbb57e85cd942839429ce1f06e2a6d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dfd5bb3f58364dd7970832ae45ab562f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dfd7243b8e3241daab4d86ff4704b5d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_23890454a63d47b2877e51e80659c014", + "IPY_MODEL_eb8df350afe54d568a17416c4bce1cc9", + "IPY_MODEL_f19c20f822614fb0b889d73574290785" + ], + "layout": "IPY_MODEL_e029769f01ff4b68b73f7420d663e6aa" + } + }, + "dfdb3b6302974060ad31c2429fce326c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dfe53a0d143f4fd69cdc2326dc9be741": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dff036fec1ae41a5a1d039803fcc3b5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_12af3a22e7e64264bed1c2925e5586b2", + "placeholder": "​", + "style": "IPY_MODEL_7d789106e7ae4f93bc106c47b7a71881", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "dff10e013aeb4ad082e2f8514b5fadcc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e00ac383f49840c8986215e923446034": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_74f183b45dc349bba3effc2742dbdd29", + "placeholder": "​", + "style": "IPY_MODEL_21f2c779a2894f5fb14606b08562844e", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "e018bb6171094723bf9a8470fa148346": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e029769f01ff4b68b73f7420d663e6aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e032e765018e424490b81daa056eac03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0371eb6ccd747fd9450a10062080a1b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e03969f0822346a6adb420fdf84e692e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_13dd97ef61df4984aae9166930188d99", + "placeholder": "​", + "style": "IPY_MODEL_1197ff507e5941cb9fd625dcce4ed06d", + "value": " 162k/162k [00:00<00:00, 614kB/s]" + } + }, + "e03f61a3714a4bf6860274b7a019cb0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_31e06f03299e4050b505459494825ba5", + "IPY_MODEL_563b3b482819457286022ccd21f85f93", + "IPY_MODEL_5153cdf46585452f8a869b15a08d6e4a" + ], + "layout": "IPY_MODEL_c6bd95f5ae76489dba22b8115b42a867" + } + }, + "e064f53a4939434b9cddb8b28e80bccb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_34d3930e329045e99ef5946ade634191", + "IPY_MODEL_1de914bafa57494d987805fbff744a9c", + "IPY_MODEL_a775a68c52e64b45bbd9bc3d8e8f2a43" + ], + "layout": "IPY_MODEL_439f63bb5a3f425c88b7d47e78e5c74d" + } + }, + "e06d35e258c94370afda04b30f73b37e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_470d7ccadf5144e49b777c71590c0bda", + "placeholder": "​", + "style": "IPY_MODEL_dbf026e5b2e84b0b9678b0adc2696b1b", + "value": " 2.21k/2.21k [00:00<00:00, 18.2kB/s]" + } + }, + "e08d506c7523486782a034ceae874689": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c77ffae0cf7b4a33a66e2c79d3027ead", + "max": 3823, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4a461862121947509ccfdad321354ff3", + "value": 3823 + } + }, + "e093daab5e2146fea51a45549e869508": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e095ed89f7fc4fddbcb93194bfb713ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ca1ef94d9c541cba28cac0d044e92ab", + "max": 2610, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5d59195102a44702a7fd4db708875a6c", + "value": 2610 + } + }, + "e09733303b714f90895621fa2b2e30e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e09a402034f440e9a5edc67056bf8373": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0b215b5f9204a3bacf5cc7eb3e6164c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0b42051b5e9486b9dad4ae0833f21be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4d5ef419d5a34af1afb4ee1da7d15bc7", + "IPY_MODEL_0f9e8972ae124a11837ef540cc6de22b", + "IPY_MODEL_1a668557e98b4ab192e59d3d222d5a3e" + ], + "layout": "IPY_MODEL_1356d4185789407aa4138d6b8d625466" + } + }, + "e0c6863ca51c482b9b8510b1d96e083c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e0cdf250916344d7a097dfe95d8f9195": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9cc2bd9b5bdb4a169e09b025662d3e3a", + "max": 998, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_92ae0066ebb741b2ab1af6fb13a3e5b1", + "value": 998 + } + }, + "e0dbac81fdad4671be34490bcf3b7892": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0e7d05e5d3f4440a6dd11154b4d4365": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0f3698f44584505ae65847cd4e95bb8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e103e8f1e3554c1cab49f6d54ee6c7f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e106745312074eef9791f25b06ef6b9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e112823e4acf4a6485c3ff87423e91da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e11db52c903447a9adb15fe9049b3c1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e124657421f6473b932c7a1d1c049037": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d83f0aa56d114892b47c33184fe85a22", + "placeholder": "​", + "style": "IPY_MODEL_22170890fd8548c7b041fa6eb2064cfc", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "e1332e94a529489187ff412e5392f8c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_970e880777ce4c86a4c49829169c3251", + "IPY_MODEL_521812c36c0c4a928c3da5233f83a7bc", + "IPY_MODEL_2456ae7542424529b01df033081cbbb7" + ], + "layout": "IPY_MODEL_ea9aeb89af234fd8a559264a4900ecde" + } + }, + "e14684c133e647ae811911cf5451c8e2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e16ca6a8d7644551843f4189f523d608": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e172549f373643bd805835363b7a0201": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e172e595c3294d1bb65bb2eb0b25408a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a0c73459d8ce4b8d935624d3f87b46c1", + "placeholder": "​", + "style": "IPY_MODEL_a9748915e7c648d39c3a469b794c6c13", + "value": " 1.78k/1.78k [00:00<00:00, 9.13kB/s]" + } + }, + "e176b267c6dc49788610b090cb960c48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e180e5dc5ca745a6b5bece7e91939277": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e1831af076744876a8870ff2469e9884": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1e8616f90c5f40d68f7182ad8749c88e", + "placeholder": "​", + "style": "IPY_MODEL_eb9b04bfe00d4905adaa147db31ef3ea", + "value": " 1.76k/1.76k [00:00<00:00, 10.8kB/s]" + } + }, + "e185024beecb45ecb18040e8510a74ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1ed57112248c415091fe143741855b9c", + "placeholder": "​", + "style": "IPY_MODEL_0ff66b03ec674e8388fb6a204ebacb82", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "e18d31e05b19451c97cee5244a86759f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e18d8f4beb434665a6b48e61d073acf0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e1904b4f110143fdb4378ccb285ef492": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e1b30d5a27d24252a9f2658225f15739": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e1b8b8fd530b4c0291dc9dea02cf083c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_07638bbb4a2b424ea8825dfbba3bfb21", + "placeholder": "​", + "style": "IPY_MODEL_8d299bfe4a4f4587a1f23bd1c79270a1", + "value": " 916/916 [00:00<00:00, 5.09kB/s]" + } + }, + "e1bb19e7f64b4715806d14c737a86fb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d7dacd89818d48018115f7fce3066c8f", + "IPY_MODEL_dd4f46b54ba24ed28c9ad64ad2dfeb2c", + "IPY_MODEL_d1964f3928684dc29fdbc733231071ea" + ], + "layout": "IPY_MODEL_e3fc9b5620b34241909eb81203ccada6" + } + }, + "e1d09aa6c2b94cbd94af0f8cc62d136a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_54d181b9d66e406c99e560fbe9c05c9f", + "IPY_MODEL_1d51041c854549db9164ec1ba218fbb6", + "IPY_MODEL_af0801968f534aa0a0a3f87c9dd65730" + ], + "layout": "IPY_MODEL_b6c3a65023034159a1f72adfba1356b8" + } + }, + "e1d0c1807c7943b08ad663617f45fd3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dc412b80b899423f849e9d95e1c530b3", + "max": 1241, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_173c288bdf474f009f225ec2443a19e5", + "value": 1241 + } + }, + "e1d53d337f404774ad0919c688c62833": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4eceac85e2384f01b468df9259980b6c", + "placeholder": "​", + "style": "IPY_MODEL_c5eb1952a28a49bdb987939943b668f7", + "value": " 2.05k/2.05k [00:00<00:00, 14.9kB/s]" + } + }, + "e1fe4b4a84664e30878421461de2c648": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_91a803ecdaf84287807dd55bc214e5fe", + "placeholder": "​", + "style": "IPY_MODEL_1876670c15e6444eb791d3401bd74a15", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "e20ad481fe614e738073871b4a615573": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_74cc7aded9fe4ab9afea0a479a6ce7cf", + "placeholder": "​", + "style": "IPY_MODEL_db908a3686d54e28bfd7aed1c7c1b4bc", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "e214328e0e4f4896a4cbbd3de1543d9f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e2228a2757b149fba2ee743663d5ce7c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e2393568f777497f8d3d8cc14fb3b01f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e264ee369cd34d96a435861a5f3295aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b7949d49a1464751b3db6b3aa21d31eb", + "max": 3428, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3f75369bd7984d7181ccfaaa703f7fa5", + "value": 3428 + } + }, + "e266d36c68f44d78bf07706c70dc3267": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e2775ec1af3c48a88b669102f7edd47a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e288f62b099f408aba7176e6beb0c629": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d5113127f8ad4a6fb2488ee504a25dbe", + "placeholder": "​", + "style": "IPY_MODEL_1bfb222f761b4d71927644b318f1efbd", + "value": " 1.78k/1.78k [00:00<00:00, 13.0kB/s]" + } + }, + "e2b03b494672404d8b7e64a41d86066d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a6108588b46549a5a9a0c6277c880159", + "max": 141240, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ca401b39379d4134a068b578d99cb821", + "value": 141240 + } + }, + "e2cab2451ddf4f76accec6ac264c0447": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e2ce011856b24340b23832d46aad63d2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e2cead14e99d4093ab98f83b2cd201c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fc01610df6ad4c45917067a766c617aa", + "max": 777, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2bb85d0bc55240f49988f7d34de73756", + "value": 777 + } + }, + "e2d7317b33d847c99c060d9d8b080105": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e2ee1110dce44fb09fc1f23dc2ce7735": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e2fea24941314289bdc3c66a188ca0e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e30a0d7a3c3b406ea73df5aebd70d515": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e89eda21f8a1474987a01582aa8ef70d", + "placeholder": "​", + "style": "IPY_MODEL_cc8a5f5b8e2843aca6bb76c912a1b2a4", + "value": " 1.89k/1.89k [00:00<00:00, 7.01kB/s]" + } + }, + "e3133c58668f455ba66f11b91065a250": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e31acf009f2e4df28bb52e3014bc2c3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_051ba026ddb64559b9b894268e7eef04", + "placeholder": "​", + "style": "IPY_MODEL_dd78463cf9054c22ba20a3b531ae1623", + "value": " 3.82k/3.82k [00:00<00:00, 14.9kB/s]" + } + }, + "e32dd5c3041642f09e25b870b59d18a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e348d66b67c941c7ade77f3e4ff50be8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e3583b97d25949b58e5cd6413408f15f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e35b7707727b4fffb4d13d18ab748357": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e366d9f7283042cd96ca1a3b6ff84ecd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e36d1ad192e240028e75c4d64fe0ae96": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e36d5dec9c844c569f95938b08d4cab6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dfaa9a62a39544aebbcf63bc8a19e0f0", + "placeholder": "​", + "style": "IPY_MODEL_5ece719c79444ef58fb58ec13a9ea36f", + "value": " 157k/157k [00:00<00:00, 1.16MB/s]" + } + }, + "e37058f1bb4b44fdbb60f35544b8f248": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e382cb1542d4491084a9a20874d3179b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1504f362ab144a02b5e1e07e6735ad62", + "placeholder": "​", + "style": "IPY_MODEL_15f3c8c9d0634cff9fb524b35a7db11b", + "value": " 2.85k/2.85k [00:00<00:00, 10.5kB/s]" + } + }, + "e396c1d14e2d4da397f6be080c10f5e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3a35774b3a740d2b0dd60583151701d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_97de91cf96f54102a1466f9fcf4d24f2", + "max": 2664, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9783013c85894208a1e6bb1a54b02004", + "value": 2664 + } + }, + "e3b18e757a4840d3b7d05bf3dad82005": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0ae6aa3db65c4901aa4962bfd724f12c", + "placeholder": "​", + "style": "IPY_MODEL_06f5f34c8fc443efb9a604f58bc573a9", + "value": " 2.38k/2.38k [00:00<00:00, 13.5kB/s]" + } + }, + "e3b39ae261f44490b254f0b04793d172": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e3b5f521ab89409486d7bbc1249acd0e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3bc4dcb54e546cd9043807b1501880d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3bc655af8c345c1a973f8e15f20fe08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_33dda4c88af7439fb4a0e9b6b2fe40e1", + "max": 1380, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7f00831c75f14b2682d9cde63803d201", + "value": 1380 + } + }, + "e3c5f8726e9e4ec4938c51dddd4ef0da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9103f5c89f0b44e7827e1a4b3e38cdec", + "IPY_MODEL_959c48251a3b4a51bd49a47ecd8c8a51", + "IPY_MODEL_6aad608ecfc84e8585e85fb33fbfe1b0" + ], + "layout": "IPY_MODEL_1f1d8ce3c5da46b3997b5d5e3546ab5c" + } + }, + "e3e93b306ce24ac0b643e4bee5940beb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e3ed1a40b4e84c7087dd8eb37f8fea25": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3f00354518d48e98e9e21a905372f73": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3f6cfce0d0a4dac99fd8201b573d21a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_10ebb9cf3be643fdbe714a64e6537f49", + "IPY_MODEL_b050cbf900d54740a37905c5c53cd1e4", + "IPY_MODEL_4ac39fe0a8ca47f6ae363120153a8550" + ], + "layout": "IPY_MODEL_cdc6999fd92846bcb4713fd6769f94cd" + } + }, + "e3fc9b5620b34241909eb81203ccada6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e401729096864937a0a132f459857c14": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e41baee4b88a4510affbedf7f261d987": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e41eac45d7cb40b9b2b10c70ca1a5399": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9899417287b3424caf309ea2b933b928", + "IPY_MODEL_7fd1ab39d7eb49ec9be8aae7b3b9fa32", + "IPY_MODEL_1859be5fef9c4f11abf26e57c6e3b710" + ], + "layout": "IPY_MODEL_8bc3bffc9e344a1e9652592e7c26e9e8" + } + }, + "e42502bd9d6242c89dafec5e75d2085e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_be65c4260b4541488b70eb1b4787dea6", + "placeholder": "​", + "style": "IPY_MODEL_50b92da5765546ce9b01e81d2751cdeb", + "value": " 893/893 [00:00<00:00, 6.71kB/s]" + } + }, + "e42ab30f418c4d23b2cd82485b6a921f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4427d91578342caa56c05aeaa0c03e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e450fff693c94ed79b2f7ac6cb5eec63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e45d579a66ac45e3a2aa148505547d67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_063734ec216145b282d43a95a72bd28e", + "placeholder": "​", + "style": "IPY_MODEL_1baca642e3944d6a879ba493aea7a7fa", + "value": " 1.42k/1.42k [00:00<00:00, 6.92kB/s]" + } + }, + "e45fc2bd193148fa9312f1385a18e44f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e46054c96e2c4a9e99cba754c515c4bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_91fd39518bca4100b9d2f811d37e416e", + "max": 3281, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d276e62ebbeb46deb8be6990e53e11ad", + "value": 3281 + } + }, + "e460ea4315aa4da484d726167a6fafa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9c388a074b004f738373b518d3bd3ff0", + "max": 157052, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_aa4fc088d39b4637b2dde476c923c292", + "value": 157052 + } + }, + "e46f30686e834ce6aad604bd011eda88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e49c560dd928416e838b56a45c5083a5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4a2f6a8c3b2427eb80b4079db2ca6b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4a42e063fb8450bac61a2fa1fc9978c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_54c11e84b11046ce98cc7fe4dc3f5363", + "placeholder": "​", + "style": "IPY_MODEL_5e43b9d2a08542049f3a359ff5e9e615", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "e4b1dd2d8f1644cd99738d60d9e22d32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3efa7873f5064a6b863496f7a63daf4f", + "placeholder": "​", + "style": "IPY_MODEL_8ea2f2860e2a4c60ba566864b80fda75", + "value": " 2.19k/2.19k [00:00<00:00, 7.68kB/s]" + } + }, + "e4b79b803a79468ea486d2e803ac2b4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4b93724e4bb40b1a7bf0d52ba497c06": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4bbfa84904b4dccb152adfaf04abb6a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4c1e6e503e74bbea3073f307b9dfdde": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4c40f79de824ac58ddbbda33880bcba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_098d4797b91f4cee9571f9fc4776fe43", + "placeholder": "​", + "style": "IPY_MODEL_c06e9e4ba9254bec8278078ee7e7775e", + "value": " 3.59k/3.59k [00:00<00:00, 7.49kB/s]" + } + }, + "e4d2c29c561147668ed69e4a6bb49405": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d746aa10e0be4dd39e9efc21fb70d6b5", + "placeholder": "​", + "style": "IPY_MODEL_86b099e3fc384f34ad304d20ea9b1ed0", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "e4db82deb62e457a8d225049e5ddb48e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4ec977da5f6424d9bfa8ad72d7f51e2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4ecae76ae8048779ed2b334fcc8d530": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4fe1b39345143d0bcc7404b6f22a5b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e4fe9ec58678410998887ad20582920a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e50d12b921dc409b99eaba5004ad0b57": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e50d56818d5247b59669c863efd2408a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e50f4e3504384b02b774757e4b22ea2b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e522614df693440db36884ddfd08d1e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e534e4b7c83c4908b015b07f02f81e7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e535c5e7c89d4741bd869dd43f96096f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e53b38b077cc4915ad322576737bd316": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e53bc1b6441746f2a53e6b949b375e66": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e54ab1ae78784e81b1e78ab0734828f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e55eb0d4fec84a3a81cceca3bb82d30f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e55faca86deb46b78ef742f233c6d245": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e5667fda338c420f8e1571798c45b206": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e56bf30ae89a4e98a80fc6ee88a68df2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5720ff0080842629652d5b37c19c210": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e57234779448462184e0a127ca9bd8aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e58e11fa2c3645738f7eac579a49fe94": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5996fa272ce44aa8fbb5f4a6fa7c3b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e5a6d761b2d74731899a716c1bef22c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e5a84fc09d3640f89cedad955b2d76b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5bf6dad18344d479a7a9d014dea71e2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5cbc3594dc44154b401e165e8c4741c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5cfd5a146604c668e24f8fc55becf47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5d4b85ae3d4409ebaa4c84e6d9d14f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e5de1893b42e49c992c01fcb6a616184": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c8348697c2354c35b551a457e1a73c4f", + "IPY_MODEL_371365ea7cc842d7bcf4da790b57f7b8", + "IPY_MODEL_39252eed697d4b549f3eb6bc0f728b04" + ], + "layout": "IPY_MODEL_808fde7efac8416ea750b85e4e06efd0" + } + }, + "e5df13b05641409ba61803834bae581e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5e48480452444de8187bd97bec2a617": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e5e8d132aef74190a397d6046e24f807": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5eab57d3616448590694bc7fe8a3695": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e5edc206686a425485cce4d8ae935256": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e5f138093693493c98e7dfb496c3e075": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5f450e5ad78495f8e07e6bdff5d1b68": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5fa52ad015e4ecfb2a79a939c1b5c60": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6022f88fa4448c0997df7763c8acfa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e622cc2cb6e84853beaaa86affcb90ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e625cca5301249249fe86f5ae1b64a74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e6534015d0254b8bbdc827d48632d20c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fe8432f6fff54c1a967649fe883cde02", + "IPY_MODEL_4e89244489d2418399e62b3efef3a112", + "IPY_MODEL_a29b7e1a2f794805acc7bf90e6196ef2" + ], + "layout": "IPY_MODEL_c2277045edf74a138348b1d5a7cec66a" + } + }, + "e654b581409a4207aba66013cdb48b8a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e6552baa43304e5193ebb7def2f40ce8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cded2235eefc4e579efe5fda26667253", + "IPY_MODEL_13794a28c987439cb8660c6ec8ade023", + "IPY_MODEL_7b3f0c64fb1448e2bcadd44ca6e854d4" + ], + "layout": "IPY_MODEL_ca127c8431f04c578552af9b988d8941" + } + }, + "e6553793625b49e8aee0b121e8414223": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e65969f558374d459ad7ec6799ff8a1f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6675eeba2884c28b59c5ac7df485d15": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e66c7fe293254973b4bed8043b5ecbe3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e67b2ddaa6554f65ab929d287415f098": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c3848f3665ad468bad4c813b4398e548", + "max": 4059, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5879acd059614671929570b1e133186c", + "value": 4059 + } + }, + "e697ed9a27654418beebc683faf3f8c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8387f8d6209e41768844c5b85b5fa61c", + "placeholder": "​", + "style": "IPY_MODEL_5d4c87bc8fd547e39fcdf9f9122b6ee7", + "value": " 1.74k/1.74k [00:00<00:00, 10.7kB/s]" + } + }, + "e6a93481a3a243f29dc2293be877daa4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6ab3669436949299aeac0f421f31326": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bf2b1d5dbe1545a3b64feaa37285ebd0", + "IPY_MODEL_df8e996799894e29b5db260b70e363ab", + "IPY_MODEL_e4c40f79de824ac58ddbbda33880bcba" + ], + "layout": "IPY_MODEL_e16ca6a8d7644551843f4189f523d608" + } + }, + "e6b2412f729749b89e8a4576b2cc9e8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_094aa79ed1674519b37d3d734040d332", + "placeholder": "​", + "style": "IPY_MODEL_28cff1f12a7b48fba1b397c8c5d790e6", + "value": " 1.78k/1.78k [00:00<00:00, 12.9kB/s]" + } + }, + "e6bb5e9583a84e17b8db7166bfb52190": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e6bd84d34ae644e6b2b1c33945476eb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e6bdb25c4fa845b79b0cc3555be9caa6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6c8d0b261cd4f67ae68dab713c6ac65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_846e10b634304f3f9c857808825e08a3", + "IPY_MODEL_95be018529964c0fb7881d589f3ed6fa", + "IPY_MODEL_7770f7787a6845779a4e6bccda4ffb5d" + ], + "layout": "IPY_MODEL_a277a0fcea0f4788a4910237d71c8ac8" + } + }, + "e6f00cd5115348229cdc350b70c78239": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e49c560dd928416e838b56a45c5083a5", + "placeholder": "​", + "style": "IPY_MODEL_6c9dbe173ed64c338edd5230b13e10b7", + "value": " 157k/157k [00:00<00:00, 1.07MB/s]" + } + }, + "e6f9ad8fe8de40e7a85a1a6268cd6e47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_36974fcc3a144ee4af4e14a01debe248", + "max": 2091, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4d77ab3b93284ea3ba191a8edc00698f", + "value": 2091 + } + }, + "e70425ba92584b6caaad7cfa74f4e2cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e719165348854f0aa947a61cdd90388d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e72696eb834343099b1d5c6ed3e05731": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_53476ac7279c4f74b979f6a2b59c0958", + "max": 2953, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fbded70a21764671a3e9a1c22e0caa85", + "value": 2953 + } + }, + "e74c3b0227814855aa3d32f80d35ae83": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4cb25f8cfbb54ebbb9adf9197ebd00b3", + "placeholder": "​", + "style": "IPY_MODEL_d19fdcaf3445439d9489079f609e0649", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "e75700e91b904c1ba0b1bb99fb896fa5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f3711fc09ed6465c9945212c899d7403", + "max": 1580, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8c5fe0a361544b3b8e152e1d90cdbc3d", + "value": 1580 + } + }, + "e75a6481c3824589a0a77c8ed31a672d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b46b02dbc6f34dd98195713c624471ab", + "placeholder": "​", + "style": "IPY_MODEL_164bc9614d1542429336585bf1a086ab", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "e76f752468e94e509a5ca0540cabbf89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ac61caa3d9b4afa9e84e0030b6fe209", + "placeholder": "​", + "style": "IPY_MODEL_b0257016f562414da9755ee75cd96ce8", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "e77ee40efe074359a4dffdfe594d8f99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e788f146051c467386b14eb1a2acdaec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e7adc274284a4769b2476e8c8cc6d4ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e7c2408884f848c9913ca35ffd48cf7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e7c719191fc744e68d0482f5320177f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e7d90e411cc84b6ea84c2dddd564d2aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e7e09f2eb9f84631826715a3e35a7fed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c1e680bdc4084555bf4a73a72e2d6e3b", + "placeholder": "​", + "style": "IPY_MODEL_726063b933d34480a3ffd4ed226f614c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "e7e1f4d95cb248948fbb9901e109782d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_03dad5930e994984a18f0aae3f726e46", + "IPY_MODEL_43c961fc8fd84aada7ac6a7e098b5f25", + "IPY_MODEL_775c5c12de294176b14b4bb303272eb8" + ], + "layout": "IPY_MODEL_ebdf0799e07c4de0be6c91bccf0a303f" + } + }, + "e7e34bd06ea94425854ab9722b05f5c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e7e7234074a04169814bbb3a17910ef1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e800ba72fdf5409d9b8614a27bbef8fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e82755178f2f4ef3a4f750f7c0b02b86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2938e42558d64c4d85e41c1882a36e5d", + "IPY_MODEL_d907e26889f1401db3934a1886fb368c", + "IPY_MODEL_6c4f77cd572741d3b0a0a17d0d1ef633" + ], + "layout": "IPY_MODEL_161bd046dd85409d93ed0a8fff1f168e" + } + }, + "e82dd83767e847f5b901783347ab41d7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e83f527146a0408591691927b99520c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e8555a5be08e4b478ef1f68f0cbd438f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e85613f0d2e94a249487b1ec603c7a68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_999190a0ee0c4a7c82ba8f915bc911f6", + "IPY_MODEL_d8036381b400416fbf32efa7bb05ba83", + "IPY_MODEL_efcf1cdd0b674f8fa62d9a84c55b77ec" + ], + "layout": "IPY_MODEL_005569397ad54617ae5e062961f8c116" + } + }, + "e8666de7950f46c0a0c9cf706976fdb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_568e8a357ee0424e95af5a3e2b47364f", + "IPY_MODEL_39f72699e81a44efb96064f8f6628afb", + "IPY_MODEL_cc54925a9f1c4ff697a629e797357f31" + ], + "layout": "IPY_MODEL_c096d81ee2be4c908662598a18d37d8a" + } + }, + "e87653b130ed4efc90101e9655ad0376": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e89eda21f8a1474987a01582aa8ef70d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e8a354322ca143f99e2f5f5b31433487": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e8a44564aa1c4cd6af0f6058254d6667": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e8a7618e62f44377aa8dcb6b38dcacce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8e355e45a6ed4979bb17352e8b9d1e16", + "max": 1972, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f59f45277dab436cab3ba5175be29bf7", + "value": 1972 + } + }, + "e8ca16c1962c44a9a3d3b85154c0c98a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_461907105a0045b596410c10b7c5aa99", + "placeholder": "​", + "style": "IPY_MODEL_2046754926644f97958db1e1d5ebdeb3", + "value": " 3.66k/3.66k [00:00<00:00, 25.1kB/s]" + } + }, + "e8cdfec953dc41eba4eba35c90bd5c85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e8d60fed2eab4483aff596f6285d6e76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e8e1a23a16e74aeca193e9b14915c7aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e2775ec1af3c48a88b669102f7edd47a", + "placeholder": "​", + "style": "IPY_MODEL_0cbe98782cf54922a9425511ba0f7731", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "e8e56aeb96754016a594eba6079729a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e8f8dc14ba0642c3bdfff97218ac76e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e91953d1c7fb4aaca76034b576a121f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e91a9d6f93124b5eaa016d57ffa77a0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ec0306be0343471aa4589ac0d26564a8", + "IPY_MODEL_5f285ffe54314b5597c3ef8d2d1643ba", + "IPY_MODEL_d4b84cea652847cc952b26fb4aa89186" + ], + "layout": "IPY_MODEL_6a952c52a5674e79bdf2565e75e57371" + } + }, + "e9237a5176024d5796f9d5f6903be69e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a821cd1a8ba47fcb7c096d615a8b26f", + "placeholder": "​", + "style": "IPY_MODEL_4653ecbca1d54ce1a453803b4b5450d4", + "value": "val/images/all/DOP25_LV03_1301_13_2015_1(…): 100%" + } + }, + "e924bcc461e04c2db33bfa15293c4a36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e928b339fcad49fe8c40b221d2e4e785": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e932b0c7e729498e8d0f86148a98656d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e954fbef94b742e697c9abdddf2cb715": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e97517d697a94bf8a09bdb05f5f5dda4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e97c56b91f6149bdb05e62e84339ce5a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e981da87b70347f982492cdb60db515c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e98db5016d8d4cb99ddf18aff34c4275": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_559ad0a05af34ce591e31338c884cb10", + "placeholder": "​", + "style": "IPY_MODEL_0815f6b022ab4375aed98f6de7d2d767", + "value": " 3.69k/3.69k [00:00<00:00, 17.6kB/s]" + } + }, + "e9a2de02811e4f56887b01c30f02ac51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e9a45b9fd22b456b85f138e10254f826": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e9a7f27086234fa0baf8ce3e7847122b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bec3b37f03564ceca215a2def93c33cf", + "max": 1960, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3f821413b0444453b561a50544e07e7e", + "value": 1960 + } + }, + "e9b3ac1f93ad42b1aa80afc2b6e6c4b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e9b7dd8af5f54f74b7120f0f765c0fc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b8e6c99e368e4f8985c87018626e7a8c", + "max": 1029, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_760bf81784eb46e6b0b97c0316400c50", + "value": 1029 + } + }, + "e9e2a7e4154947799318d08a5f291a2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e9e3cd93394140d1842bf085f21ff3f1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea0c6dde625e4d01bfff2a469f4d98a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea24566834b3461d883924f88551d0ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6550dbc3f2384e66ad0d94cc0af8b753", + "placeholder": "​", + "style": "IPY_MODEL_a27cc97137db419eb8bbb9dfc5ddb4b3", + "value": " 1.99k/1.99k [00:00<00:00, 9.44kB/s]" + } + }, + "ea3dec75152c445fbfa4dfed3b382c82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ea461590be4c4f449ea11e8aa081dcb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_233325cd10bc45b186a5da5ed59948f5", + "placeholder": "​", + "style": "IPY_MODEL_2a4e4417154d4f42879a7b9a158f9a7a", + "value": " 2.82k/2.82k [00:00<00:00, 18.1kB/s]" + } + }, + "ea4abbf61ddc4861b3818b64fc8b60f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea4f80533bf04c67aed60dab85fe5743": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_921966af9b5e4eba899e4e8617d0273c", + "placeholder": "​", + "style": "IPY_MODEL_787f9882d2314d488dd65c3dafb84612", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "ea528b2f7bb44b1f9b48ca145972acbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1e2bcb1369484f479a6137ff1c34973e", + "placeholder": "​", + "style": "IPY_MODEL_38c97cbda4d1486798e8ec80f4966a53", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ea6a01e499a648e78fe516b32d7a05d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c9de3b1a3b2f465d84bdc26bb9b71790", + "placeholder": "​", + "style": "IPY_MODEL_dec9520bf7c0404387c17bef8781b0cb", + "value": " 3.84k/3.84k [00:00<00:00, 12.4kB/s]" + } + }, + "ea7d317db1ab459d97efdce0449d77ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9e0614c14e3e4672b4a6e86cf3e2e552", + "placeholder": "​", + "style": "IPY_MODEL_4062817416f04e3297fb36d9a2e88ff5", + "value": " 2.41k/2.41k [00:00<00:00, 11.9kB/s]" + } + }, + "ea9aeb89af234fd8a559264a4900ecde": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea9b71c45b664bec96857265e32e9f76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eaab736d30a04ba39cd46cc0a4b81e3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_109512ebc3ad4c9dbb724ef645ecd77a", + "placeholder": "​", + "style": "IPY_MODEL_94e34f9bc25941ff92c79f7ac582f1eb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "eab22391f959447ba3816f0eba6a8b0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eabbecf8c78b4723b3da51ad57e3de60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_617ffa9d9892467dae86ad5b0bbf0799", + "placeholder": "​", + "style": "IPY_MODEL_d085833ae2ed429d9e588dd512b42d00", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "eac0d8bbf8024e89b6bd091bc8b6d702": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eac63cc53b9a45bb994225174102d13b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eaccd1fb2e1c41769ae017e85f482175": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ead71620cbd645d59593252e79916502": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b4bc10fc49a04c8f8d39e9f2d61c3ef7", + "placeholder": "​", + "style": "IPY_MODEL_94ccdf8357de4bc692918fc931ca07c6", + "value": " 1.77k/1.77k [00:00<00:00, 9.67kB/s]" + } + }, + "ead887bedf71461aa5375e2131e87b95": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eadb0941f75f4879b454498990b8eeca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5bef949c68e0410b9692e6b8a6634042", + "IPY_MODEL_b11a79d42e944b4d9668c2e33f4f8231", + "IPY_MODEL_6d7b8ee5cbe2441499121a838681bd0b" + ], + "layout": "IPY_MODEL_62257e013ea7432c8fe17e61087e3571" + } + }, + "eadd5ef140d6486aa8bb46289b65cc0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eb0f47e48c544b0b86efd78a02f783a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fdead4d6787b4abc878efa17710f9ce3", + "IPY_MODEL_9c68a395eb0348bca7361e4ff9a9da91", + "IPY_MODEL_4360b7db25b24168b896ebc1fec4cdef" + ], + "layout": "IPY_MODEL_8f6831ee39f54df486aec11189011b0f" + } + }, + "eb13db3c3ad042df8b9c469a069c6bec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eb1fc1769deb4cbc87f8c99da23353aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eb244c124dbc4725851fa704d867cbcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eb3d549204f347d194ba92f8595c22fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6298e944f79b4dc9aac6c019182e3443", + "max": 1719, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bd8cf72edf164cd8bddf6f319164975e", + "value": 1719 + } + }, + "eb3dfb287f9748a1a99eb48084b23720": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b29172ba8d2e45adaf373d5db694522d", + "placeholder": "​", + "style": "IPY_MODEL_dd108e816ce641c190d7fe6105facbe6", + "value": " 4.33k/4.33k [00:00<00:00, 25.0kB/s]" + } + }, + "eb4489f1c02948fea0d8a937e92bdf49": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eb47b66aba55493babfccf55eb9b4dde": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_306e3b27f3cc4970bea29f1014f2be76", + "placeholder": "​", + "style": "IPY_MODEL_2b5b5c00904d432db4916690b376a532", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "eb57a4ff28e24ffba1958e853d576b97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eb61ecb0154c4132bb3ce8292891e2e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eb7cd9beab8d4179a0a7e772cbadb8ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e50f4e3504384b02b774757e4b22ea2b", + "max": 1822, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b357c02a391a4f8781548af1c6fb5718", + "value": 1822 + } + }, + "eb83a756a2e14835972aaf06491b05ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eb8abdaf73364e44ad833674f3bc4481": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eb8df350afe54d568a17416c4bce1cc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b1a77fc9b5647fd9393fbbb83524204", + "max": 1034, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e6bb5e9583a84e17b8db7166bfb52190", + "value": 1034 + } + }, + "eb9b04bfe00d4905adaa147db31ef3ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ebab26ca85fc4d22ae32d0fd99718e4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ebab7ead7528424cae1b06730d222ecb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ebb63ad4e2b14b1e951536f4a2b977d4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ebbd7cb8142b41eab30eb9344f9aa469": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_455fb950de084bb388bd2a56e513b8c2", + "max": 2382, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_174895fbc5ed4a8594014e02e43ad201", + "value": 2382 + } + }, + "ebcaba1b129e4f7ab16cf61718591247": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6ce7b2c355f94bcc81438e2c34fa51d0", + "IPY_MODEL_d7f4110550b94c6aaf5423fd3cad0e7f", + "IPY_MODEL_cf4e9bfcd2c041deb173a4195a22453e" + ], + "layout": "IPY_MODEL_6a8231fa803343efaeeb557c33e71be3" + } + }, + "ebd3a064cbd744f19279e5432b882f14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ebdf0799e07c4de0be6c91bccf0a303f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ebe1c9cb8a844ffc94ec25127479d342": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a01b623af50e4043b8adac80e083766a", + "placeholder": "​", + "style": "IPY_MODEL_d32eef1d67374892be8ef54bd0d6434b", + "value": " 143k/143k [00:00<00:00, 486kB/s]" + } + }, + "ebe957db31004ad585f3562a047ecf57": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ebf1670079d84ca28e2336a7cd09e97b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ec0306be0343471aa4589ac0d26564a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9539cf21c7844b1893a9c67c0136a4cf", + "placeholder": "​", + "style": "IPY_MODEL_3c10e3a7148d4e228a44e2d9bababccc", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ec03897d36654ea3b51075a3d853c4a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec06ec5e802e4cf2b186000139352f76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ec0a0c86ceb94caabd5482d3c08dbca7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f039c1d4199c4e979cf94c97719d26fd", + "IPY_MODEL_bc9ab3ba05b742e2a51674b644d105af", + "IPY_MODEL_e1b8b8fd530b4c0291dc9dea02cf083c" + ], + "layout": "IPY_MODEL_d6da603baddc4c3bbcbba0db6d7afd7e" + } + }, + "ec0e076ded3948d8bcc55dfd93e30f9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ec1ab92700514310bd160bb50e5d2c25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2f51ed752616490692bc16349142cf1e", + "placeholder": "​", + "style": "IPY_MODEL_790139771a45490f80feaa97b17d9b48", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ec409bc08cd2432c9b4e44177e583eac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3654a9f4d1c94faaa26760ad8a3a7d70", + "placeholder": "​", + "style": "IPY_MODEL_524eb8abe9e34c8ca2fd0a98112700a9", + "value": ".DS_Store: 100%" + } + }, + "ec46c84b1e534bda8c6b9298c9984839": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ec4a24cc9e96499ebdda6efedacd7602": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ac41e48101964256a68dfdf425d7216b", + "placeholder": "​", + "style": "IPY_MODEL_d23e4120db2141708ed8a84ca30ffb9e", + "value": " 2.12k/2.12k [00:00<00:00, 19.2kB/s]" + } + }, + "ec7a8abc11b84779b381dac1411994f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ec7c860f22624acbbef213de8e308035": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ec8e0fe983ec42d5bd3bed1d81aafd27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ec956412a5b84f85a670ca0ced92d068": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eca14a541519463abb7f48abd7f3b8c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ecae9399c14e4964afe57c6a74630549": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8203a8a680a84076b570ff8cb1a1d279", + "IPY_MODEL_daeb5c72addb426fa88e92721e283cf9", + "IPY_MODEL_90e22e5c064d49c98c7010602b3873e9" + ], + "layout": "IPY_MODEL_a6742cfa201d415fa808e01f2d85d9b4" + } + }, + "ecccb3ea1265494b815e327a236c88cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5b545742365e45f4b2d64f98200492cf", + "IPY_MODEL_430e15904bd343c4b0dda2c787222a6e", + "IPY_MODEL_8efc76cc9a9244fba23931e0ae961dc0" + ], + "layout": "IPY_MODEL_b0908f8f45fa4cf1b0c88d08a65422a9" + } + }, + "eccf0ea5acca4e7bbf7df22539bb103f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ce775da2cb8d4cc3a8ec3138876ab68d", + "IPY_MODEL_be4e9de04e6242748fd5ae5a31da7f88", + "IPY_MODEL_391c54a5bae7440c973423caddfdeb5c" + ], + "layout": "IPY_MODEL_b8c9633b4522422b9b0502c30d9211df" + } + }, + "ecd829b411514fdd81bbd8234054de48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bfc367718b3a4398ac976b974219a620", + "max": 1574, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_02439dc915e34d6f9c0fc024d0a8278b", + "value": 1574 + } + }, + "ece0e8670b7240c1bc634097d1798f25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a0e9f24284349848002a87535d65243", + "placeholder": "​", + "style": "IPY_MODEL_cef605e1bc6b44c3a36af2512d0770b3", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ece3bf641a844b2ab19d04c20e76d008": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cee77b29e5c242b3aaab8e503bdb1abb", + "max": 2122, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f0c0909f630b447382ef84a2e0fcd0cf", + "value": 2122 + } + }, + "ecf2d39201ed459d890b01f9c78d05a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ef64368ea2a348bbbd12746de13d6fc7", + "placeholder": "​", + "style": "IPY_MODEL_dab780965d9c489783a19913f4a4ccb9", + "value": " 2.29k/2.29k [00:00<00:00, 12.0kB/s]" + } + }, + "ecfda1335f9746308a58ea55ec92079f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed01f4a481444779a5dc8f1a4cca1884": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ed07e98444964626a1416743f13b08f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ed112c83ad9840d1bca2762166164a8b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed1391da2b76450b81abbf609f718582": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_20e7bc1516524ac69401c3be724c6203", + "placeholder": "​", + "style": "IPY_MODEL_7f78c2ac96104f108f4f0b27e754ffcb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ed16fdda30724cf9ae07fd89361192e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ab19de3630364e31aceae317ae1e9186", + "placeholder": "​", + "style": "IPY_MODEL_f20c6d5df9074016a1d369986382ea85", + "value": " 2.47k/2.47k [00:00<00:00, 11.6kB/s]" + } + }, + "ed1b021553aa459590ccc78ae2d2d645": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ed1e904be50d45bdb2afa358469953f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_32f90de9b6784b668e2416863fe7d73a", + "IPY_MODEL_ca61e1813cf247caba37415f5459f85f", + "IPY_MODEL_04cfc37d1f8046c886fcaaa76771b046" + ], + "layout": "IPY_MODEL_c3c4fe31d72f4d29967b9fd178341241" + } + }, + "ed1ffdbe74874c81b4310d92827b4cbe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed370a86fcf8418989f177ad443fa194": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ed502a9b444142a88ee3eca15a175705": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed6de05f26894bf3a71cfbab35a75862": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_28c82199795d4e3cb94458bc755be269", + "placeholder": "​", + "style": "IPY_MODEL_b04dbfeef9564345b9a68f935ae38b0f", + "value": " 3.88k/3.88k [00:00<00:00, 27.1kB/s]" + } + }, + "ed8529a8ab0a45caacb3271c36f99ba0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5b7a400a33b749d88682a99dce7be43b", + "IPY_MODEL_5700c29243cc4ca8bd09a2fe751be5a7", + "IPY_MODEL_52d58efef02e480cbb0cd7242e0235a2" + ], + "layout": "IPY_MODEL_da99bca13e9d447d8d9cef70563d720d" + } + }, + "ed88d8fb4f0a4438808bb1f1ab13e9ac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed8fbda2464c4bb6ae5a391552cc4b64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0a0651ad413f44e4b029daa2442888ef", + "placeholder": "​", + "style": "IPY_MODEL_627a30bf92294683a584443dd2c2f6d0", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "ed9602623e1a4534826c9b57dc06f944": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0ccfb9cd8bb54d18b443e630faaee20b", + "IPY_MODEL_e08d506c7523486782a034ceae874689", + "IPY_MODEL_e31acf009f2e4df28bb52e3014bc2c3b" + ], + "layout": "IPY_MODEL_4e05770f26044e4f9f8b034a4d22bf39" + } + }, + "edb3732fe7a94e63847aed0b8641dfcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "edba5fb6bb6c4846b1e5382b3607b50a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c5771d145aa04999a35ff5addd71ed4b", + "IPY_MODEL_cf1f454dc1e94365be7bf9221084a7c7", + "IPY_MODEL_50114b3936354f25aed5688e95dda430" + ], + "layout": "IPY_MODEL_59252e4617a549f19df6be4e31f9781a" + } + }, + "edc3b8cc74e447c2b9cdef4e4d2be6ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "edd5c8d4227c4780b9ec297e96d89700": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "eddcc438863e40938ee6df9bc1b93ec6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6a8575c5b3224e3aabf9d7120ef0bee3", + "IPY_MODEL_8f922de694b243fda8494e30ef79e212", + "IPY_MODEL_ea461590be4c4f449ea11e8aa081dcb1" + ], + "layout": "IPY_MODEL_973ab01368fd4ab8b228d150f3de7da3" + } + }, + "edecbf56a6894732bb87d2b8f38d1261": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6b4b395518584094afeb1b91c3a1ff24", + "placeholder": "​", + "style": "IPY_MODEL_324bcce13f5243e9aeedb977e09a70e6", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "edf3d942345f4a368ad868fb823a44d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_28d81097487e4f288a626fd55d7af6f9", + "max": 3178, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_25c762810d8a4f3bb52115adfb09ecee", + "value": 3178 + } + }, + "edff2c7792244ad5a7d95170069833e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f29aa35b5da84e4f9728d5b650beaec4", + "placeholder": "​", + "style": "IPY_MODEL_fd115290b9414198a5337fc18878b59c", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "edff3bf033ab45679e518f942fe86864": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_36395b69afda455c9ff2a8657f3055db", + "placeholder": "​", + "style": "IPY_MODEL_1bd3229ae14d419096a5cbb502785f18", + "value": " 2.95k/2.95k [00:00<00:00, 12.6kB/s]" + } + }, + "ee15d375e4d2443ca98e579f208a8ed0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee18abdec5804d74ac0f35e55635c4c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ee1af378e6e44b92835f1682ef857109": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_610c6cefb5fe4c7c8393baca992cf445", + "placeholder": "​", + "style": "IPY_MODEL_03072f4675024e988eab2342861e3cbd", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ee23de0d853648d2a3122ef92558b104": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee242d8b6bbc462eb394c3bfc63e4132": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee26360c9c314a1abcf46756072d1596": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee2acf4f69ba432687bf41aaea63926e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee30d9251aaa456980c79d7936eb1a05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ee3b15fac27348a88d0b82367e4572a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee457b092ce64cd09fcaabaf7a171132": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_acc974a385d141c094ade00b24b3fbf2", + "max": 1806, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b30f6ff19f5449e18c07a963b5915415", + "value": 1806 + } + }, + "ee5cd6b4d0a14c9bb8e6e4921c279aeb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_70ac8924ace042e984c0d60cfe3be42c", + "max": 3057, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b1039c64ccaa4f118836a8667b80885d", + "value": 3057 + } + }, + "ee5d9f27b149417ea211306894d2acfa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_063148cdfac64123bbd11f1477b71e88", + "placeholder": "​", + "style": "IPY_MODEL_2bbed93524e44e99bc1aea543ee4bd59", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ee622b7999434b33aa45a3acb8b53c80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee65a4958c43430b9eb1d2564b99770e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee66c6eab08347f898e2f73d53fd438b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee80731d4ef444e6971fcc647e28a809": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee813fbb35ad42b8b79c46c33fbb3dcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3596f3fc3e4e4520bb77ca50c73a05db", + "placeholder": "​", + "style": "IPY_MODEL_854d0921ce1349b09ec268206eba0a79", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ee8e19490f674f7b8ff9983686aae74d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee9a760fe91e46429c3318274b40b6aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eea03490657647faa7fbd4c646c225ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "eea86e3f0b534635baba9658db8bd51e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_215ac19920c54889850267b19856ea97", + "placeholder": "​", + "style": "IPY_MODEL_4f42aafdeb79436f8569b6952982b332", + "value": " 2.19k/2.19k [00:00<00:00, 12.0kB/s]" + } + }, + "eeb0a452e95b42ae82086e37df8135d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eeb121cc12e54d4bb270c70a312e3c56": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3758377462934d0983bd5f942470da6b", + "max": 1449, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9e6607ec145142ca90e71192e179800a", + "value": 1449 + } + }, + "eebfca6973dc472e8ac862196d1a75d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b28f9b3410b46f2b7bed76ab92cb380", + "placeholder": "​", + "style": "IPY_MODEL_5318fa94dd56428b81519cdf8700361c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "eec4d6285c1849338b3181a7deb7a0c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eec5fdd080d74996acdf1b13b23c038d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_28a72aabd82e4617b380656b5fc11098", + "placeholder": "​", + "style": "IPY_MODEL_1971ea9ace2a4a70a042241a7b874ba5", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "eee2ede7cc3d44bbb984a71e41574f09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eeebb647760a450890df086a26ccf123": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eeedfb5dd5a147f7bc934a194c48645b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eef85cc094024d30ad0a7de80ccc53b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eef9a886afc6429fa4d16df7d40145e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ef032d76083e4feb85bdf35c8da65dfb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ef046ea175444331ac5bb0f6f8ea9269": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ef154f498d924d6088fd01414a5043f4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ef1aaa1881004639b50da1cf8daecd95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_337acd01213c4f589388761ffc1e5dbc", + "placeholder": "​", + "style": "IPY_MODEL_601fa9b50ae94cad8c411e22860fefee", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ef1e3e8e1d744e5aa7b0bda2f77ec6d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_abe31dbaed344cdfb8c7ff3ea5d83e73", + "max": 1000, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9911462630384121b857622176cd2f9c", + "value": 1000 + } + }, + "ef22120b94db49318db350f6178cd35c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8b188bec49574a8988f8a0e6e2daf5d3", + "placeholder": "​", + "style": "IPY_MODEL_3dccb2289f4145ccb9803fd49d1a8c9e", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "ef3aeb961663495fbd207b5757db6343": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ef43291c1c054539be42678c3f1b06cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4b7c5f14b6604805bf417588b78d2899", + "placeholder": "​", + "style": "IPY_MODEL_9727d0e3e3474e4cab6cee8641e3eebc", + "value": " 4.06k/4.06k [00:00<00:00, 28.8kB/s]" + } + }, + "ef45fe39689c4281a674fad9edb94037": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4a7204ec1cc847f7b0b9b635f29476b8", + "IPY_MODEL_8ef546e1d5fc4ea89be7e64d2e30fc01", + "IPY_MODEL_1f5040d55fbc463f849a70cd35ddbb87" + ], + "layout": "IPY_MODEL_d80e9d142a3a4a75987ad3bfea830771" + } + }, + "ef5ddbe34b48404a9dfd454a83fd2829": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e66c7fe293254973b4bed8043b5ecbe3", + "max": 3484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_135bb8cbb38f4cf7b41ad5715de4c7a3", + "value": 3484 + } + }, + "ef64368ea2a348bbbd12746de13d6fc7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ef6b17be94074586bc6ef055a46c8404": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9cf8ad9bef3b430b857b53340d46ba99", + "IPY_MODEL_2278a648e91d4162b9a4e8d801d01efe", + "IPY_MODEL_e36d5dec9c844c569f95938b08d4cab6" + ], + "layout": "IPY_MODEL_9f552994802841e182eafd893a2e66a4" + } + }, + "ef96f74ebf9f4f3ebfc80f450f6bb6f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7fc34adf4dee49fd9df1d354370f0bf0", + "placeholder": "​", + "style": "IPY_MODEL_af33fa9fab8e476ba156a25e8c582907", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ef985732896b4fe2b76db62ac4207fec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "efaa5a5449814220ac8506f942c5657e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "efae1cf41a1a4d3caac840e8a4182aa1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4fd8cb7d530d4614b455f40be1728866", + "placeholder": "​", + "style": "IPY_MODEL_6aae09158fb14746bf40d4b5ac15c569", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "efb7296509b5446eb0e2c170706abe28": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "efb7457baedd4b5a93140453560619ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "efc95c5cbfc44eeebc9736da96640452": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "efcf1cdd0b674f8fa62d9a84c55b77ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9222af4dafe647d8b2b62a8ba21b1242", + "placeholder": "​", + "style": "IPY_MODEL_48ea56cf8b064d68ae8afa93282ed711", + "value": " 138k/138k [00:00<00:00, 801kB/s]" + } + }, + "efe4d9cb66bf44b3b39f4657543e3dfe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dd845b6bb54744849872e6236e7d3a1a", + "IPY_MODEL_ee5cd6b4d0a14c9bb8e6e4921c279aeb", + "IPY_MODEL_ab239916f45046c68ebf3d4793a53fb7" + ], + "layout": "IPY_MODEL_973c9e95f279499189ab90bf7e356ede" + } + }, + "efe74bbfd70a48739462874b8c4b59a4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "effb4783513640ba880117ed01e7580c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "effc25e66a68445c9698129ae4ba20c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "effe5861b4aa4be09dfc52da8449daff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f015de370343469aa38381b2c92a8f89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d2e45d8be17349268176e3b39a30387a", + "max": 2100, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7ea2983a7d8f416792ce6bea1718e52f", + "value": 2100 + } + }, + "f0206caa22374965bf0d0b6861ae8f60": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f026fbf1f7b74294b4c8853bc5f6c5ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f039c1d4199c4e979cf94c97719d26fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_190e699a19634ebeb05acd72c55f8e55", + "placeholder": "​", + "style": "IPY_MODEL_ae4d4584cb4742558cdf869950c01feb", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "f042856c6ac240e2b0341306d4597a65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f04a49cc023b493181d3ee229709c060": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f0564fa9e5a141da9f96b09f917ce9da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f0626483e4c7431b8029015ba199849d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f06490569e5343db87b7f8a15d9c2a9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_96aee07a9e5041ce978571a4ff65960e", + "IPY_MODEL_ae85cc83ceaa492085de672255f930a0", + "IPY_MODEL_3d8ac01bafe14f97b849828732223f7b" + ], + "layout": "IPY_MODEL_db69e36f912e48eb8f1ede1cba4bf965" + } + }, + "f07553620a324a6dbd92405f6807d52a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f07cc501e32c4ba7809a836f4cf587c6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f088f59f1c5a44e6a2c952d133000948": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f0891d3038814cd080c0216d81aad744": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f0895f18c0da4b90b4f512e8b8788a72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f0af312c878849b39e962659b5e4c118": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f0c0909f630b447382ef84a2e0fcd0cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f0db9fc0075842f3a6c6621a2032abc2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f0df7d96d03e428c97deb46b431823ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_73a96590fd47443bb964334b454db653", + "max": 3103, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_904ece6e8f9849dfbb84bc1b8e53322c", + "value": 3103 + } + }, + "f0e2b69f02c54b76a7a94eab5a83a208": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f0e6b26d3a5244ba97e583c186f328f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_06ed3ad4e9e442888d0a7b87008ffc46", + "placeholder": "​", + "style": "IPY_MODEL_7e47f26d15b64875b3f535049c5d42cc", + "value": " 2.91k/2.91k [00:00<00:00, 14.9kB/s]" + } + }, + "f0eb4659ed924d29bd570ae7940cc743": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f0fd10fc1d9e40b99dbe4131aa497f1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_19b4d44e46974b9698e21682a4dd6b4b", + "IPY_MODEL_98a496e4cec34a52be5fc252d4d78088", + "IPY_MODEL_5887455e911b448ea129166540f92a87" + ], + "layout": "IPY_MODEL_152618c004e54089a605f86130596e75" + } + }, + "f10086878337467290ec583e0096e502": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f1182133c53e452d84820b98cd45ef50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ed3075fcb3b4488b67249ac8cf2973c", + "max": 1738, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c41abfdf452141569448aa044de4c481", + "value": 1738 + } + }, + "f12c4e03e810468492964a35f25f2515": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_25f1da87cc65484eac1de8d33546efd7", + "placeholder": "​", + "style": "IPY_MODEL_778b7ad8925a4fa7aad46835dcb57b87", + "value": " 2.38k/2.38k [00:00<00:00, 12.8kB/s]" + } + }, + "f1559b378b6f4268a85e4a9e26a0ab43": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f15e0f9665e645ed84e37f64b7b491d2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f16c678ef24245579a2bb067591661dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c567fa5d85ee4e64bcd6b4da0a421641", + "max": 6140, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3787d1bfb2224dd4b5d29797ab3aa34d", + "value": 6140 + } + }, + "f16cbc3a92fd4d0782b30ddbb4db3629": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f16f6e3070f846039b86abbad6b65046": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f16fa3d75a474a47b1f661a039410985": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f184a346582c4c668d61255195819161": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f19699814d12423a8045111db6a055f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f19c20f822614fb0b889d73574290785": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4e036fef93ae44afba8f0c7ddcc3072c", + "placeholder": "​", + "style": "IPY_MODEL_dda804296531400b92f710544b4a6665", + "value": " 1.03k/1.03k [00:00<00:00, 3.57kB/s]" + } + }, + "f1ab0f1f34664adfa9d0e2362adc56ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f1e2a8b2d1d04cd0bb6b79358f14f037": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f20c6d5df9074016a1d369986382ea85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f23c6d6333b24223a87e91b3ef5116f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af4a4f7a959b4901ba2e4116e7313ada", + "max": 3074, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_68c7cc0a8ddb471f953bfb91450d3a97", + "value": 3074 + } + }, + "f23da968069b45669d13ed544449afba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f24324565238444dbe3a2c305df2089b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_85080c2726c9465d85f20ff8b71fd173", + "placeholder": "​", + "style": "IPY_MODEL_25f092ced93a4637a70ce526489efbcf", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "f246ac19fe1a41cb9148a313f66b6daf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0941faf66f5d4fa9975aa63d7ad926ea", + "placeholder": "​", + "style": "IPY_MODEL_7093600bad454a5589efb814b9f1e9fc", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "f2553af5de8e410bbe53954fc27dfd1d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f26513e75ae4488a8fa09b72399a1e75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fda67b3d1c1d438b8cfd640f135847fc", + "placeholder": "​", + "style": "IPY_MODEL_66e57f760a1841e685152734af2520fd", + "value": " 1.61k/1.61k [00:00<00:00, 10.5kB/s]" + } + }, + "f29aa35b5da84e4f9728d5b650beaec4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f2a11d00ffe741898541a53c6380d7d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f2af6b2e16e2430a910d404c5e857a17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_db6a14194a9f4d40a15e527a4049e783", + "placeholder": "​", + "style": "IPY_MODEL_afd555f66fc64c1b845ad3228d6780ea", + "value": " 2.56k/2.56k [00:00<00:00, 17.1kB/s]" + } + }, + "f2c0fa1c90204130a1721f26ac0a7db3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f2dbe76cb2414a56849aad020092c4e2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f2ddef131b6c48279ad2bed01eeb720a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f2df55cf40fb4a858fd254065a26bf7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8367cdb0915443dc88f43218b16d6367", + "placeholder": "​", + "style": "IPY_MODEL_15ca26be4e51449298677cd34c3d04e2", + "value": " 145k/145k [00:00<00:00, 746kB/s]" + } + }, + "f304653b348446f1bd158dffebe16e31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_878dfdba3acf4fccada8d9c3d420bb7c", + "IPY_MODEL_c9c6993e5263437988d645e92a22e70d", + "IPY_MODEL_ca36cf37211445008fcc696068773b86" + ], + "layout": "IPY_MODEL_34c3b2b0e3de46899dbd0c4845a545cc" + } + }, + "f3048685518f47bfb17bb6606c936824": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f307e2f6478b4fc789004976ffe32f4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_070bfdc385f24cc59cc7d26422a3dda4", + "placeholder": "​", + "style": "IPY_MODEL_d9ac82bf717e4af6941bb516bdcf6955", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "f30a46062e68457eb3254c98fc2fce38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f3170150e89042f6a6b885438beaec0c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f31c7939eacd4de5ab66955e912330a5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f32453e2b47e40d7b41ca85ed25a1348": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f32c31282c6a40eca98bb8c597c84e7d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f34bc3d10342461b856c1235be42e31f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f352b51866434fe8b11edd075a0353aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f35925448f18409dae239d975b35428e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_abf4bbd79b354a25a83f3298309bae0b", + "placeholder": "​", + "style": "IPY_MODEL_f8e2c937889c44cb978b42bdc259e844", + "value": " 1.52k/1.52k [00:00<00:00, 7.83kB/s]" + } + }, + "f3668041960548e3be37bda53d474e1d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f367ad27b8c54a0bbf4297167067ce03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f3697558905c464dacc82f384fde10a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2b41f6d02f694126a90807604a3262c9", + "placeholder": "​", + "style": "IPY_MODEL_789a2ebbf777433fb2339b8af2f907d5", + "value": " 2.98k/2.98k [00:00<00:00, 13.3kB/s]" + } + }, + "f36c1b53da014bcb8b9266c503cb4ae1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f3711fc09ed6465c9945212c899d7403": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f381ca2255e44a369fd910f66828870d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2efa4eda841145609701202580d7d092", + "max": 2428, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b7867d678d9844ae94671576cc31bb88", + "value": 2428 + } + }, + "f3906a1dbb5e431e97503b2ca5ef8d7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_793f64fb3f8a4ebeb14615c6c9dbcd71", + "placeholder": "​", + "style": "IPY_MODEL_83025c1ea9df490f9c139673513cb88e", + "value": "train/images/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "f39a5b9c31a74dd8be4a2207cf78f6a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a9a24be9ad154cdcb850fdbd169b3313", + "IPY_MODEL_0b4c065929384c33be9a8a3bd7f03019", + "IPY_MODEL_783cfc22f62d457c8ea6e76a5114f0b3" + ], + "layout": "IPY_MODEL_b66a41cd131f4a6c8a1583dba66c47a1" + } + }, + "f39bbddb54594aeb8d62f8f596799676": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f39d3f07fd2547c39e9de088eedc57dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cfaf1f68cc1a48f6b9c20b6459ea9b37", + "placeholder": "​", + "style": "IPY_MODEL_bbcf9fa5eefa4d63aa0cf6afbb065cee", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "f3a6d6a3a50e4756a970788f0f5b96a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fb82925f762e43aa88feae298d6c2f2b", + "IPY_MODEL_73aabae894e84cefa72982cbdfa7d23d", + "IPY_MODEL_051f9dca91d346339d95c4e2502d8bf9" + ], + "layout": "IPY_MODEL_172187140d824835b1d9343535fa9b45" + } + }, + "f3aa03b83cac489fb8d7461be0bf3059": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f3acf59d433f4799b501037b09eff5f1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f3b32772ec6c4ef1b5710ca258fbf453": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cdaf6e1fbf5d46d880b651d7d4ec8538", + "IPY_MODEL_19770cec16a44727b2ae0e4fed9d89d9", + "IPY_MODEL_05248401683e4177abff5876332b88f2" + ], + "layout": "IPY_MODEL_fc6d106718a640e7ab68abd9ca4f64c3" + } + }, + "f3cc81f7aba04beda37d55dfd9a6acd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b5dd77b187cc4b5faa8bd1a7cfdcdc28", + "IPY_MODEL_c0e4efbd70324a98996b1a1a1594cbd8", + "IPY_MODEL_a9e1f367292444edb7f6401cc1545bd5" + ], + "layout": "IPY_MODEL_c7ddf498565e42bda9e4f5d7c0cef479" + } + }, + "f3dec8bca6e94e9d876061ddc7f70dc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6023b156869f4455825e409431ba3009", + "max": 2034, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_327db7ee8da94e6ba7cb75147dad025a", + "value": 2034 + } + }, + "f3e24d199f594a37b9cfb2f6b1d9cc77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_277165ff490f47ed8f3fd4141fe92851", + "max": 3030, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cc20fc6519d84f39aeeb0d5693019563", + "value": 3030 + } + }, + "f3e38e591af24a2c900e53f282c79dd5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f3f3af2db2224dcc891289725a3ae799": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f40583aed99f4f44835959053b971773": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_93c572d8ee1f4f7d8222784e5a6ce270", + "IPY_MODEL_a2a9460bc8ce4550aa7fdb50150b4176", + "IPY_MODEL_f6c54bad6eb740a48bbcbb63ed50b757" + ], + "layout": "IPY_MODEL_ba7f63e4892345fd9ef1c8d763edf7f8" + } + }, + "f407e40bddd943d08fb8f58bed5a0ff0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f4146003c6f8463f93637bc04bab731a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f43884f617dc44b5808aab1b64b5f9f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f43bb05bb1e2467ea677416b3c7dc8fa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f43e97c5934e40f7bdf315b837737def": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_36151590171d42adad3b2d4bf8257405", + "IPY_MODEL_2546157dff3a4503b825f64793200857", + "IPY_MODEL_975d3ddbcfe848b1b109c47ebd081b4c" + ], + "layout": "IPY_MODEL_22fbd71bde084ef3b8390f1c6a4507f9" + } + }, + "f44052810219462496d0e5c140aa60b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fa3d59160c444e0e87fd9710ad25e82c", + "placeholder": "​", + "style": "IPY_MODEL_3f03e60a2dc84ae68fc1d19f7fd67cb9", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "f452e15fd2374b84917ad3c67ce8feed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f45fd850cc3d43adbf08551faa65ed08": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f460c4cabe8f4394bc32d4a4d4cdd503": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f463926058a04395873c79f0ee391b22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b1d73df453df4827ada377cc4be5183f", + "placeholder": "​", + "style": "IPY_MODEL_ed07e98444964626a1416743f13b08f1", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "f48c2a29cad34418aa460a7633d013d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f499f755efb347ae867b1e51e671d909": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f49c6bddf9944330aa511b38fae96321": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f4ad3b4e11ee4015a301e1141b3ac3a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f4b76e10cadd4277981ebe18d21f8b71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b564f507f4d84871b56bee9953cb79d1", + "max": 3341, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1977fbabe9b245d1bb57bae987318226", + "value": 3341 + } + }, + "f4c779ed467d4bbfb87cd414f96b9ae4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f4dbd6ca71cf4346b2ec6db94169747d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b361d1126d24bb68dc9bdccd3789ff0", + "max": 2341, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_caa6010721ec4473a6c0db3f4761f59e", + "value": 2341 + } + }, + "f4e7a76de1084654a2b43e4261ab7d7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_63f331b144e84b608ab08c4125560a2e", + "max": 2842, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6742099a4ee34e6996a62655cf43f1f7", + "value": 2842 + } + }, + "f4efc605a18842f2be33436f4dad827f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a108943217cb462e8c1391aae80e36de", + "IPY_MODEL_047ecac8092e452f9906c0573861d4bc", + "IPY_MODEL_22d30a0f11bf438b8f4242e907acdff4" + ], + "layout": "IPY_MODEL_0e5716410bff4292bbf21905d99b2b2a" + } + }, + "f4f4532bbcbd450784b3c2e6103078f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f921d0a315046358625155f074a6077", + "placeholder": "​", + "style": "IPY_MODEL_76a7b024888c4adf90ad9323706d8ffd", + "value": " 1.68k/1.68k [00:00<00:00, 9.12kB/s]" + } + }, + "f517a882358e40d5b56420609dc2567c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d2f24be24b00462eb9ec032237656aa6", + "IPY_MODEL_388b455405814e65b650c2546ac76bee", + "IPY_MODEL_c92455b735b0418c9cd6e5e10c36e59e" + ], + "layout": "IPY_MODEL_f3f3af2db2224dcc891289725a3ae799" + } + }, + "f521fe96218f4b85b3e5231f23f6bb5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_04bafb219fe64766aaf5f02ad28f72ae", + "IPY_MODEL_9c84e32cf5d6473b8598fac0c88e4846", + "IPY_MODEL_73253e9a84b0482ab7d7240a77fb8a9d" + ], + "layout": "IPY_MODEL_ff49d356817643768b556709f805446f" + } + }, + "f5308b1ff3c3419f84cbac4c447e55da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f53c28a5fee1480583cf449b51e140de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f54ca68f48754cd194e8469fdc87a2eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5dfdf6b269e74b2e9280f8cd0eed8bc2", + "placeholder": "​", + "style": "IPY_MODEL_dfb00b49cddc4183b1cb820a86dee1f8", + "value": " 2.05k/2.05k [00:00<00:00, 9.79kB/s]" + } + }, + "f5500e5415b74d97b7bc3a72bc69b291": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f55b5c959ede48c888291bcfe6b355e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3462c6e8ce7147be80ae364a4c2baae8", + "max": 142844, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0f1d7c1436bb40868973cc524d52e86f", + "value": 142844 + } + }, + "f563428b3b7247a99b348e31fe7a7494": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f56402c312134ffd8354bff7a29a2767": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f5752dce14df4a9eb8d42f8900e7d7d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4946a56a07614f20b53a4b6bd1c0f5ce", + "IPY_MODEL_101f5e1bc7fc4018a36cf1e108fb5bdb", + "IPY_MODEL_9def15835d51428785d689e709ec37c5" + ], + "layout": "IPY_MODEL_754dffb1f0cb4708923b71a61f350256" + } + }, + "f58e60df0d2b41af8e406802b8f05315": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b45a999b8c841b2a4c21f63342c3d03", + "placeholder": "​", + "style": "IPY_MODEL_e45fc2bd193148fa9312f1385a18e44f", + "value": " 2.80k/2.80k [00:00<00:00, 14.5kB/s]" + } + }, + "f59f45277dab436cab3ba5175be29bf7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f5a3567ad21940098ae0aaa85257ef69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3bc4dcb54e546cd9043807b1501880d", + "placeholder": "​", + "style": "IPY_MODEL_deb6b57816f044e280d1a6bc206a7b5b", + "value": " 1.96k/1.96k [00:00<00:00, 7.43kB/s]" + } + }, + "f5a5c524ed754546b3ebd6c1f0e4ec84": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f5a90544c5004dad9ed5c80a0618f3c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c87bde0fa89f4324af8a25d20e76c938", + "placeholder": "​", + "style": "IPY_MODEL_6fbd1448ffb041b488abec7b24a46eb5", + "value": " 777/777 [00:00<00:00, 2.84kB/s]" + } + }, + "f5aa88edd79445a598c0fc8aabba7651": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f5af42802496449b9c29fb41fb5d9e15": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f5b0328391864b6fbf254cb84a36f128": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c0069eb4c22a4379a9e6945261a146ef", + "IPY_MODEL_c1e29e6a71e0461baacd4cfeea0c8ff5", + "IPY_MODEL_e697ed9a27654418beebc683faf3f8c7" + ], + "layout": "IPY_MODEL_8bab5469e3f546cba5df01f90cc9ef8f" + } + }, + "f5b4cd648c28494db75c64bc7a71d411": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f5d18c4bf8d44a72807189d2d28eb317": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f5fcee62bccd40519700c98fa49242f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f608595e3ca841b8a098f3851b225b7c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f60e4bbf22a54d52814e2b3ba38b4d13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f61435ba4b0e475091ce0e7f1ebe9796": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_db885bb8aa2a4173a80919ab7de6c762", + "placeholder": "​", + "style": "IPY_MODEL_fa20017d49ac4630b387f02b063e0d30", + "value": " 1.82k/1.82k [00:00<00:00, 13.8kB/s]" + } + }, + "f615b1ec8fd14f0082713b8e1460533a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f61e0473d9eb4e1bb2e5aaa281bb4149": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f63dd9f0693b4c3890cc8af1d7cbe611": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f640508b0553436488c27223b5ede2a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9a3ca082918a4716a7d37695b068acda", + "placeholder": "​", + "style": "IPY_MODEL_37e9729e3b66451ba840db503bbf6473", + "value": " 1.62k/1.62k [00:00<00:00, 8.85kB/s]" + } + }, + "f6434b5ffcfb4bfbacc2357cc036009f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4a340f6d7ce47f2a3a39d1ebacc0adb", + "placeholder": "​", + "style": "IPY_MODEL_8ac68915728747b4a9bf15dea4d544a1", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "f6481e43de7f40a0aba7cf5626c515c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f64f58280fd946b38ff184d023cff0fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f65025277a0a46029d696e795cbb9267": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f66427cbee42482c9504bc608d6d33b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f66f0cf11eb34ed4ab361829596bfaab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f677a024916847aa8330ce20d829b1d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4234f57e28834f21a526ba804f5cada1", + "placeholder": "​", + "style": "IPY_MODEL_d4cccea318f34c43ba23bd7c40fe2f88", + "value": " 1.61k/1.61k [00:00<00:00, 9.51kB/s]" + } + }, + "f678dda9b217428c9d8edc1544fb3f64": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f6876b975e8349f49bcf909c52f1fd6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f6904857e05f48948922d545d247ec10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f695e19ca03b4a248c4bb4b713c6b5fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f698a453828b40fd8323626210a44cd4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f699648f0c6c46d4a736de42c73a616e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f69e2da5892643538822f3fe2fc0b33f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f69ef9469c3b4f10b79fc2b81635e220": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f6a03c43118f477880c47bf55498be96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bdfd36cb7e374b3681fb266dbee612b5", + "placeholder": "​", + "style": "IPY_MODEL_996f2543e55e4aff8b0593e9ef268c2a", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "f6b848e211bf44159dcecb8cca6af229": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f6b8a0978bf24347b751c1c7c43008f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f6b8c8611c2747469aecd8e72e5e0557": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f6b91a0c6ac9460cb6d62bc883fddbcb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f6bdb7a2654549fe9726d2feb8f9d045": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_afd9cab7fb264639ad7c49d42eee3009", + "placeholder": "​", + "style": "IPY_MODEL_70832079707e4fcea00eb70a891f4e28", + "value": " 1.84k/1.84k [00:00<00:00, 8.52kB/s]" + } + }, + "f6c54bad6eb740a48bbcbb63ed50b757": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f01a3d5deb9433dbd2b5e9c6d64ab10", + "placeholder": "​", + "style": "IPY_MODEL_edd5c8d4227c4780b9ec297e96d89700", + "value": " 2.89k/2.89k [00:00<00:00, 18.0kB/s]" + } + }, + "f6c7c1df0af44d24a02316e43032d47b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5e463b7b2d044105a4113259f08224a1", + "placeholder": "​", + "style": "IPY_MODEL_23d0e69c4d654e85b79b1c3f9a608c35", + "value": " 147k/147k [00:00<00:00, 394kB/s]" + } + }, + "f6e8e6b83f9e4bc18b53e5c4e1f36691": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f6ea67f098f5454e9a1179d1473e5daa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eac63cc53b9a45bb994225174102d13b", + "placeholder": "​", + "style": "IPY_MODEL_80046b1dff0047da9b5bce0bf2a892a4", + "value": " 836/836 [00:00<00:00, 5.79kB/s]" + } + }, + "f70c906f37664c3d88a02e40b6bc0bee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f731705dec8640ec950c92ec5993ab82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f736f604b68f47619cbe558d54d89b0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f74938a026b7449aa10ce2a84a8efe4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f74c6a9ba4cf48b2ad6c29a6820a1916": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f754431750db4e4fbd00a09d474892ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_48f41b52dce94a12bb954680807f7061", + "placeholder": "​", + "style": "IPY_MODEL_4005a8b313494a668f7abf91c254c8a0", + "value": " 1.38k/1.38k [00:00<00:00, 8.86kB/s]" + } + }, + "f757b4b312bb4899aa70e2a14fe8e2aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f75cf6f7fb514466a68db9b86699bb72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f79fce8c195142459a01a514b7b36181": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f7abde07763948c4bfb6ac22bc315396": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f7b16989eaab49b589a2fc06691c1f44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f7ba9a7029d44aeab247c71190495f84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f80597d919ce4fdd984720e3794c5263": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4005e9724e824283a27cbe7a19e599b8", + "placeholder": "​", + "style": "IPY_MODEL_8e9fd64e98014e599328b8334f6afb17", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "f809db31fefb4b328202f3e39013661a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f80ea21655ed41579163385ff1c1c3d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f824b4b94cb84389b485b34398e670c6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f838bd4c03394780aa7ca86334f2aece": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f8471e7736014638a8b4d4f98fcfa068": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_abfa99231655401196439a83b0baead2", + "IPY_MODEL_d266bcd201f3492daaf990ca77c8cd45", + "IPY_MODEL_3331a526ab3b41c3850e94e878412fb2" + ], + "layout": "IPY_MODEL_dff10e013aeb4ad082e2f8514b5fadcc" + } + }, + "f8607237a89744c88e0f57482f629347": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f86b791386324fc7aa3a7ad29f75adc8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f879172baedd4b509ec11980be1ba3b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_500abb0a19d94124a36a771213fadb97", + "placeholder": "​", + "style": "IPY_MODEL_a1a31f3998f04083862b188f37fc0804", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "f879ea5166424f6ba299c711d399fd8e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a8e805327ae4122a43debb4f96db082", + "placeholder": "​", + "style": "IPY_MODEL_b32f43f96fe94edf99bf9dd8ab0aae30", + "value": " 2.99k/2.99k [00:00<00:00, 16.2kB/s]" + } + }, + "f87ab56c33ee44c6a36b27a5df00f133": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f8869e7046554c63b18662c11d0f48ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba48de07aeed4697aa7323831b79d750", + "placeholder": "​", + "style": "IPY_MODEL_a6d954eec50b42b09530f5b020c6e9ba", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "f89173c729734e8a8549b5578e717515": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f8b104aed5d54ac18aa8bbd43898623c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a74a44c253144c693a6315fc38c954b", + "placeholder": "​", + "style": "IPY_MODEL_d1ae94393e0f4baf95e7de1238b97955", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "f8b69d9ad9f34ce587b01e6ed3bccc51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f8b7e633bdf145c8b76900324facf823": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_beab17e991394579bbef6ed9d83244be", + "placeholder": "​", + "style": "IPY_MODEL_6e718220fe69475f8f81d5c47cc0cd0c", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "f8ba7ac1b82e4f5ea6fa36fe8ac3fb1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f8c1fea63fa746b89330fc9511f8aafd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_903fbe13d9d44ec98e226e8207130e6b", + "placeholder": "​", + "style": "IPY_MODEL_26d064797c7342a293e34d9f4db16e7b", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "f8cb9c39d1fd4de189d90ad505b954f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f8cc61dd2d7042299e819b0273e3c580": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f8ded9aac1dd4d6789b9596ef45a9c3b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f8e2c937889c44cb978b42bdc259e844": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f8e70a7c172646d5a68d969bf6969f50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f8e7daf0ce894b609d96160cd69adaee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f8f2b856620e4409ba3b743527e9dce0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f8f5b137ba7845eeb35ee01c36997dbe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_10743d2fb01246c5ae963e829eb63880", + "IPY_MODEL_f3dec8bca6e94e9d876061ddc7f70dc0", + "IPY_MODEL_9bc2c8a2bdfc4340a015d4cf1b1ae7ba" + ], + "layout": "IPY_MODEL_52bd9844a3e94d33ab22d54a72d1c7c5" + } + }, + "f8f92b260da5489fbf8af6f513da21c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f8fd79efe81843dab619222845cf65c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fc83a127c7b4447998481f2db28c7829", + "max": 2911, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ed1b021553aa459590ccc78ae2d2d645", + "value": 2911 + } + }, + "f93897132b4f433ca3778816f9fda4c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d89f62be730c456e9b34a5fd02d83316", + "placeholder": "​", + "style": "IPY_MODEL_04d2d3f07fc445d78677acb438fa1177", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "f95256528b544056befdb6ce3ff327e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2d8dc6fef40a4348a58158897fca6036", + "placeholder": "​", + "style": "IPY_MODEL_1c13b2ff48344f0d825633a75164e203", + "value": " 3.62k/3.62k [00:00<00:00, 13.8kB/s]" + } + }, + "f960434ab2f844319e42a6d20725d047": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f970356e24e14166868225ab53c15565": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f97c7271fb7a4a7395aec1ece6bd2ecd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f981887397434c4c9bba40a250a7ac8b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f9909dc8500b4787a61ee3cbff6c6b0d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_682ef1a4929a4b4c9b1c767dd8b67fbb", + "max": 3664, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6c394d7c540a4fbf9a69b80231eab344", + "value": 3664 + } + }, + "f9c1c7c353dc466892675f5bc0530d9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f9c88e446de944d3a3efb22ebd9f4cf1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f9cb189df8f94991bc9f0d617a9d095b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f9cba92d034e4c61926a2e47c76b5c3d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f9cfb174ed3543ca8d589fb33bd11790": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f9d479aae4e84d2a8dc12ffdd928f828": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f9d6562b8e7f4ea08e73d2f75f38b75a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cf68f5c3b9ec464b94062bdb586b889b", + "placeholder": "​", + "style": "IPY_MODEL_52d465243f1e4541be00fae7c0f59461", + "value": " 2.38k/2.38k [00:00<00:00, 13.8kB/s]" + } + }, + "f9e3a689beae42e4aed09d0dd145e90e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cec3c832bf3d452fb29f2a98610e108e", + "max": 1659, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4934b90531e143c688fe31f3fa6b40ef", + "value": 1659 + } + }, + "f9eb045af5294adba20ca72060496c59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0788a05015ec48e187263344f4c08ebd", + "placeholder": "​", + "style": "IPY_MODEL_ce62dd489ab14bd282712c24a64f300f", + "value": " 6.29k/6.29k [00:00<00:00, 31.8kB/s]" + } + }, + "fa0841a723914aaab0661ee0cab885a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fa1387525a4046d783519975c4a874ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fa13ee081cac4b7397934e2eaf700454": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fa187ea099624c1c896fd80e567ca41a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fa1b490e4f094a95a07bb8f44c25b571": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d6cdec2141847af9474c851722bb25e", + "placeholder": "​", + "style": "IPY_MODEL_4e91c44d120e4b9e8c89173dd063c41d", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "fa1f526fce074357a8305a57cfe09d3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fa20017d49ac4630b387f02b063e0d30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fa23f84a5eb94218a32d45714e4f9b83": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_65894031b0ab4a3f84dba2dece431d87", + "placeholder": "​", + "style": "IPY_MODEL_89808693a88c4d24a5f8d2b960daac73", + "value": " 2.69k/2.69k [00:00<00:00, 11.4kB/s]" + } + }, + "fa3d59160c444e0e87fd9710ad25e82c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fa3edb2a498d41d6b8beea7ed2b7f441": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fa4032a61dbd4f16b4a367a5ac75f5c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7c3a989cceb64e06b7595eb8cb542bb4", + "placeholder": "​", + "style": "IPY_MODEL_47f213b7371b4b4da597040cedc380b9", + "value": " 1.61k/1.61k [00:00<00:00, 8.09kB/s]" + } + }, + "fa490a912b9d42789c1e76b34b2890bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3a3e25aea80746b294901f8fae180a73", + "IPY_MODEL_3868bde5f3c549a8a60f03e5dfe2efac", + "IPY_MODEL_9fd485d535724588b11a16a9121c9652" + ], + "layout": "IPY_MODEL_3d7bceeb5996498e8c6ee7278c0b289b" + } + }, + "fa4d286277b442a7b0b805e3124e2f6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fa71f690ae9943ca8e28d2720268a70c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fa8f1c9ef17a4c7c94a8145b66d95c4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fa99f5bc587a4ec7b1e98ffed325da67": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "faa8daf782544f57a7408e744ae818e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "faac666abde647dfbde87807150b7429": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fab78a9268c24ee99cd244f52fc9f1b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fad3ba6ce4b9462198315dbea3c822dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb09ae7d5f1f42db956352663e477efe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb1dbc0bc9a54ca79932678ccca02aae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fb2120d753174f9dbf31d6ab83e33310": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c835facedd774d629c0daa17ac523783", + "max": 919, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8327c1e5f7024cec8aeee05b25cc80ef", + "value": 919 + } + }, + "fb26bb5b07a84b34b557a97ae4411b50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_973a8e144a4a4caf9664f7c0521f0532", + "max": 1784, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b05aa5d3adfa49559d457b3d6404c6e5", + "value": 1784 + } + }, + "fb3878f65a7a4da989d58663e3d5c178": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb3a02e2d3f44228bc74919b56aa40de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3283ea2f3e2d41c4b049f90a407a2b33", + "placeholder": "​", + "style": "IPY_MODEL_cc0abc38b4c04034971b230a90d24e5d", + "value": "val/images/all/DOP25_LV03_1301_11_2015_1(…): 100%" + } + }, + "fb3aaa0c9fb44de8939c65b32cef9e96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7ba36718aac54e0f817b667c6e0d588d", + "max": 1783, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b8d4814532984393bfdb810f6fa56b28", + "value": 1783 + } + }, + "fb544dfe5e0f4a69b28abfbf35a03a97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fb5d04eb75c84b0381741c88ad4103e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fb5fd5514ff84c29b3ed14e4542b549e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb63e39d077a42c79523fb1fa60e31c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3ca67f3cce984e6cbb5dc5080d23a65f", + "IPY_MODEL_823510d8b71a459e93e2e5dd1395ba1d", + "IPY_MODEL_33300317fbb2487d858665390308900f" + ], + "layout": "IPY_MODEL_829bd9ba29e74bcbb28ba08a703715c5" + } + }, + "fb6c1383aa044a3f8f330868fc70b17a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb79c300b960442e88a8912b4731323f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb82925f762e43aa88feae298d6c2f2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_17efbbd811f24622aaf16d0225536d6a", + "placeholder": "​", + "style": "IPY_MODEL_fef013378c7f4e899bd6303aa5f556b0", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "fb8325df7ca848eea0865c088e8bc80a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_48e94d05e160417e8e8f0772283c12d6", + "placeholder": "​", + "style": "IPY_MODEL_ae467a6858c342948a07e3a391a26b28", + "value": " 1.78k/1.78k [00:00<00:00, 10.6kB/s]" + } + }, + "fb8d79a8e0b04b36b0cdd643ab9254ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb94a555a86c416589f920e0ccac5eaa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fb9f59ce13ad4cebbaf2ab531a7edd54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fba27cc863a740a38bc0e126e0aa1b05": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fbac8f675c7c4402b6c4a3b3efd9a0fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fbae80a65d3843a08a02130cc6fe24a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a987b7a84a9c4ff892682a3f81a6efe4", + "placeholder": "​", + "style": "IPY_MODEL_40fe315fb6144c8fbf34bb9f7ffbae5b", + "value": "val/images/all/DOP25_LV03_1301_31_2015_1(…): 100%" + } + }, + "fbb4e99de8ab4f0ab43e75460c9968cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_46b1b90de72e4828b52427058e9932c2", + "IPY_MODEL_bc909e7e9c774a28b65573791e15250a", + "IPY_MODEL_1d7227fe8203445cabbc49ae74e7c933" + ], + "layout": "IPY_MODEL_0aa85b4bcb3a497a81088e3d9e6228e5" + } + }, + "fbba43b5593e489999e08f5231122a8c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fbcf9446ad504687b14417f0b52db9ef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fbded70a21764671a3e9a1c22e0caa85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fc01610df6ad4c45917067a766c617aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fc053f1571884e5aa26c97a46fe2caf2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5662f5808b44415a8b480ab8ae70b979", + "placeholder": "​", + "style": "IPY_MODEL_900862bc9f4648fb970842d0b24a685a", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "fc41f7f8d8ea41a69f5b1a3bd163166a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fc5fb2d941d14c649e6d8677c8909158": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_80db2671b0c64ce780f08d36f4018b79", + "placeholder": "​", + "style": "IPY_MODEL_5324f02757384ccba98100cf95a96e29", + "value": " 147k/147k [00:00<00:00, 779kB/s]" + } + }, + "fc6aee6f754d4d4d890ae29b2714909c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fc6d106718a640e7ab68abd9ca4f64c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fc702ad76ff34672a01729ee02bf6ca4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fc83a127c7b4447998481f2db28c7829": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fc86e40b95144f55806bfece59bf32c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fc8bd7212e0d43c08501f82b6d6d8a97": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fca3824059c444999a63b7eeac43c285": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fca3d305b6d44be292d61da5d5758c93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fcc61b5b8895406083ea0f771522dab2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f4446f8431741d3aec7c6fc63a23eec", + "max": 3900, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2769fdc4a43a4eba8d4ae133d0b46eb5", + "value": 3900 + } + }, + "fcdc54cb6af6471ab777a25310540a6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fce5077ffbba426aad6a25f6141bc69f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fcf9dc46152b4f569405ab0f37ab9244": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1f021bbf007f4d25864567f4b3fae7f0", + "placeholder": "​", + "style": "IPY_MODEL_4c25842ff0934ff1a5ebd7051002ca09", + "value": " 139k/139k [00:00<00:00, 628kB/s]" + } + }, + "fcfdac0592d441369da12d686d188469": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a09b2e57e4ed4d40a3b88e551309d084", + "placeholder": "​", + "style": "IPY_MODEL_9f0c36ac258843c6be0ff57efc4cf103", + "value": " 2.21k/2.21k [00:00<00:00, 16.5kB/s]" + } + }, + "fd115290b9414198a5337fc18878b59c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fd1aa8a0b57546a39c13a8f31b325cfa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fd27abddf5b5474d9d42e344bdc3662d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fd32a19ab7ac4d0c92d49d3092d61458": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0a0e10f223bd48feb85fad4c833d6393", + "placeholder": "​", + "style": "IPY_MODEL_f026fbf1f7b74294b4c8853bc5f6c5ab", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "fd397749a07b45e7aa3f80bdb4a1cc42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fd51777d567d443d9ddfba8ab4fda33e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fd6576585e9e4463b847e0bab3946adb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1a4b0175d8114e8b9681dfb32e3f00ce", + "placeholder": "​", + "style": "IPY_MODEL_340d7811de76421a88b366c562567a30", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "fd67f25388fc48feaa28eb5df9a04c36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fd824eef122d4f8db3b9fe87d5fef620": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7fc9e42c867d4bdcacd7534c7c75dabf", + "max": 2770, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d98ea71308cf40109ed36b4c1635a2e3", + "value": 2770 + } + }, + "fda67b3d1c1d438b8cfd640f135847fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fda9d091174a4308a3c3ba5c1ca02eb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ed1391da2b76450b81abbf609f718582", + "IPY_MODEL_4709eabb26fa4d41bd2032ba6207a314", + "IPY_MODEL_88e2a65380d54e0ca6467af1a923f117" + ], + "layout": "IPY_MODEL_9e9b1a7f1eca49d996daab4cee523a8e" + } + }, + "fdbfbab8564e4fb9aaf0428f5f66c4fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fdc53a5b87a849dda263479d3e3524c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fdcfba2bd13b4b8c835d02e7cd4e5b92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c952a796780a4e9b8542ee5be0369cd9", + "IPY_MODEL_98ed8eccabb2449fbb4a369dec687480", + "IPY_MODEL_fa23f84a5eb94218a32d45714e4f9b83" + ], + "layout": "IPY_MODEL_26185367b97f436f9b19d0fafa61a509" + } + }, + "fdd9ef5a709142f49c2222ad5524ac01": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ea4f80533bf04c67aed60dab85fe5743", + "IPY_MODEL_600ec83c6c134ed0b17155bdf87ebc76", + "IPY_MODEL_7b6f4fbf7e1e4751b5611017f36a9167" + ], + "layout": "IPY_MODEL_b20899b847ae47dab69e74a6e10f5389" + } + }, + "fddfb3e673d346bf9d01a8b51914d516": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fdead4d6787b4abc878efa17710f9ce3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_22e9a5ab137a44c4ba4260af2eaf2456", + "placeholder": "​", + "style": "IPY_MODEL_f1ab0f1f34664adfa9d0e2362adc56ed", + "value": "train/labels/all/DOP25_LV03_1301_13_2015(…): 100%" + } + }, + "fdf833d51a10422788b22bf921656411": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fdf8e6870ffa4579b00c22bbe2620249": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe05932be7df4f559a70b0bb7ca419b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_89a916ef42d7416eba57f69ba9d2fe32", + "placeholder": "​", + "style": "IPY_MODEL_3d74724a710a4a3cb80823384fcb8d6e", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "fe0680f0b124438583542a3a10a6523b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5165b89157e943a99657ea8bfe777f0f", + "IPY_MODEL_65907362b98c49408698a55b18c346f5", + "IPY_MODEL_b10974f4526446fabb3229dc28e22680" + ], + "layout": "IPY_MODEL_b0e7c268ac084512ab6d32ef7e0ce554" + } + }, + "fe0e9a3bc0514942a94d6a045f3ee5df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe220fd83d7e4a9a915ed231225c49cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fe3a2f68cc404f3dab8ba7184ecd88aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe3b64347dab41a2b1e19c842aa8daa7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe3c920b14be4a11a834eedb88aeb775": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_093fb0a30b084a49aebaaa8137f01b3d", + "placeholder": "​", + "style": "IPY_MODEL_ed370a86fcf8418989f177ad443fa194", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "fe4401b6c2824f65840bc20bffd0a72a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fe56b5b2e6414ad58b5a607a39bc37b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fe836c5d55ae41019294174927d41306": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe8432f6fff54c1a967649fe883cde02": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_365b057f59894c389413086bbb5f7b54", + "placeholder": "​", + "style": "IPY_MODEL_a5bac5639f4e48878a0527dbf60d0dba", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "fe8508d63612489bb8339f196b3a5290": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_832bc3ba78c24c39b8042e9b2c8f771b", + "IPY_MODEL_cc083d0afa6c405fae5e8aae709ddfc0", + "IPY_MODEL_de1e51c943fd45858469e29cbed94b41" + ], + "layout": "IPY_MODEL_63ab691e54cf4da594306020391dd865" + } + }, + "fe88b0b4f7f44f29a0752271cd2103e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe9579f8518449b2956936662a96b0b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a10b810a0a88447e9c75ec0fd6d6efee", + "max": 3119, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_faa8daf782544f57a7408e744ae818e8", + "value": 3119 + } + }, + "fea33ec7fab5489b90bdaa20c4c4c501": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3b3206f98a7a4a3aba34d29f86b09b6a", + "IPY_MODEL_898a666040444842af8c045c72dcc0f4", + "IPY_MODEL_418d4473f7514a1a8be59f437237e2db" + ], + "layout": "IPY_MODEL_d5af685d1ab44c68a579163759ac04e5" + } + }, + "feaa44f6f997446f9180402f0177d39c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "feac8d2b5a78450e90ef4216fcc433f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fec2dbc930544dc4bd39966474b9a512": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c11fb150fa6147ffa31a0964e7fbb8f9", + "IPY_MODEL_9c63572b045c4ca5a9a589e9fb27602d", + "IPY_MODEL_39d8decec2d74d47a8302db135bb1371" + ], + "layout": "IPY_MODEL_9fbe5cd1b1ca4d1b8b541e03b52cd4f2" + } + }, + "fec324a8cc5a43d0b340be5e0c7d4ccf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fec348f0b4c148c68462329045ce0906": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fec6e620898e4e77b27970bdb99fa1f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fec787b9c15f4bc3afdd6dd37a018bde": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_143e765c26004f658b5d464c3d3e9921", + "max": 1210, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_48fb35899e3749598074d237a3aece6c", + "value": 1210 + } + }, + "fec974b3c2fa4170b21bf492749ce9b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_71b27373c492446a97b3af5c73ad6343", + "placeholder": "​", + "style": "IPY_MODEL_fd397749a07b45e7aa3f80bdb4a1cc42", + "value": " 1.03k/1.03k [00:00<00:00, 4.64kB/s]" + } + }, + "fee1c9371bcd4d40a99359793b546038": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fef013378c7f4e899bd6303aa5f556b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fef063de0bdb4f9ebb128eda73750898": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fefd503d970f484f89fff225fba28a8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_67584473c8e74bab9b5bb3bcd2d4001c", + "placeholder": "​", + "style": "IPY_MODEL_3e7c2deced8f41e1bb94240c32a8ea92", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ff049392cc8c433b92fd2ca25a022475": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ff2b4b4751e04c768d7c5476a7598c67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ff445bee815940cdaf7fa530d590704a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ff4463137fe8456ca36191949b989645": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ac7d94c619b04d77a2829fde422a472e", + "max": 4335, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_40be5b3ad1874a709410c6e4fd341881", + "value": 4335 + } + }, + "ff49d356817643768b556709f805446f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ff69cd3405a04408b5ddc775c0a9157f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0918d3b788bb422b8579f947c672dc7b", + "placeholder": "​", + "style": "IPY_MODEL_80ca8e2c62cd4ddab8a9ac039df14327", + "value": " 5.06k/5.06k [00:00<00:00, 24.9kB/s]" + } + }, + "ff6a0b4dd61942fd8ce77b8e80ed64f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ff81cc209b8145f3b50f1d50edf990e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ff8bd07b517f4bc68873e32b3fffc3e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ff8eb4374e1e44fb8b564f8d4e52ecf8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ff943dccaf404c2f952170598cb4f258": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ffa7844fd78e4a6cbef5ca1c90881ea1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f452e15fd2374b84917ad3c67ce8feed", + "placeholder": "​", + "style": "IPY_MODEL_3c529cd7e7dd42cb8d462395a7cece36", + "value": "train/labels/all/DOP25_LV03_1301_31_2015(…): 100%" + } + }, + "ffbc9c4192f84b8683b343c942b14539": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ffc5f1d015bb409abd270e4c2d3cfe77": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ffc6c50175484c81a11758d517a89a43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d6ca1b792f674c81a6a8a30dbfb66e24", + "max": 2854, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dba338b8fb8c4e0699edf233f60cbfce", + "value": 2854 + } + }, + "ffd4a09e53364e7489940430ba524ba4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9b069609240e42d1a4b78cb3586b9392", + "placeholder": "​", + "style": "IPY_MODEL_70e6b6296e4f43dbb15bbe24b9cb56b4", + "value": "train/labels/all/DOP25_LV03_1301_11_2015(…): 100%" + } + }, + "ffd71f948d8b44f4b8334f05d9a3413a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ffff0e6db8ef4366b070cc081ed2a8ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a2f1bfc43fcf409d9b902002b7161e2b", + "IPY_MODEL_ef5ddbe34b48404a9dfd454a83fd2829", + "IPY_MODEL_9df86288ad4d4287b248751a6c8cce5a" + ], + "layout": "IPY_MODEL_a07280451b2c46d09cfa9dbe15f8a37c" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/fewshot_approaches_setup.ipynb b/notebooks/fewshot_approaches_setup.ipynb new file mode 100644 index 0000000..0716a4c --- /dev/null +++ b/notebooks/fewshot_approaches_setup.ipynb @@ -0,0 +1,1944 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Few-Shot Learning for Rooftop Segmentation: Approach Setup\n", + "\n", + "#### ATTENTION: This notebook is AI generated, and should be used as a checklist / orientative document. Information have been checked, and should be acceptably accurate.\n", + "\n", + "**Goal**: Explore three few-shot learning approaches for semantic segmentation of rooftops across different geographic regions.\n", + "\n", + "**Scenario**: We have a model trained on one area of Geneva (grid 1301_11) and want to deploy it to other areas (grids 1301_13 and 1301_31) with only K labeled examples from each target area.\n", + "\n", + "**Real-world motivation**: A city government trained a rooftop segmentation model for solar panel assessment. They now want to deploy it to neighboring cities/districts, but labeling is expensive. Can we achieve good performance with only 5-10 labeled examples from the new area?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0. Dataset and Geographic Split Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "/Users/giocopp/miniconda3/envs/DL-Tutorial/lib/python3.11/site-packages/huggingface_hub/utils/_validators.py:202: UserWarning: The `local_dir_use_symlinks` argument is deprecated and ignored in `snapshot_download`. Downloading to a local directory does not use symlinks anymore.\n", + " warnings.warn(\n", + "Fetching ... files: 2111it [00:00, 8405.51it/s] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset downloaded to: /Users/giocopp/Desktop/Uni/Hertie School/5th Semester/DL/DL-FinalProject/DL-Tutorial-giorgio-exploration/data\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from huggingface_hub import snapshot_download\n", + "from PIL import Image\n", + "import torch\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from pathlib import Path\n", + "from collections import defaultdict\n", + "import os\n", + "\n", + "# Download dataset\n", + "data_dir = Path(\"data\")\n", + "dataset_path = snapshot_download(\n", + " repo_id=\"raphaelattias/overfitteam-geneva-satellite-images\",\n", + " repo_type=\"dataset\",\n", + " local_dir=str(data_dir),\n", + " local_dir_use_symlinks=True,\n", + ")\n", + "\n", + "print(f\"Dataset downloaded to: {dataset_path}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 0.1 Geographic Split Strategy\n", + "\n", + "The Geneva dataset contains images from three geographic grids:\n", + "- **Grid 1301_11**: ~70% of data (295 train images)\n", + "- **Grid 1301_13**: ~18% of data (76 train images) \n", + "- **Grid 1301_31**: ~12% of data (49 train images) \n", + "\n", + "**Our Split**:\n", + "```\n", + "Source Domain (Base Training): Grid 1301_11 only\n", + "Target Domains (Few-Shot Test): Grid 1301_13 and Grid 1301_31\n", + "```\n", + "\n", + "This simulates **geographic domain shift**: training on one part of the city and deploying to other parts with different building densities, roof types, and urban layouts." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== TRAINING DATA BY GRID ===\n", + "Grid 1301_11: 295 images\n", + "Grid 1301_13: 76 images\n", + "Grid 1301_31: 49 images\n", + "\n", + "=== OUR SPLIT STRATEGY ===\n", + "Source domain (base training): Grid 1301_11 (295 images)\n", + "Target domain 1 (few-shot): Grid 1301_13 (76 images)\n", + "Target domain 2 (few-shot): Grid 1301_31 (49 images)\n" + ] + } + ], + "source": [ + "def parse_grid_from_filename(filepath):\n", + " \"\"\"\n", + " Extract grid ID from filename.\n", + " Example: DOP25_LV03_1301_11_2015_1_15_497500.0_119062.5.png -> '1301_11'\n", + " \"\"\"\n", + " parts = Path(filepath).stem.split(\"_\")\n", + " sheet, subgrid = parts[2], parts[3]\n", + " return f\"{sheet}_{subgrid}\"\n", + "\n", + "\n", + "def create_geographic_split(dataset_path, split=\"train\", category=\"all\"):\n", + " \"\"\"\n", + " Organize images by geographic grid.\n", + "\n", + " Returns:\n", + " dict: {grid_id: [(image_path, label_path), ...]}\n", + "\n", + " \"\"\"\n", + " img_dir = Path(dataset_path) / split / \"images\" / category\n", + " label_dir = Path(dataset_path) / split / \"labels\" / category\n", + "\n", + " grid_data = defaultdict(list)\n", + "\n", + " for img_path in sorted(img_dir.glob(\"*.png\")):\n", + " grid_id = parse_grid_from_filename(img_path)\n", + " label_path = label_dir / img_path.name.replace(\".png\", \"_label.png\")\n", + "\n", + " if label_path.exists():\n", + " grid_data[grid_id].append((str(img_path), str(label_path)))\n", + "\n", + " return grid_data\n", + "\n", + "\n", + "# Create splits\n", + "train_by_grid = create_geographic_split(dataset_path, split=\"train\", category=\"all\")\n", + "val_by_grid = create_geographic_split(dataset_path, split=\"val\", category=\"all\")\n", + "test_by_grid = create_geographic_split(dataset_path, split=\"test\", category=\"all\")\n", + "\n", + "# Print statistics\n", + "print(\"\\n=== TRAINING DATA BY GRID ===\")\n", + "for grid_id in sorted(train_by_grid.keys()):\n", + " print(f\"Grid {grid_id}: {len(train_by_grid[grid_id])} images\")\n", + "\n", + "print(\"\\n=== OUR SPLIT STRATEGY ===\")\n", + "print(f\"Source domain (base training): Grid 1301_11 ({len(train_by_grid['1301_11'])} images)\")\n", + "print(f\"Target domain 1 (few-shot): Grid 1301_13 ({len(train_by_grid['1301_13'])} images)\")\n", + "print(f\"Target domain 2 (few-shot): Grid 1301_31 ({len(train_by_grid['1301_31'])} images)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 1. Approach 1: Fine-Tuning (Transfer Learning)\n", + "\n", + "### Concept\n", + "Traditional transfer learning approach: pre-train a model on the source domain, then fine-tune on K labeled examples from the target domain.\n", + "\n", + "### Methodology\n", + "\n", + "**Phase 1: Base Model Training**\n", + "```\n", + "Training data: All images from Grid 1301_11 (~295 images)\n", + "Architecture: U-Net or DeepLabV3 with ResNet encoder\n", + "Task: Binary segmentation (rooftop vs. background)\n", + "Optimization: Standard supervised learning with cross-entropy + Dice loss\n", + "```\n", + "\n", + "**Phase 2: Few-Shot Adaptation (Fine-Tuning)**\n", + "```\n", + "For each target grid (1301_13, 1301_31):\n", + " 1. Randomly select K images as support set (K = 1, 3, 5, 10, 20)\n", + " 2. Fine-tune the pre-trained model on these K examples\n", + " 3. Evaluate on remaining images from that grid\n", + "```\n", + "\n", + "**Fine-Tuning Strategies**:\n", + "- **Full fine-tuning**: Update all model parameters\n", + "- **Partial fine-tuning**: Freeze encoder, only update decoder\n", + "- **Learning rate**: Use small LR (1e-5 to 1e-4) to avoid catastrophic forgetting\n", + "- **Early stopping**: Monitor validation loss to prevent overfitting on K examples\n", + "\n", + "### Advantages\n", + "- βœ… Simple to implement and understand\n", + "- βœ… Well-established baseline in transfer learning\n", + "- βœ… Works with any architecture\n", + "- βœ… Fast adaptation (just a few gradient updates)\n", + "\n", + "### Limitations\n", + "- ❌ Prone to overfitting when K is very small (K=1,3)\n", + "- ❌ Doesn't explicitly learn \"how to learn from few examples\"\n", + "- ❌ Requires careful hyperparameter tuning (LR, epochs, which layers to freeze)\n", + "- ❌ May suffer from catastrophic forgetting\n", + "\n", + "### Expected Performance\n", + "```\n", + "Baseline (zero-shot, no adaptation): ~XX% IoU on target grids\n", + "Fine-tuning with K=1: ~XX% IoU (minimal improvement)\n", + "Fine-tuning with K=5: ~XX% IoU (moderate improvement)\n", + "Fine-tuning with K=20: ~XX% IoU (good improvement)\n", + "```\n", + "\n", + "### Implementation Outline (Not Implemented Yet)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Fine-tuning approach pseudocode\n", + "\"\"\"\n", + "# Phase 1: Train base model\n", + "base_model = UNet(encoder='resnet34', classes=2)\n", + "train_dataset = Grid_1301_11_Dataset(train_by_grid['1301_11'])\n", + "trainer = train(base_model, train_dataset, epochs=50)\n", + "save_checkpoint(base_model, 'base_model.pth')\n", + "\n", + "# Phase 2: Few-shot fine-tuning\n", + "for target_grid in ['1301_13', '1301_31']:\n", + " for K in [1, 3, 5, 10, 20]:\n", + " # Sample K support examples\n", + " support_set = random.sample(train_by_grid[target_grid], K)\n", + " query_set = [x for x in train_by_grid[target_grid] if x not in support_set]\n", + " \n", + " # Load pre-trained base model\n", + " model = load_checkpoint('base_model.pth')\n", + " \n", + " # Fine-tune on K examples\n", + " optimizer = Adam(model.parameters(), lr=1e-5)\n", + " for epoch in range(10): # Small number of epochs\n", + " for img, mask in support_set:\n", + " loss = compute_loss(model(img), mask)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " # Evaluate on query set\n", + " metrics = evaluate(model, query_set)\n", + " print(f\"Grid {target_grid}, K={K}: IoU = {metrics['iou']:.3f}\")\n", + "\"\"\"\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 2. Approach 2: Meta-Learning with Prototypical Networks\n", + "\n", + "### Concept\n", + "Instead of pre-training then adapting, **learn how to segment from K examples during training itself**. The model learns to extract good feature embeddings such that pixels from the same class (rooftop/background) cluster together.\n", + "\n", + "### Methodology\n", + "\n", + "**Core Idea**: \n", + "- Learn a feature encoder that maps pixels to an embedding space\n", + "- In this space, compute class prototypes (centers) from support set\n", + "- Classify query pixels by distance to nearest prototype\n", + "\n", + "**Episodic Training (on Grid 1301_11)**:\n", + "```\n", + "For each training episode:\n", + " 1. Sample K images as support set\n", + " 2. Sample Q images as query set \n", + " 3. Encode all images β†’ pixel embeddings\n", + " 4. Compute class prototypes from support set:\n", + " - fg_prototype = mean(embeddings where mask == 1)\n", + " - bg_prototype = mean(embeddings where mask == 0)\n", + " 5. Classify query pixels by distance to prototypes\n", + " 6. Compute loss on query predictions\n", + " 7. Update encoder to improve few-shot segmentation\n", + "```\n", + "\n", + "**Architecture**:\n", + "```\n", + "Input Image [H, W, 3]\n", + " ↓\n", + "Feature Encoder (ResNet/UNet encoder)\n", + " ↓\n", + "Pixel Embeddings [H, W, D] (D = embedding dimension, e.g., 256)\n", + " ↓\n", + "Prototype Computation:\n", + " - For each class c, compute prototype ΞΌ_c\n", + " - ΞΌ_c = mean of embeddings where support_mask == c\n", + " ↓\n", + "Distance-based Classification:\n", + " - For each query pixel embedding z\n", + " - distance_c = ||z - ΞΌ_c||Β²\n", + " - prediction = argmin_c(distance_c)\n", + "```\n", + "\n", + "**Training Details**:\n", + "- Episodes: 1000-2000 episodes sampled from Grid 1301_11\n", + "- K (support): 3-5 images per episode\n", + "- Q (query): 5-10 images per episode\n", + "- Embedding dim: 256 or 512\n", + "- Distance metric: Euclidean or cosine\n", + "- Loss: Cross-entropy on query predictions\n", + "- Augmentation: Rotation, flip, color jitter, random crop\n", + "\n", + "**Few-Shot Inference (on Target Grids)**:\n", + "```\n", + "Given K labeled images from Grid 1301_13:\n", + " 1. Encode support images β†’ embeddings\n", + " 2. Compute prototypes from support masks\n", + " 3. For each query image:\n", + " - Encode β†’ embeddings\n", + " - Classify each pixel by nearest prototype\n", + " 4. No gradient updates needed! (zero-shot in the target domain)\n", + "```\n", + "\n", + "### Advantages\n", + "- βœ… **Explicitly designed for few-shot learning**: trained to segment from K examples\n", + "- βœ… **No fine-tuning needed**: just compute prototypes and classify\n", + "- βœ… **Better generalization**: learns transferable embeddings, not dataset-specific features\n", + "- βœ… **Interpretable**: can visualize learned embeddings and prototypes\n", + "- βœ… **Sample efficient**: should outperform fine-tuning at very low K (1-5 shots)\n", + "\n", + "### Limitations\n", + "- ❌ More complex to implement than fine-tuning\n", + "- ❌ Requires episodic training (different from standard supervised learning)\n", + "- ❌ Slower training (need many episodes to sample diverse tasks)\n", + "- ❌ Needs sufficient source domain diversity (Grid 1301_11 should be varied enough)\n", + "\n", + "### Expected Performance\n", + "```\n", + "Baseline (zero-shot, no adaptation): ~XX% IoU on target grids\n", + "Prototypical Networks with K=1: ~XX% IoU (better than fine-tuning at K=1)\n", + "Prototypical Networks with K=5: ~XX% IoU (significantly better than fine-tuning)\n", + "Prototypical Networks with K=20: ~XX% IoU (comparable or better than fine-tuning)\n", + "```\n", + "\n", + "**Key hypothesis**: Prototypical Networks should outperform fine-tuning especially at **low K (1-5 shots)** because they're explicitly trained for this scenario.\n", + "\n", + "### Implementation Outline (Not Implemented Yet)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Prototypical Networks pseudocode\n", + "\"\"\"\n", + "import torch\n", + "import torch.nn as nn\n", + "\n", + "class PrototypicalSegmentationNetwork(nn.Module):\n", + " def __init__(self, encoder_name='resnet34', embedding_dim=256):\n", + " super().__init__()\n", + " self.encoder = build_encoder(encoder_name) # e.g., ResNet backbone\n", + " self.embedding_head = nn.Conv2d(encoder_channels, embedding_dim, 1)\n", + " \n", + " def extract_embeddings(self, images):\n", + " # images: [B, 3, H, W]\n", + " features = self.encoder(images) # [B, C, H, W]\n", + " embeddings = self.embedding_head(features) # [B, D, H, W]\n", + " return embeddings\n", + " \n", + " def compute_prototypes(self, support_embeddings, support_masks):\n", + " # support_embeddings: [K, D, H, W]\n", + " # support_masks: [K, H, W] (binary: 0=background, 1=rooftop)\n", + " \n", + " # Flatten spatial dimensions\n", + " embeddings_flat = support_embeddings.flatten(2) # [K, D, H*W]\n", + " masks_flat = support_masks.flatten(1) # [K, H*W]\n", + " \n", + " # Compute prototypes for each class\n", + " bg_prototype = embeddings_flat[:, :, masks_flat == 0].mean(dim=-1) # [D]\n", + " fg_prototype = embeddings_flat[:, :, masks_flat == 1].mean(dim=-1) # [D]\n", + " \n", + " return torch.stack([bg_prototype, fg_prototype]) # [2, D]\n", + " \n", + " def classify_by_prototypes(self, query_embeddings, prototypes):\n", + " # query_embeddings: [Q, D, H, W]\n", + " # prototypes: [2, D]\n", + " \n", + " Q, D, H, W = query_embeddings.shape\n", + " embeddings_flat = query_embeddings.view(Q, D, -1).permute(0, 2, 1) # [Q, H*W, D]\n", + " \n", + " # Compute distances to each prototype\n", + " distances = torch.cdist(embeddings_flat, prototypes.unsqueeze(0)) # [Q, H*W, 2]\n", + " \n", + " # Classify by nearest prototype (argmin distance)\n", + " predictions = distances.argmin(dim=-1).view(Q, H, W) # [Q, H, W]\n", + " \n", + " return predictions\n", + "\n", + "# Training loop\n", + "model = PrototypicalSegmentationNetwork()\n", + "optimizer = Adam(model.parameters(), lr=1e-4)\n", + "\n", + "for episode in range(num_episodes):\n", + " # Sample episode from Grid 1301_11\n", + " support_imgs, support_masks = sample_k_images(train_by_grid['1301_11'], k=5)\n", + " query_imgs, query_masks = sample_q_images(train_by_grid['1301_11'], q=5)\n", + " \n", + " # Extract embeddings\n", + " support_emb = model.extract_embeddings(support_imgs)\n", + " query_emb = model.extract_embeddings(query_imgs)\n", + " \n", + " # Compute prototypes from support set\n", + " prototypes = model.compute_prototypes(support_emb, support_masks)\n", + " \n", + " # Classify query images\n", + " predictions = model.classify_by_prototypes(query_emb, prototypes)\n", + " \n", + " # Compute loss\n", + " loss = cross_entropy(predictions, query_masks)\n", + " \n", + " # Update encoder\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + "# Inference on target grid\n", + "support_imgs, support_masks = select_k_examples(train_by_grid['1301_13'], k=5)\n", + "query_imgs, query_masks = get_remaining_images(train_by_grid['1301_13'])\n", + "\n", + "with torch.no_grad():\n", + " support_emb = model.extract_embeddings(support_imgs)\n", + " query_emb = model.extract_embeddings(query_imgs)\n", + " \n", + " prototypes = model.compute_prototypes(support_emb, support_masks)\n", + " predictions = model.classify_by_prototypes(query_emb, prototypes)\n", + " \n", + " iou = compute_iou(predictions, query_masks)\n", + " print(f\"IoU on Grid 1301_13 with K=5: {iou:.3f}\")\n", + "\"\"\"\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 3. Approach 3: PANet (Prototype Alignment Network)\n", + "\n", + "### Concept\n", + "PANet is a more sophisticated meta-learning approach specifically designed for few-shot semantic segmentation. It extends Prototypical Networks by adding **masked average pooling** and **prototype alignment** to better handle dense prediction tasks like segmentation.\n", + "\n", + "### Key Differences from Prototypical Networks\n", + "While Prototypical Networks compute simple class prototypes, PANet introduces:\n", + "1. **Masked Average Pooling (MAP)**: Uses support masks to extract more informative prototypes\n", + "2. **Bidirectional matching**: Matches queryβ†’support AND supportβ†’query for consistency\n", + "3. **Multi-scale features**: Combines features from multiple encoder levels\n", + "4. **Optimized for segmentation**: Designed specifically for dense pixel-wise prediction\n", + "\n", + "### Methodology\n", + "\n", + "**Core Architecture**:\n", + "```\n", + "Support Set (K images + masks) Query Image\n", + " ↓ ↓\n", + " Feature Encoder Feature Encoder\n", + " ↓ ↓\n", + " [K, C, H, W] [C, H, W]\n", + " ↓ ↓\n", + " Masked Average Pooling ──────────────→ Prototype Matching\n", + " (extract class prototypes ↓\n", + " using support masks) Distance-based prediction\n", + " ↓ ↓\n", + " Foreground prototype: ΞΌ_fg Segmentation mask [H, W]\n", + " Background prototype: ΞΌ_bg\n", + "```\n", + "\n", + "**Masked Average Pooling (MAP)**:\n", + "```\n", + "For class c (foreground or background):\n", + " 1. Collect all feature vectors from support images where mask == c\n", + " 2. Compute prototype ΞΌ_c = mean of these feature vectors\n", + " 3. This gives one prototype per class\n", + " \n", + "ΞΌ_fg = Ξ£_{i,x,y} f_i(x,y) * m_i(x,y) / Ξ£_{i,x,y} m_i(x,y)\n", + "ΞΌ_bg = Ξ£_{i,x,y} f_i(x,y) * (1-m_i(x,y)) / Ξ£_{i,x,y} (1-m_i(x,y))\n", + "\n", + "where:\n", + "- f_i(x,y) = feature vector at position (x,y) in support image i\n", + "- m_i(x,y) = mask value (0 or 1) at position (x,y) in support image i\n", + "```\n", + "\n", + "**Prototype Alignment**:\n", + "```\n", + "For each query pixel embedding z:\n", + " 1. Compute cosine similarity to each prototype\n", + " sim_fg = cos(z, ΞΌ_fg)\n", + " sim_bg = cos(z, ΞΌ_bg)\n", + " \n", + " 2. Convert to prediction probability\n", + " P(y=fg|z) = exp(sim_fg) / (exp(sim_fg) + exp(sim_bg))\n", + "```\n", + "\n", + "**Episodic Training (on Grid 1301_11)**:\n", + "```\n", + "For each training episode:\n", + " 1. Sample K support images with masks\n", + " 2. Sample Q query images with masks\n", + " 3. Extract multi-scale features for all images\n", + " 4. Compute class prototypes via Masked Average Pooling on support set\n", + " 5. For each query image:\n", + " a. Compute similarity between query features and prototypes\n", + " b. Generate segmentation prediction\n", + " 6. Compute loss (cross-entropy + auxiliary losses)\n", + " 7. Update encoder via backpropagation\n", + "```\n", + "\n", + "**Training Details**:\n", + "- Episodes: 1000-2000 episodes from Grid 1301_11\n", + "- K (support): 1-5 images per episode (PANet works well even with K=1)\n", + "- Q (query): 1 image per episode (typical PANet setup)\n", + "- Feature extractor: ResNet-50 or ResNet-101 backbone\n", + "- Multi-scale: Uses features from multiple ResNet blocks (e.g., res3, res4, res5)\n", + "- Loss: Cross-entropy loss on query predictions\n", + "- Augmentation: Random crop, flip, color jitter\n", + "\n", + "**Few-Shot Inference (on Target Grids)**:\n", + "```\n", + "Given K labeled images from Grid 1301_13:\n", + " 1. Extract features from K support images\n", + " 2. Compute fg/bg prototypes using Masked Average Pooling\n", + " 3. For each query image:\n", + " a. Extract features\n", + " b. Compute cosine similarity to prototypes\n", + " c. Generate segmentation prediction\n", + " 4. No gradient updates! (forward pass only)\n", + "```\n", + "\n", + "### Advantages\n", + "- βœ… **State-of-art for few-shot segmentation**: Consistently outperforms simpler methods\n", + "- βœ… **Better use of support masks**: MAP extracts richer prototypes than simple averaging\n", + "- βœ… **Works with K=1**: Effective even with single support example\n", + "- βœ… **Multi-scale features**: Captures both fine details and semantic context\n", + "- βœ… **No fine-tuning needed**: Like Prototypical Networks, inference is forward-pass only\n", + "- βœ… **Well-studied**: Multiple papers and implementations available\n", + "\n", + "### Limitations\n", + "- ❌ **More complex**: Harder to implement than Prototypical Networks\n", + "- ❌ **Computationally expensive**: Multi-scale features increase memory/compute\n", + "- ❌ **Requires careful design**: Choosing which feature levels, how to combine them\n", + "- ❌ **Slower training**: More complex architecture means longer training time\n", + "- ❌ **More hyperparameters**: Feature levels, similarity metrics, loss weights\n", + "\n", + "### Expected Performance\n", + "```\n", + "Baseline (zero-shot, no adaptation): ~XX% IoU on target grids\n", + "PANet with K=1: ~(XX+5)% IoU (best at K=1)\n", + "PANet with K=5: ~(XX+8)% IoU (state-of-art performance)\n", + "PANet with K=20: ~(XX+10)% IoU (approaching upper bound)\n", + "```\n", + "\n", + "**Key hypothesis**: PANet should outperform both fine-tuning and Prototypical Networks across all K values, with the **largest advantage at K=1-5** due to its sophisticated prototype extraction.\n", + "\n", + "### Implementation Outline (Not Implemented Yet)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# PANet pseudocode\n", + "\"\"\"\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "\n", + "class PANet(nn.Module):\n", + " def __init__(self, backbone='resnet50', use_multi_scale=True):\n", + " super().__init__()\n", + " self.encoder = build_resnet_encoder(backbone) # ResNet-50 or 101\n", + " self.use_multi_scale = use_multi_scale\n", + " \n", + " # If using multi-scale, we'll extract features from multiple layers\n", + " # e.g., res3, res4, res5 from ResNet\n", + " if use_multi_scale:\n", + " self.feature_levels = ['layer2', 'layer3', 'layer4'] # ResNet layers\n", + " \n", + " def extract_features(self, images, multi_scale=False):\n", + " # images: [B, 3, H, W]\n", + " if self.use_multi_scale and multi_scale:\n", + " # Extract features from multiple ResNet blocks\n", + " features = {}\n", + " x = self.encoder.conv1(images)\n", + " x = self.encoder.bn1(x)\n", + " x = self.encoder.relu(x)\n", + " x = self.encoder.maxpool(x)\n", + " \n", + " x = self.encoder.layer1(x)\n", + " x = self.encoder.layer2(x)\n", + " features['layer2'] = x # 1/8 resolution\n", + " \n", + " x = self.encoder.layer3(x)\n", + " features['layer3'] = x # 1/16 resolution\n", + " \n", + " x = self.encoder.layer4(x)\n", + " features['layer4'] = x # 1/32 resolution\n", + " \n", + " return features\n", + " else:\n", + " # Single-scale features from final layer\n", + " features = self.encoder(images) # [B, C, H', W']\n", + " return features\n", + " \n", + " def masked_average_pooling(self, features, masks):\n", + " \\\"\\\"\\\"\n", + " Compute class prototypes using Masked Average Pooling (MAP).\n", + " \n", + " Args:\n", + " features: [K, C, H, W] - support features\n", + " masks: [K, H, W] - support masks (binary: 0=bg, 1=fg)\n", + " \n", + " Returns:\n", + " fg_prototype: [C] - foreground prototype\n", + " bg_prototype: [C] - background prototype\n", + " \\\"\\\"\\\"\n", + " K, C, H, W = features.shape\n", + " \n", + " # Resize masks to match feature resolution\n", + " masks_resized = F.interpolate(\n", + " masks.unsqueeze(1).float(), \n", + " size=(H, W), \n", + " mode='nearest'\n", + " ).squeeze(1) # [K, H, W]\n", + " \n", + " # Flatten spatial dimensions\n", + " features_flat = features.view(K, C, -1) # [K, C, H*W]\n", + " masks_flat = masks_resized.view(K, -1) # [K, H*W]\n", + " \n", + " # Foreground prototype: average of features where mask == 1\n", + " fg_mask = (masks_flat == 1).unsqueeze(1) # [K, 1, H*W]\n", + " fg_features = features_flat * fg_mask # [K, C, H*W]\n", + " fg_count = fg_mask.sum(dim=(0, 2), keepdim=True) # [1, 1, 1]\n", + " fg_prototype = fg_features.sum(dim=(0, 2)) / (fg_count.squeeze() + 1e-5) # [C]\n", + " \n", + " # Background prototype: average of features where mask == 0\n", + " bg_mask = (masks_flat == 0).unsqueeze(1) # [K, 1, H*W]\n", + " bg_features = features_flat * bg_mask # [K, C, H*W]\n", + " bg_count = bg_mask.sum(dim=(0, 2), keepdim=True) # [1, 1, 1]\n", + " bg_prototype = bg_features.sum(dim=(0, 2)) / (bg_count.squeeze() + 1e-5) # [C]\n", + " \n", + " return fg_prototype, bg_prototype\n", + " \n", + " def prototype_alignment(self, query_features, fg_prototype, bg_prototype):\n", + " \\\"\\\"\\\"\n", + " Compute cosine similarity between query features and prototypes.\n", + " \n", + " Args:\n", + " query_features: [Q, C, H, W]\n", + " fg_prototype: [C]\n", + " bg_prototype: [C]\n", + " \n", + " Returns:\n", + " predictions: [Q, 2, H, W] - similarity scores for each class\n", + " \\\"\\\"\\\"\n", + " Q, C, H, W = query_features.shape\n", + " \n", + " # Normalize features and prototypes for cosine similarity\n", + " query_norm = F.normalize(query_features, p=2, dim=1) # [Q, C, H, W]\n", + " fg_proto_norm = F.normalize(fg_prototype.unsqueeze(0), p=2, dim=1) # [1, C]\n", + " bg_proto_norm = F.normalize(bg_prototype.unsqueeze(0), p=2, dim=1) # [1, C]\n", + " \n", + " # Compute cosine similarity\n", + " # query_norm: [Q, C, H, W], proto_norm: [1, C] -> need to broadcast\n", + " fg_sim = (query_norm * fg_proto_norm.view(1, C, 1, 1)).sum(dim=1) # [Q, H, W]\n", + " bg_sim = (query_norm * bg_proto_norm.view(1, C, 1, 1)).sum(dim=1) # [Q, H, W]\n", + " \n", + " # Stack similarities for both classes\n", + " similarity_map = torch.stack([bg_sim, fg_sim], dim=1) # [Q, 2, H, W]\n", + " \n", + " return similarity_map\n", + " \n", + " def forward(self, support_images, support_masks, query_images):\n", + " \\\"\\\"\\\"\n", + " PANet forward pass for few-shot segmentation.\n", + " \n", + " Args:\n", + " support_images: [K, 3, H, W]\n", + " support_masks: [K, H, W]\n", + " query_images: [Q, 3, H, W]\n", + " \n", + " Returns:\n", + " predictions: [Q, 2, H, W] - class scores for query images\n", + " \\\"\\\"\\\"\n", + " # Extract features\n", + " support_features = self.extract_features(support_images) # [K, C, H', W']\n", + " query_features = self.extract_features(query_images) # [Q, C, H', W']\n", + " \n", + " # Compute prototypes from support set\n", + " fg_prototype, bg_prototype = self.masked_average_pooling(\n", + " support_features, support_masks\n", + " )\n", + " \n", + " # Align query features with prototypes\n", + " similarity_map = self.prototype_alignment(\n", + " query_features, fg_prototype, bg_prototype\n", + " )\n", + " \n", + " # Upsample to original resolution\n", + " Q, _, H, W = query_images.shape\n", + " predictions = F.interpolate(\n", + " similarity_map,\n", + " size=(H, W),\n", + " mode='bilinear',\n", + " align_corners=True\n", + " ) # [Q, 2, H, W]\n", + " \n", + " return predictions\n", + "\n", + "# Training loop\n", + "model = PANet(backbone='resnet50')\n", + "optimizer = Adam(model.parameters(), lr=1e-4)\n", + "\n", + "for episode in range(num_episodes):\n", + " # Sample episode from Grid 1301_11\n", + " support_imgs, support_masks = sample_k_images(train_by_grid['1301_11'], k=5)\n", + " query_imgs, query_masks = sample_q_images(train_by_grid['1301_11'], q=1)\n", + " \n", + " # Forward pass\n", + " predictions = model(support_imgs, support_masks, query_imgs) # [Q, 2, H, W]\n", + " \n", + " # Compute loss\n", + " loss = F.cross_entropy(predictions, query_masks.long())\n", + " \n", + " # Update model\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " if episode % 100 == 0:\n", + " print(f\"Episode {episode}, Loss: {loss.item():.4f}\")\n", + "\n", + "# Inference on target grid\n", + "support_imgs, support_masks = select_k_examples(train_by_grid['1301_13'], k=5)\n", + "query_imgs, query_masks = get_remaining_images(train_by_grid['1301_13'])\n", + "\n", + "model.eval()\n", + "with torch.no_grad():\n", + " predictions = model(support_imgs, support_masks, query_imgs) # [Q, 2, H, W]\n", + " pred_masks = predictions.argmax(dim=1) # [Q, H, W]\n", + " \n", + " iou = compute_iou(pred_masks, query_masks)\n", + " print(f\"IoU on Grid 1301_13 with K=5: {iou:.3f}\")\n", + "\"\"\"\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 4. Comparison of Approaches\n", + "\n", + "| Aspect | Fine-Tuning | Prototypical Networks | PANet |\n", + "|--------|-------------|----------------------|-------|\n", + "| **Training paradigm** | Standard supervised β†’ fine-tune | Episodic meta-learning | Episodic meta-learning |\n", + "| **Adaptation method** | Gradient updates on K examples | Compute prototypes (no updates) | Compute prototypes (no updates) |\n", + "| **Prototype extraction** | N/A | Simple averaging | Masked Average Pooling (MAP) |\n", + "| **Feature representation** | Task-specific | Learned embeddings | Multi-scale learned embeddings |\n", + "| **Sample efficiency** | Moderate (needs K~10-20) | High (works well with K=3-5) | Very high (works well with K=1-3) |\n", + "| **Overfitting risk** | High at low K | Lower | Lowest |\n", + "| **Computational cost (training)** | Low (few gradient steps) | Medium (episodic training) | High (complex architecture) |\n", + "| **Computational cost (inference)** | Low | Low | Medium (multi-scale features) |\n", + "| **Implementation complexity** | Simple | Moderate | High |\n", + "| **Interpretability** | Standard CNN features | Explicit embeddings + prototypes | Prototypes + similarity maps |\n", + "| **Expected performance K=1** | Poor | Moderate | Good |\n", + "| **Expected performance K=5** | Moderate | Good | Very good |\n", + "| **Expected performance K=20** | Good | Very good | Excellent |\n", + "\n", + "### Detailed Comparison\n", + "\n", + "#### 1. **Fine-Tuning (Baseline)**\n", + "- **Best for**: K > 10, similar domains, simple baseline\n", + "- **Strengths**: Easy to implement, well-understood, works with any architecture\n", + "- **Weaknesses**: Overfits at low K, requires hyperparameter tuning\n", + "- **Use case**: When you have enough target data and want a simple solution\n", + "\n", + "#### 2. **Prototypical Networks**\n", + "- **Best for**: K = 3-10, learning transferable embeddings\n", + "- **Strengths**: Designed for few-shot, no fine-tuning needed, interpretable\n", + "- **Weaknesses**: Simpler than PANet, may not capture complex patterns\n", + "- **Use case**: Balance between performance and implementation complexity\n", + "\n", + "#### 3. **PANet (State-of-Art)**\n", + "- **Best for**: K = 1-5, maximum performance, complex domain shifts\n", + "- **Strengths**: Best performance, works with K=1, sophisticated prototype extraction\n", + "- **Weaknesses**: Complex to implement, computationally expensive, many hyperparameters\n", + "- **Use case**: When you need the best possible performance and can handle complexity\n", + "\n", + "### When to Use Each Approach\n", + "\n", + "| Scenario | Recommended Method | Rationale |\n", + "|----------|-------------------|-----------|\n", + "| K = 1 shot | **PANet** | Only PANet handles single example well |\n", + "| K = 3-5 shots | **PANet or Prototypical** | Both work well, trade complexity for performance |\n", + "| K = 10+ shots | **Fine-tuning or Prototypical** | Diminishing returns from PANet complexity |\n", + "| Tutorial/Educational | **Prototypical Networks** | Best balance of concepts and implementation |\n", + "| Production deployment | **PANet** | Maximum performance, worth the engineering |\n", + "| Quick baseline | **Fine-tuning** | Simplest, fastest to implement |\n", + "| Large domain shift | **PANet** | Best generalization to new domains |\n", + "| Limited compute | **Fine-tuning** | Lowest computational requirements |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 5. Evaluation Protocol\n", + "\n", + "For all three approaches, we'll use the same evaluation protocol:\n", + "\n", + "### 5.1 Metrics\n", + "- **Intersection over Union (IoU)**: Primary metric for segmentation quality\n", + "- **Pixel Accuracy**: Overall percentage of correctly classified pixels\n", + "- **Dice Coefficient**: Harmonic mean of precision and recall\n", + "- **F1-Score**: Per-class performance metric\n", + "\n", + "### 5.2 Experimental Setup\n", + "```\n", + "For K in [1, 3, 5, 10, 20]:\n", + " For target_grid in ['1301_13', '1301_31']:\n", + " For trial in range(5): # 5 random trials for statistical significance\n", + " # Randomly select K support examples\n", + " support_set = random.sample(target_grid_data, K)\n", + " query_set = remaining images\n", + " \n", + " # Apply each method\n", + " pred_finetuning = fine_tuning_method.predict(support_set, query_set)\n", + " pred_prototypical = prototypical_method.predict(support_set, query_set)\n", + " pred_panet = panet_method.predict(support_set, query_set)\n", + " \n", + " # Compute metrics for each\n", + " iou_ft = compute_iou(pred_finetuning, query_ground_truth)\n", + " iou_proto = compute_iou(pred_prototypical, query_ground_truth)\n", + " iou_panet = compute_iou(pred_panet, query_ground_truth)\n", + " \n", + " # Report mean Β± std across trials\n", + "```\n", + "\n", + "### 5.3 Baselines\n", + "1. **Zero-shot**: Trained on 1301_11, test directly on target (no adaptation)\n", + "2. **Upper bound**: Train on full target grid data (supervised learning)\n", + "3. **Random**: Random segmentation (sanity check)\n", + "\n", + "### 5.4 Statistical Testing\n", + "- **Paired t-test**: Compare methods at each K value\n", + "- **Confidence intervals**: 95% CI for mean IoU\n", + "- **Significance level**: Ξ± = 0.05\n", + "\n", + "### 5.5 Visualization\n", + "- **Performance vs. K curves**: Line plot showing all three methods\n", + "- **Box plots**: Distribution of IoU scores across trials\n", + "- **Qualitative results**: Side-by-side segmentation outputs\n", + "- **Error analysis**: Where does each method fail?\n", + "- **Prototype visualization** (for Prototypical Networks and PANet):\n", + " - t-SNE of learned embeddings\n", + " - Similarity maps\n", + " - Prototype evolution as K increases" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Evaluation utilities (to be implemented)\n", + "\"\"\"\n", + "def compute_iou(predictions, targets, num_classes=2):\n", + " \\\"\\\"\\\"\n", + " Compute intersection over union for each class.\n", + " \n", + " Args:\n", + " predictions: [N, H, W] - predicted masks\n", + " targets: [N, H, W] - ground truth masks\n", + " num_classes: number of classes\n", + " \n", + " Returns:\n", + " iou: mean IoU across classes\n", + " \\\"\\\"\\\"\n", + " pass\n", + "\n", + "def evaluate_fewshot(model, support_set, query_set, method='prototypical'):\n", + " \\\"\\\"\\\"\n", + " Run few-shot evaluation for a given method.\n", + " \n", + " Args:\n", + " model: trained model\n", + " support_set: K labeled examples\n", + " query_set: unlabeled test examples\n", + " method: 'fine_tuning', 'prototypical', or 'panet'\n", + " \n", + " Returns:\n", + " metrics: dict with IoU, Dice, accuracy, etc.\n", + " \\\"\\\"\\\"\n", + " pass\n", + "\n", + "def plot_performance_curve(results_dict, save_path=None):\n", + " \\\"\\\"\\\"\n", + " Plot IoU vs K for all three methods.\n", + " \n", + " Args:\n", + " results_dict: {\n", + " 'fine_tuning': {K: [iou_values]}, \n", + " 'prototypical': {K: [iou_values]},\n", + " 'panet': {K: [iou_values]}\n", + " }\n", + " \\\"\\\"\\\"\n", + " import matplotlib.pyplot as plt\n", + " \n", + " fig, ax = plt.subplots(figsize=(10, 6))\n", + " \n", + " for method_name, results in results_dict.items():\n", + " K_values = sorted(results.keys())\n", + " mean_ious = [np.mean(results[k]) for k in K_values]\n", + " std_ious = [np.std(results[k]) for k in K_values]\n", + " \n", + " ax.plot(K_values, mean_ious, marker='o', label=method_name)\n", + " ax.fill_between(K_values, \n", + " np.array(mean_ious) - np.array(std_ious),\n", + " np.array(mean_ious) + np.array(std_ious),\n", + " alpha=0.2)\n", + " \n", + " ax.set_xlabel('K (number of support examples)')\n", + " ax.set_ylabel('Mean IoU')\n", + " ax.set_title('Few-Shot Segmentation Performance')\n", + " ax.legend()\n", + " ax.grid(True, alpha=0.3)\n", + " \n", + " if save_path:\n", + " plt.savefig(save_path, dpi=300, bbox_inches='tight')\n", + " plt.show()\n", + " \n", + " pass\n", + "\n", + "def visualize_predictions(images, masks, predictions_dict, n_samples=5):\n", + " \\\"\\\"\\\"\n", + " Side-by-side comparison of ground truth and all method predictions.\n", + " \n", + " Args:\n", + " images: [N, H, W, 3] - input images\n", + " masks: [N, H, W] - ground truth masks\n", + " predictions_dict: {\n", + " 'fine_tuning': [N, H, W],\n", + " 'prototypical': [N, H, W],\n", + " 'panet': [N, H, W]\n", + " }\n", + " n_samples: number of samples to visualize\n", + " \\\"\\\"\\\"\n", + " pass\n", + "\n", + "def visualize_prototypes(model, support_set, method='prototypical'):\n", + " \\\"\\\"\\\"\n", + " Visualize learned embeddings and prototypes.\n", + " \n", + " For Prototypical Networks and PANet:\n", + " - t-SNE visualization of pixel embeddings\n", + " - Show foreground/background prototype locations\n", + " - Similarity maps for query images\n", + " \\\"\\\"\\\"\n", + " pass\n", + "\n", + "def statistical_comparison(results_dict, K_value=5):\n", + " \\\"\\\"\\\"\n", + " Perform paired t-test between methods at a specific K.\n", + " \n", + " Args:\n", + " results_dict: results from all methods\n", + " K_value: which K to compare\n", + " \n", + " Returns:\n", + " p_values: pairwise p-values\n", + " \\\"\\\"\\\"\n", + " from scipy import stats\n", + " \n", + " methods = list(results_dict.keys())\n", + " p_values = {}\n", + " \n", + " for i, method1 in enumerate(methods):\n", + " for method2 in methods[i+1:]:\n", + " ious1 = results_dict[method1][K_value]\n", + " ious2 = results_dict[method2][K_value]\n", + " \n", + " t_stat, p_val = stats.ttest_rel(ious1, ious2)\n", + " p_values[f'{method1}_vs_{method2}'] = p_val\n", + " \n", + " return p_values\n", + "\"\"\"\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 6. Cross-City Transfer: Integrating Inria Aerial Dataset\n", + "\n", + "### Motivation\n", + "To make the few-shot learning scenario more realistic and demonstrate the full power of meta-learning approaches, we integrate the **Inria Aerial Image Dataset** as cross-city target domains. This tests true **cross-city generalization**, moving beyond within-city transfer to real-world deployment scenarios.\n", + "\n", + "### Why Inria Aerial Dataset?\n", + "\n", + "**Dataset Overview**:\n", + "- **5 cities**: Austin (US), Chicago (US), Kitsap (US), Vienna (Austria), Tyrol (Austria)\n", + "- **Coverage**: 180 kmΒ² total across all cities\n", + "- **Images**: 360 images (180 train + 180 test), 5000Γ—5000 pixels each\n", + "- **Resolution**: 0.3m per pixel\n", + "- **Task**: Building footprint segmentation (binary: building vs background)\n", + "- **Availability**: Free, well-documented benchmark dataset\n", + "- **HuggingFace**: `Jonathan/INRIA-Aerial-Dataset`\n", + "\n", + "**Why This Strategy (Geneva + Inria)**:\n", + "βœ… **Progressive difficulty**: Start with small domain shift (Geneva grids), then cross-city transfer (Inria cities)\n", + "βœ… **Same task throughout**: Binary segmentation (rooftop/building vs background)\n", + "βœ… **Educational value**: Clear learning progression from easy to hard\n", + "βœ… **Multiple test scenarios**: 2 Geneva grids + up to 5 Inria cities\n", + "βœ… **Real-world relevance**: \"Train on Geneva, deploy to Vienna\" mimics actual government use cases\n", + "\n", + "**Expected Domain Shifts**:\n", + "```\n", + "Geneva 1301_11 β†’ Geneva 1301_13: SMALL (same city, different neighborhood)\n", + "Geneva 1301_11 β†’ Vienna: MEDIUM (both European, different city)\n", + "Geneva 1301_11 β†’ Austin: LARGE (European β†’ US, different architecture)\n", + "Geneva 1301_11 β†’ Kitsap: VERY LARGE (European urban β†’ US rural)\n", + "```\n", + "\n", + "### Recommended Implementation: Vienna + Austin\n", + "\n", + "For this tutorial, we'll focus on **two Inria cities**:\n", + "\n", + "1. **Vienna** (Medium shift)\n", + " - European city like Geneva\n", + " - Moderate density, similar coordinate system\n", + " - Different architecture but same continental style\n", + " - Expected: Meta-learning should show moderate advantage\n", + "\n", + "2. **Austin** (Large shift)\n", + " - US suburban sprawl\n", + " - Low-density, very different building types\n", + " - Large domain gap from Geneva\n", + " - Expected: Meta-learning should show large advantage over fine-tuning\n", + "\n", + "### Integration Workflow\n", + "\n", + "#### Step 1: Download and Prepare Inria Dataset\n", + "\n", + "```python\n", + "from datasets import load_dataset\n", + "from PIL import Image\n", + "import numpy as np\n", + "from pathlib import Path\n", + "\n", + "def download_inria_dataset(cities=['vienna', 'austin']):\n", + " \"\"\"\n", + " Download Inria dataset from HuggingFace.\n", + " \n", + " Args:\n", + " cities: List of cities to download\n", + " \n", + " Returns:\n", + " Dictionary with city data\n", + " \"\"\"\n", + " # Load full dataset\n", + " inria_data = load_dataset(\"Jonathan/INRIA-Aerial-Dataset\")\n", + " \n", + " # Filter by cities\n", + " city_data = {}\n", + " for city in cities:\n", + " city_data[city] = {\n", + " 'train': inria_data['train'].filter(lambda x: x['city'].lower() == city),\n", + " 'test': inria_data['test'].filter(lambda x: x['city'].lower() == city)\n", + " }\n", + " \n", + " return city_data\n", + "```\n", + "\n", + "#### Step 2: Tile Images to Match Geneva Format\n", + "\n", + "```python\n", + "def tile_image(image, mask, tile_size=250, stride=250):\n", + " \"\"\"\n", + " Tile large Inria images (5000x5000) into Geneva-compatible patches (250x250).\n", + " \n", + " Args:\n", + " image: PIL Image or numpy array [H, W, 3]\n", + " mask: PIL Image or numpy array [H, W]\n", + " tile_size: Size of output tiles (default 250 to match Geneva)\n", + " stride: Stride for tiling (default 250 for non-overlapping)\n", + " \n", + " Returns:\n", + " List of (image_tile, mask_tile) tuples\n", + " \"\"\"\n", + " if isinstance(image, Image.Image):\n", + " image = np.array(image)\n", + " if isinstance(mask, Image.Image):\n", + " mask = np.array(mask)\n", + " \n", + " H, W = image.shape[:2]\n", + " tiles = []\n", + " \n", + " for y in range(0, H - tile_size + 1, stride):\n", + " for x in range(0, W - tile_size + 1, stride):\n", + " img_tile = image[y:y+tile_size, x:x+tile_size]\n", + " mask_tile = mask[y:y+tile_size, x:x+tile_size]\n", + " \n", + " # Skip tiles with no buildings (optional: for efficiency)\n", + " if mask_tile.sum() > 0: # At least some building pixels\n", + " tiles.append((img_tile, mask_tile))\n", + " \n", + " return tiles\n", + "\n", + "def preprocess_inria_city(city_data, output_dir, tile_size=250):\n", + " \"\"\"\n", + " Process all images from one Inria city.\n", + " \n", + " Args:\n", + " city_data: Dataset for one city (train/test splits)\n", + " output_dir: Where to save tiled images\n", + " tile_size: Tile size (default 250)\n", + " \n", + " Returns:\n", + " Dictionary with paths to tiled images\n", + " \"\"\"\n", + " output_dir = Path(output_dir)\n", + " output_dir.mkdir(parents=True, exist_ok=True)\n", + " \n", + " tiled_data = {'train': [], 'test': []}\n", + " \n", + " for split in ['train', 'test']:\n", + " for idx, sample in enumerate(city_data[split]):\n", + " image = sample['image'] # PIL Image\n", + " mask = sample['mask'] # PIL Image (building=1, background=0)\n", + " \n", + " # Tile into 250x250 patches\n", + " tiles = tile_image(image, mask, tile_size=tile_size)\n", + " \n", + " # Save tiles\n", + " for tile_idx, (img_tile, mask_tile) in enumerate(tiles):\n", + " img_path = output_dir / split / 'images' / f\"{idx}_{tile_idx}.png\"\n", + " mask_path = output_dir / split / 'masks' / f\"{idx}_{tile_idx}.png\"\n", + " \n", + " img_path.parent.mkdir(parents=True, exist_ok=True)\n", + " mask_path.parent.mkdir(parents=True, exist_ok=True)\n", + " \n", + " Image.fromarray(img_tile).save(img_path)\n", + " Image.fromarray(mask_tile).save(mask_path)\n", + " \n", + " tiled_data[split].append((str(img_path), str(mask_path)))\n", + " \n", + " print(f\"Created {len(tiled_data['train'])} train tiles and {len(tiled_data['test'])} test tiles\")\n", + " return tiled_data\n", + "```\n", + "\n", + "#### Step 3: Normalize and Align Preprocessing\n", + "\n", + "```python\n", + "def analyze_dataset_statistics(dataset_paths):\n", + " \"\"\"\n", + " Compute mean and std of RGB channels for normalization.\n", + " \n", + " Args:\n", + " dataset_paths: List of (image_path, mask_path) tuples\n", + " \n", + " Returns:\n", + " mean, std: RGB channel statistics\n", + " \"\"\"\n", + " means = []\n", + " stds = []\n", + " \n", + " for img_path, _ in dataset_paths[:100]: # Sample 100 images\n", + " img = np.array(Image.open(img_path)) / 255.0\n", + " means.append(img.mean(axis=(0, 1)))\n", + " stds.append(img.std(axis=(0, 1)))\n", + " \n", + " mean = np.mean(means, axis=0)\n", + " std = np.mean(stds, axis=0)\n", + " \n", + " return mean, std\n", + "\n", + "# Compare Geneva vs Inria statistics\n", + "geneva_mean, geneva_std = analyze_dataset_statistics(train_by_grid['1301_11'])\n", + "vienna_mean, vienna_std = analyze_dataset_statistics(vienna_tiled_data['train'])\n", + "austin_mean, austin_std = analyze_dataset_statistics(austin_tiled_data['train'])\n", + "\n", + "print(\"Dataset Statistics:\")\n", + "print(f\"Geneva: mean={geneva_mean}, std={geneva_std}\")\n", + "print(f\"Vienna: mean={vienna_mean}, std={vienna_std}\")\n", + "print(f\"Austin: mean={austin_mean}, std={austin_std}\")\n", + "```\n", + "\n", + "#### Step 4: Three-Level Evaluation Framework\n", + "\n", + "```\n", + "Tutorial Evaluation Structure:\n", + "\n", + "Level 1: Within-City Transfer (Baseline)\n", + " Train: Geneva Grid 1301_11\n", + " Test: Geneva Grids 1301_13, 1301_31\n", + " Purpose: Validate methods, small domain shift\n", + " Expected: All methods work reasonably well\n", + "\n", + "Level 2: Cross-City Transfer - Similar Domain (Vienna)\n", + " Train: Geneva Grid 1301_11\n", + " Test: Vienna (Inria)\n", + " Purpose: Medium domain shift, European β†’ European\n", + " Expected: Meta-learning starts showing advantage\n", + "\n", + "Level 3: Cross-City Transfer - Large Domain Shift (Austin)\n", + " Train: Geneva Grid 1301_11\n", + " Test: Austin (Inria)\n", + " Purpose: Large domain shift, European urban β†’ US suburban\n", + " Expected: Meta-learning shows large advantage, fine-tuning struggles\n", + "```\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Inria dataset integration implementation (to be completed)\n", + "\"\"\"\n", + "# Complete implementation for integrating Inria dataset\n", + "\n", + "from datasets import load_dataset\n", + "from PIL import Image\n", + "import numpy as np\n", + "from pathlib import Path\n", + "\n", + "# Step 1: Download Inria dataset\n", + "def load_and_prepare_inria(cities=['vienna', 'austin'], cache_dir='./data/inria'):\n", + " \\\"\\\"\\\"\n", + " Download and prepare Inria dataset for cross-city evaluation.\n", + " \\\"\\\"\\\"\n", + " print(f\"Downloading Inria dataset for cities: {cities}\")\n", + " \n", + " # Load from HuggingFace\n", + " inria_dataset = load_dataset(\"Jonathan/INRIA-Aerial-Dataset\", cache_dir=cache_dir)\n", + " \n", + " city_data = {}\n", + " for city in cities:\n", + " print(f\"Processing {city}...\")\n", + " \n", + " # Filter by city (case-insensitive)\n", + " train_city = [x for x in inria_dataset['train'] if x['city'].lower() == city.lower()]\n", + " test_city = [x for x in inria_dataset['test'] if x['city'].lower() == city.lower()]\n", + " \n", + " city_data[city] = {\n", + " 'train': train_city,\n", + " 'test': test_city\n", + " }\n", + " \n", + " print(f\" {city}: {len(train_city)} train, {len(test_city)} test images\")\n", + " \n", + " return city_data\n", + "\n", + "# Step 2: Tile images to 250x250\n", + "def tile_inria_images(city_data, output_dir, tile_size=250, stride=250, min_building_pixels=100):\n", + " \\\"\\\"\\\"\n", + " Tile Inria 5000x5000 images into 250x250 patches compatible with Geneva.\n", + " \n", + " Args:\n", + " city_data: Dictionary with train/test splits for a city\n", + " output_dir: Where to save tiles\n", + " tile_size: Size of each tile (default 250)\n", + " stride: Stride for tiling (default 250 for non-overlapping)\n", + " min_building_pixels: Minimum building pixels to keep a tile\n", + " \n", + " Returns:\n", + " Dictionary with tile paths: {'train': [(img, mask), ...], 'test': [...]}\n", + " \\\"\\\"\\\"\n", + " output_dir = Path(output_dir)\n", + " tiled_paths = {'train': [], 'test': []}\n", + " \n", + " for split in ['train', 'test']:\n", + " split_dir = output_dir / split\n", + " (split_dir / 'images').mkdir(parents=True, exist_ok=True)\n", + " (split_dir / 'masks').mkdir(parents=True, exist_ok=True)\n", + " \n", + " for img_idx, sample in enumerate(city_data[split]):\n", + " # Get image and mask (already PIL Images)\n", + " image = sample['image'] # 5000x5000 RGB\n", + " mask = sample['mask'] # 5000x5000 binary\n", + " \n", + " # Convert to numpy for tiling\n", + " img_np = np.array(image)\n", + " mask_np = np.array(mask)\n", + " \n", + " H, W = img_np.shape[:2]\n", + " tile_idx = 0\n", + " \n", + " # Tile the image\n", + " for y in range(0, H - tile_size + 1, stride):\n", + " for x in range(0, W - tile_size + 1, stride):\n", + " img_tile = img_np[y:y+tile_size, x:x+tile_size]\n", + " mask_tile = mask_np[y:y+tile_size, x:x+tile_size]\n", + " \n", + " # Skip tiles with too few building pixels\n", + " if mask_tile.sum() < min_building_pixels:\n", + " continue\n", + " \n", + " # Save tiles\n", + " img_path = split_dir / 'images' / f\"img{img_idx:03d}_tile{tile_idx:03d}.png\"\n", + " mask_path = split_dir / 'masks' / f\"img{img_idx:03d}_tile{tile_idx:03d}.png\"\n", + " \n", + " Image.fromarray(img_tile).save(img_path)\n", + " Image.fromarray(mask_tile).save(mask_path)\n", + " \n", + " tiled_paths[split].append((str(img_path), str(mask_path)))\n", + " tile_idx += 1\n", + " \n", + " print(f\"{split}: Created {len(tiled_paths[split])} tiles\")\n", + " \n", + " return tiled_paths\n", + "\n", + "# Step 3: Cross-city evaluation\n", + "def evaluate_cross_city_transfer(model, geneva_train, vienna_data, austin_data, K_values=[1, 3, 5, 10, 20]):\n", + " \\\"\\\"\\\"\n", + " Evaluate few-shot transfer from Geneva to Vienna and Austin.\n", + " \n", + " Args:\n", + " model: Trained model (Fine-tuning, Prototypical, or PANet)\n", + " geneva_train: Geneva Grid 1301_11 data (source domain)\n", + " vienna_data: Vienna tiled data (target domain 1)\n", + " austin_data: Austin tiled data (target domain 2)\n", + " K_values: List of K values to evaluate\n", + " \n", + " Returns:\n", + " Dictionary with results for each target city and K value\n", + " \\\"\\\"\\\"\n", + " results = {\n", + " 'vienna': {},\n", + " 'austin': {}\n", + " }\n", + " \n", + " # Test on Vienna\n", + " print(\"\\\\n=== Vienna Cross-City Transfer ===\")\n", + " for K in K_values:\n", + " # Sample K support examples from Vienna\n", + " support_vienna = random.sample(vienna_data['test'], K)\n", + " query_vienna = [x for x in vienna_data['test'] if x not in support_vienna]\n", + " \n", + " # Run few-shot evaluation\n", + " iou_vienna = model.evaluate_fewshot(support_vienna, query_vienna)\n", + " results['vienna'][K] = iou_vienna\n", + " \n", + " print(f\"K={K}: IoU = {iou_vienna:.3f}\")\n", + " \n", + " # Test on Austin\n", + " print(\"\\\\n=== Austin Cross-City Transfer ===\")\n", + " for K in K_values:\n", + " # Sample K support examples from Austin\n", + " support_austin = random.sample(austin_data['test'], K)\n", + " query_austin = [x for x in austin_data['test'] if x not in support_austin]\n", + " \n", + " # Run few-shot evaluation\n", + " iou_austin = model.evaluate_fewshot(support_austin, query_austin)\n", + " results['austin'][K] = iou_austin\n", + " \n", + " print(f\"K={K}: IoU = {iou_austin:.3f}\")\n", + " \n", + " return results\n", + "\n", + "# Step 4: Visualization - Compare within-city vs cross-city\n", + "def plot_cross_city_comparison(results_geneva, results_vienna, results_austin, save_path=None):\n", + " \\\"\\\"\\\"\n", + " Plot performance comparison across different domain shifts.\n", + " \n", + " Args:\n", + " results_geneva: Results on Geneva grids (1301_13, 1301_31)\n", + " results_vienna: Results on Vienna\n", + " results_austin: Results on Austin\n", + " \\\"\\\"\\\"\n", + " import matplotlib.pyplot as plt\n", + " \n", + " fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\n", + " \n", + " # Plot 1: Fine-tuning across domains\n", + " K_values = sorted(results_geneva['fine_tuning'].keys())\n", + " \n", + " ax1.plot(K_values, [results_geneva['fine_tuning'][k] for k in K_values], \n", + " marker='o', label='Geneva (small shift)', linewidth=2)\n", + " ax1.plot(K_values, [results_vienna['fine_tuning'][k] for k in K_values], \n", + " marker='s', label='Vienna (medium shift)', linewidth=2)\n", + " ax1.plot(K_values, [results_austin['fine_tuning'][k] for k in K_values], \n", + " marker='^', label='Austin (large shift)', linewidth=2)\n", + " \n", + " ax1.set_xlabel('K (number of support examples)', fontsize=12)\n", + " ax1.set_ylabel('Mean IoU', fontsize=12)\n", + " ax1.set_title('Fine-Tuning: Performance vs Domain Shift', fontsize=14)\n", + " ax1.legend(fontsize=10)\n", + " ax1.grid(True, alpha=0.3)\n", + " \n", + " # Plot 2: PANet across domains (should be more robust)\n", + " ax2.plot(K_values, [results_geneva['panet'][k] for k in K_values], \n", + " marker='o', label='Geneva (small shift)', linewidth=2)\n", + " ax2.plot(K_values, [results_vienna['panet'][k] for k in K_values], \n", + " marker='s', label='Vienna (medium shift)', linewidth=2)\n", + " ax2.plot(K_values, [results_austin['panet'][k] for k in K_values], \n", + " marker='^', label='Austin (large shift)', linewidth=2)\n", + " \n", + " ax2.set_xlabel('K (number of support examples)', fontsize=12)\n", + " ax2.set_ylabel('Mean IoU', fontsize=12)\n", + " ax2.set_title('PANet: Performance vs Domain Shift', fontsize=14)\n", + " ax2.legend(fontsize=10)\n", + " ax2.grid(True, alpha=0.3)\n", + " \n", + " plt.tight_layout()\n", + " \n", + " if save_path:\n", + " plt.savefig(save_path, dpi=300, bbox_inches='tight')\n", + " plt.show()\n", + "\n", + "# Usage example:\n", + "# city_data = load_and_prepare_inria(cities=['vienna', 'austin'])\n", + "# vienna_tiles = tile_inria_images(city_data['vienna'], output_dir='data/inria/vienna')\n", + "# austin_tiles = tile_inria_images(city_data['austin'], output_dir='data/inria/austin')\n", + "# results = evaluate_cross_city_transfer(model, geneva_train, vienna_tiles, austin_tiles)\n", + "\"\"\"\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 7. Recommended Starting Points for Implementation\n", + "\n", + "### For This Tutorial Specifically\n", + "\n", + "Based on our rooftop segmentation task, here are the most relevant resources:\n", + "\n", + "#### 1. **Start with PFENet for Understanding** ⭐ RECOMMENDED\n", + " ```bash\n", + " git clone https://github.com/dvlab-research/PFENet\n", + " ```\n", + " **Why**: \n", + " - Cleanest PyTorch implementation\n", + " - Well-documented code structure\n", + " - Easy to adapt for binary segmentation\n", + " - Good episodic training examples\n", + " \n", + " **Use for**: Understanding episodic training loop and prototype computation\n", + "\n", + "#### 2. **Study PANet Official Implementation**\n", + " ```bash\n", + " git clone https://github.com/kaixin96/PANet\n", + " ```\n", + " **Why**:\n", + " - Official implementation\n", + " - Complete masked average pooling code\n", + " - Even though it's TensorFlow, the logic is clear\n", + " \n", + " **Use for**: Understanding PANet architecture details\n", + "\n", + "#### 3. **Use HSNet for PyTorch PANet-style Implementation**\n", + " ```bash\n", + " git clone https://github.com/juhongm999/hsnet\n", + " ```\n", + " **Why**:\n", + " - Modern PyTorch implementation\n", + " - Similar to PANet but better documented\n", + " - Can adapt their prototype extraction code\n", + " \n", + " **Use for**: Adapting masked average pooling to our dataset\n", + "\n", + "#### 4. **Leverage segmentation_models.pytorch for Baseline**\n", + " ```bash\n", + " pip install segmentation-models-pytorch\n", + " ```\n", + " **Why**:\n", + " - Pre-built U-Net, DeepLabV3 models\n", + " - Easy to use for fine-tuning baseline\n", + " - Lots of pre-trained encoders (ResNet, EfficientNet)\n", + " \n", + " **Use for**: Quick baseline implementation\n", + "\n", + "#### 5. **Use learn2learn for Prototypical Networks**\n", + " ```bash\n", + " pip install learn2learn\n", + " ```\n", + " **Why**:\n", + " - High-level API for meta-learning\n", + " - Built-in episodic data loaders\n", + " - Prototypical Networks already implemented\n", + " \n", + " **Use for**: Prototypical Networks implementation\n", + "\n", + "### Suggested Code Reuse Strategy\n", + "\n", + "#### Phase 1: Baseline (Fine-tuning)\n", + "```python\n", + "# Use segmentation_models.pytorch\n", + "import segmentation_models_pytorch as smp\n", + "\n", + "model = smp.Unet(\n", + " encoder_name=\"resnet34\",\n", + " encoder_weights=\"imagenet\",\n", + " in_channels=3,\n", + " classes=2\n", + ")\n", + "\n", + "# Train on Grid 1301_11\n", + "# Fine-tune on K examples from target grid\n", + "```\n", + "\n", + "#### Phase 2: Prototypical Networks\n", + "```python\n", + "# Adapt from PFENet or learn2learn\n", + "# Reference: https://github.com/dvlab-research/PFENet/blob/master/model/PFENet.py\n", + "\n", + "# Key components to adapt:\n", + "# 1. Episodic data loader (sample K-shot tasks)\n", + "# 2. Prototype computation (masked average pooling)\n", + "# 3. Distance-based classification\n", + "```\n", + "\n", + "#### Phase 3: PANet\n", + "```python\n", + "# Adapt from HSNet\n", + "# Reference: https://github.com/juhongm999/hsnet/blob/main/model/hsnet.py\n", + "\n", + "# Key components to adapt:\n", + "# 1. Multi-scale feature extraction\n", + "# 2. Masked average pooling (more sophisticated than Prototypical)\n", + "# 3. Cosine similarity matching\n", + "```\n", + "\n", + "### Recommended External Dataset\n", + "\n", + "For cross-city evaluation, use **Inria Aerial Dataset (Vienna)**:\n", + "\n", + "```python\n", + "# Available on HuggingFace\n", + "from datasets import load_dataset\n", + "\n", + "inria = load_dataset(\"Jonathan/INRIA-Aerial-Dataset\", split=\"train\")\n", + "\n", + "# Filter for Vienna\n", + "vienna_data = inria.filter(lambda x: x['city'] == 'vienna')\n", + "```\n", + "\n", + "**Why Vienna**:\n", + "- Similar to Geneva (European city)\n", + "- Same coordinate system (will look similar visually)\n", + "- But different architecture/urban layout\n", + "- Perfect for testing domain adaptation\n", + "\n", + "**Alternative**: Use **Austin** from Inria for larger domain shift (US city, very different)\n", + "\n", + "### Code Adaptation Checklist\n", + "\n", + "When adapting code from repositories above:\n", + "\n", + "- [ ] **Data loader**: Modify to load Geneva dataset format\n", + "- [ ] **Number of classes**: Change from N-way to binary (rooftop/background)\n", + "- [ ] **Image size**: Adapt to 250x250 (Geneva's size)\n", + "- [ ] **Episodic sampling**: Sample from single grid (1301_11) instead of class-based sampling\n", + "- [ ] **Evaluation**: Add geographic split evaluation (test on different grids)\n", + "- [ ] **Metrics**: Ensure IoU computation is correct for binary segmentation\n", + "\n", + "### Quick Start Code Snippets\n", + "\n", + "#### Episodic Data Loader (adapt from PFENet)\n", + "```python\n", + "class EpisodicDataLoader:\n", + " def __init__(self, grid_data, n_shot=5, n_query=5):\n", + " self.grid_data = grid_data # List of (image, mask) pairs\n", + " self.n_shot = n_shot\n", + " self.n_query = n_query\n", + " \n", + " def __iter__(self):\n", + " while True:\n", + " # Sample K support + Q query from grid\n", + " indices = np.random.choice(len(self.grid_data), \n", + " self.n_shot + self.n_query, \n", + " replace=False)\n", + " \n", + " support_idx = indices[:self.n_shot]\n", + " query_idx = indices[self.n_shot:]\n", + " \n", + " support_imgs = [self.grid_data[i][0] for i in support_idx]\n", + " support_masks = [self.grid_data[i][1] for i in support_idx]\n", + " query_imgs = [self.grid_data[i][0] for i in query_idx]\n", + " query_masks = [self.grid_data[i][1] for i in query_idx]\n", + " \n", + " yield (support_imgs, support_masks, query_imgs, query_masks)\n", + "```\n", + "\n", + "#### Masked Average Pooling (adapt from PANet/HSNet)\n", + "```python\n", + "def masked_average_pooling(features, masks):\n", + " \\\"\\\"\\\"\n", + " Compute prototypes using masked average pooling.\n", + " \n", + " Args:\n", + " features: [K, C, H, W] - support features\n", + " masks: [K, H, W] - support masks\n", + " \n", + " Returns:\n", + " fg_proto, bg_proto: [C] - class prototypes\n", + " \\\"\\\"\\\"\n", + " # Resize masks to feature resolution\n", + " masks = F.interpolate(masks.unsqueeze(1).float(), \n", + " size=features.shape[-2:], \n", + " mode='nearest').squeeze(1)\n", + " \n", + " # Foreground prototype\n", + " fg_mask = (masks == 1).unsqueeze(1) # [K, 1, H, W]\n", + " fg_features = features * fg_mask\n", + " fg_proto = fg_features.sum(dim=(0, 2, 3)) / (fg_mask.sum() + 1e-5)\n", + " \n", + " # Background prototype \n", + " bg_mask = (masks == 0).unsqueeze(1)\n", + " bg_features = features * bg_mask\n", + " bg_proto = bg_features.sum(dim=(0, 2, 3)) / (bg_mask.sum() + 1e-5)\n", + " \n", + " return fg_proto, bg_proto\n", + "```\n", + "\n", + "### Additional Resources for Debugging\n", + "\n", + "1. **Visualization Tools**\n", + " - Use `tensorboard` for training monitoring\n", + " - Use `matplotlib` for prototype visualization\n", + " - Use `sklearn.manifold.TSNE` for embedding visualization\n", + "\n", + "2. **Debugging Few-Shot Learning**\n", + " - Common issue: Prototypes collapse (all embeddings same)\n", + " - Solution: Check learning rate, add normalization\n", + " - Test on PASCAL-5i first to verify implementation works\n", + "\n", + "3. **Expected Results (Sanity Checks)**\n", + " - Zero-shot on Geneva grids: ~0.45-0.55 IoU\n", + " - Fine-tuning K=5: ~0.60-0.70 IoU\n", + " - Prototypical K=5: ~0.65-0.75 IoU\n", + " - PANet K=5: ~0.70-0.80 IoU\n", + "\n", + "### Citation\n", + "\n", + "If you use these approaches in your tutorial, cite the key papers:\n", + "\n", + "```bibtex\n", + "@inproceedings{wang2019panet,\n", + " title={PANet: Few-shot image semantic segmentation with prototype alignment},\n", + " author={Wang, Kaixin and Liew, Jun Hao and Zou, Yingtian and Zhou, Daquan and Feng, Jiashi},\n", + " booktitle={ICCV},\n", + " year={2019}\n", + "}\n", + "\n", + "@inproceedings{snell2017prototypical,\n", + " title={Prototypical networks for few-shot learning},\n", + " author={Snell, Jake and Swersky, Kevin and Zemel, Richard},\n", + " booktitle={NeurIPS},\n", + " year={2017}\n", + "}\n", + "\n", + "@misc{geneva-satellite-dataset,\n", + " title={Geneva Satellite Images Dataset},\n", + " author={OverfitTeam},\n", + " year={2024},\n", + " publisher={HuggingFace},\n", + " url={https://huggingface.co/datasets/raphaelattias/overfitteam-geneva-satellite-images}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 8. References & Resources\n", + "\n", + "### Academic Papers\n", + "\n", + "#### Few-Shot Learning Foundations\n", + "\n", + "1. **Prototypical Networks for Few-shot Learning**\n", + " - Snell, J., Swersky, K., & Zemel, R. (2017)\n", + " - NeurIPS 2017\n", + " - Paper: https://arxiv.org/abs/1703.05175\n", + " - *Foundation paper for prototypical networks in classification*\n", + "\n", + "2. **Model-Agnostic Meta-Learning (MAML)**\n", + " - Finn, C., Abbeel, P., & Levine, S. (2017)\n", + " - ICML 2017\n", + " - Paper: https://arxiv.org/abs/1703.03400\n", + " - *Alternative meta-learning approach (more complex)*\n", + "\n", + "#### Few-Shot Semantic Segmentation\n", + "\n", + "3. **PANet: Few-Shot Image Semantic Segmentation with Prototype Alignment**\n", + " - Wang, K., Liew, J. H., Zou, Y., Zhou, D., & Feng, J. (2019)\n", + " - ICCV 2019\n", + " - Paper: https://arxiv.org/abs/1908.06391\n", + " - GitHub: https://github.com/kaixin96/PANet\n", + " - *The main PANet paper - state-of-art few-shot segmentation*\n", + "\n", + "4. **Adaptive Masked Proxies for Few-Shot Segmentation**\n", + " - Boudiaf, M., Kervadec, H., Masud, Z. I., Piantanida, P., Ben Ayed, I., & Dolz, J. (2021)\n", + " - ICCV 2021\n", + " - Paper: https://arxiv.org/abs/2102.11123\n", + " - GitHub: https://github.com/mboudiaf/RePRI-for-Few-Shot-Segmentation\n", + " - *Improved version of PANet with adaptive prototypes*\n", + "\n", + "5. **HSNet: Hypercorrelation Squeeze for Few-Shot Segmentation**\n", + " - Min, J., Kang, D., & Cho, M. (2021)\n", + " - ICCV 2021\n", + " - Paper: https://arxiv.org/abs/2109.06211\n", + " - GitHub: https://github.com/juhongm999/hsnet\n", + " - *Alternative approach using correlation matching*\n", + "\n", + "6. **Meta-Learning for Few-Shot Semantic Segmentation**\n", + " - Tian, P., Wu, Z., Qi, L., Wang, L., Shi, Y., & Gao, Y. (2020)\n", + " - Pattern Recognition 2020\n", + " - Paper: https://arxiv.org/abs/2004.07730\n", + " - *Good survey of meta-learning for segmentation*\n", + "\n", + "#### Remote Sensing & Building Segmentation\n", + "\n", + "7. **Building Extraction from Remote Sensing Images with Deep Learning**\n", + " - Ji, S., Wei, S., & Lu, M. (2019)\n", + " - Remote Sensing 2019\n", + " - Paper: https://www.mdpi.com/2072-4292/11/7/778\n", + " - *Survey of building segmentation methods*\n", + "\n", + "8. **Domain Adaptation for Semantic Segmentation of Urban Scenes**\n", + " - Hoffman, J., et al. (2018)\n", + " - CVPR 2018\n", + " - Paper: https://arxiv.org/abs/1711.06969\n", + " - *Related work on domain adaptation for urban scenes*\n", + "\n", + "### GitHub Repositories\n", + "\n", + "#### Few-Shot Segmentation Implementations\n", + "\n", + "1. **PANet (Official)**\n", + " - https://github.com/kaixin96/PANet\n", + " - TensorFlow implementation of PANet\n", + " - Includes PASCAL-5i and COCO-20i benchmarks\n", + "\n", + "2. **Few-Shot Semantic Segmentation Papers and Code**\n", + " - https://github.com/xiaomengyc/Few-Shot-Semantic-Segmentation-Papers\n", + " - Comprehensive collection of papers and code\n", + " - Updated regularly with new methods\n", + "\n", + "3. **PFENet: Prior Guided Feature Enrichment Network**\n", + " - https://github.com/dvlab-research/PFENet\n", + " - TPAMI 2020\n", + " - PyTorch, very clean implementation\n", + " - Good starting point for understanding few-shot segmentation\n", + "\n", + "4. **HSNet (Hypercorrelation Squeeze Network)**\n", + " - https://github.com/juhongm999/hsnet\n", + " - PyTorch implementation\n", + " - State-of-art results, well-documented\n", + "\n", + "5. **RePRI: Adaptive Masked Proxies**\n", + " - https://github.com/mboudiaf/RePRI-for-Few-Shot-Segmentation\n", + " - PyTorch implementation\n", + " - Improved PANet variant\n", + "\n", + "#### Prototypical Networks Implementations\n", + "\n", + "6. **Prototypical Networks (PyTorch)**\n", + " - https://github.com/orobix/Prototypical-Networks-for-Few-shot-Learning-PyTorch\n", + " - Clean PyTorch reimplementation\n", + " - Good for understanding prototypical networks\n", + "\n", + "7. **Few-Shot Learning Library (learn2learn)**\n", + " - https://github.com/learnables/learn2learn\n", + " - PyTorch library for meta-learning\n", + " - Includes MAML, Prototypical Networks, and more\n", + " - Great for experimentation\n", + "\n", + "#### Building/Rooftop Segmentation\n", + "\n", + "8. **SpaceNet Building Detection**\n", + " - https://github.com/SpaceNetChallenge/BuildingDetectors\n", + " - Collection of winning solutions for building detection\n", + " - Various architectures (U-Net, Mask R-CNN, etc.)\n", + "\n", + "9. **Inria Aerial Image Labeling Benchmark**\n", + " - https://github.com/zorzi-s/projectRegularization\n", + " - Segmentation on Inria dataset\n", + " - Building footprint extraction\n", + "\n", + "10. **Rooftop Segmentation for Solar Potential**\n", + " - https://github.com/mdominguezd/Solar-Panel-Installability\n", + " - Solar panel rooftop segmentation\n", + " - Similar application to our use case\n", + "\n", + "### Datasets\n", + "\n", + "#### Few-Shot Segmentation Benchmarks\n", + "\n", + "1. **PASCAL-5i**\n", + " - Standard few-shot segmentation benchmark\n", + " - 4-fold cross-validation setup\n", + " - Download: http://host.robots.ox.ac.uk/pascal/VOC/\n", + "\n", + "2. **COCO-20i**\n", + " - MS COCO adapted for few-shot segmentation\n", + " - 20 classes, 4 splits\n", + " - Download: https://cocodataset.org/\n", + "\n", + "#### Remote Sensing & Building Datasets\n", + "\n", + "3. **Inria Aerial Image Dataset**\n", + " - 5 cities, 180 kmΒ² coverage\n", + " - Building footprints\n", + " - Download: https://project.inria.fr/aerialimagelabeling/\n", + " - HuggingFace: https://huggingface.co/datasets/Jonathan/INRIA-Aerial-Dataset\n", + "\n", + "4. **SpaceNet Building Dataset**\n", + " - Multiple cities worldwide\n", + " - High-resolution satellite imagery\n", + " - Download: https://spacenet.ai/datasets/\n", + "\n", + "5. **Massachusetts Buildings Dataset**\n", + " - 151 aerial images\n", + " - Building segmentation masks\n", + " - Download: https://www.cs.toronto.edu/~vmnih/data/\n", + "\n", + "6. **Open Cities AI Challenge Dataset**\n", + " - African cities building footprints\n", + " - Good for domain adaptation\n", + " - Download: https://www.drivendata.org/competitions/60/building-segmentation-disaster-resilience/\n", + "\n", + "7. **xBD (xView2) Building Damage Dataset**\n", + " - Pre/post disaster building assessment\n", + " - Multiple cities\n", + " - Download: https://xview2.org/\n", + "\n", + "### Related Tutorials & Blog Posts\n", + "\n", + "1. **Few-Shot Learning Tutorial**\n", + " - https://lilianweng.github.io/posts/2018-11-30-meta-learning/\n", + " - Excellent overview of meta-learning approaches\n", + " - By Lilian Weng (OpenAI)\n", + "\n", + "2. **Prototypical Networks Explained**\n", + " - https://towardsdatascience.com/prototypical-networks-for-few-shot-learning-eb2c2b86baac\n", + " - Intuitive explanation with code examples\n", + "\n", + "3. **Satellite Image Segmentation**\n", + " - https://github.com/robmarkcole/satellite-image-deep-learning\n", + " - Comprehensive resource for satellite image analysis\n", + " - Includes segmentation techniques\n", + "\n", + "### Useful Libraries\n", + "\n", + "1. **segmentation_models.pytorch**\n", + " - https://github.com/qubvel/segmentation_models.pytorch\n", + " - Pre-built segmentation architectures (U-Net, DeepLab, etc.)\n", + " - Good for baseline implementations\n", + "\n", + "2. **Albumentations**\n", + " - https://github.com/albumentations-team/albumentations\n", + " - Data augmentation library\n", + " - Essential for episodic training\n", + "\n", + "3. **PyTorch Metric Learning**\n", + " - https://github.com/KevinMusgrave/pytorch-metric-learning\n", + " - Useful for prototypical networks\n", + " - Distance metrics, losses, miners\n", + "\n", + "### Community & Forums\n", + "\n", + "1. **Papers with Code - Few-Shot Segmentation**\n", + " - https://paperswithcode.com/task/few-shot-semantic-segmentation\n", + " - Leaderboards, benchmarks, and implementations\n", + "\n", + "2. **r/MachineLearning - Meta-Learning discussions**\n", + " - https://www.reddit.com/r/MachineLearning/\n", + " - Active community for questions\n", + "\n", + "3. **Computer Vision Foundation (CVF) Open Access**\n", + " - https://openaccess.thecvf.com/\n", + " - Free access to CVPR/ICCV/ECCV papers" + ] + } + ], + "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.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/try_few_shot.ipynb b/notebooks/try_few_shot.ipynb new file mode 100644 index 0000000..fedd6b0 --- /dev/null +++ b/notebooks/try_few_shot.ipynb @@ -0,0 +1,1471 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Few-shot semantic segmentation for PV suitability assessment\n", + "\n", + "### Memo\n", + "\n", + "\n", + "This notebook offers an in-depth look at few-shot learning (FSL), an advanced deep learning technique that enables models to generalize effectively from only a small number of training examples. FSL becomes particularly valuable when traditional supervised learning is impractical. For instance, when annotation is expensive, requires specialized expertise, or when data is scarce. \n", + "Few-shot learning is especially relevant in the context of public policy, where we often face limited access to comprehensive, well-curated datasets or lack the resources to collect large amounts of training data. Applications span a wide range of policy areas, including disaster classification (Lee et al., 2025), urban planning (Hu et al., 2022) and health policy, where FSL has supported COVID-19 detection (Jadon, 2021) and the diagnosis of rare genetic diseases (Alsentzer et al., 2025). \n", + "Beyond classification tasks, FSL also performs well in segmentation problems, helping identify different types of buildings, vegetation such as forest cover (Puthumanaillam & Verma, 2023) and performing well in remote sensing imagery segmentation (Chen et al., 2022).All of these examples share a common challenge: limited data. Few-shot learning helps address this constraint, and we encounter similar situations within our own institution. A clear illustration is our Wildlife Trade Monitoring Project (WTMP), where labeled examples of rare, endangered species are extremely scarce and often inconsistent. This emphasizes just how valuable few-shot learning approaches can be. \n", + "Today, a wide range of few-shot learning frameworks and architectures are available. Some of the most widely used include model-agnostic meta-learning (Finn, Abbeel & Levine, 2017), prototypical networks (Snell, Swersky & Zemel, 2017), and relation networks (Sung et al., 2018). Over the past few years, the field has continued to evolve, giving rise to more specialized and state-of-the-art techniques, such as SegPPD-FS for semantic segmentation (Ge et al., 2025) and CDCNet for classification tasks (Li et al., 2025). \n", + "Because of its importance to public policy and its potential value for our organization, this notebook takes a deep dive into prototypical networks semantic segmentation of building rooftops. This is an essential step for many downstream tasks, such as assessing rooftop suitability for solar panel installation. By walking through this method, the notebook aims to help our staff better understand and apply this powerful technique in their day-to-day work.\n", + "\n", + "---\n", + "\n", + "### Introduction\n", + "\n", + "Dear colleagues, \n", + "In this notebook, we will introduce the concept of few-shot learning (FSL). As briefly mentioned earlier, FSL is an advanced deep learning paradigm that enables models to generalize from only a handful of annotated samples. In particular, we will focus on prototypical networks, which learn a metric space where each class is represented by a prototype (usually the mean embedding of its support examples) and then classify query samples based on their distance to these prototypes (more details will be provided below). This method can be applied to semantic segmentation tasks, allowing us to partition an image into meaningful regions.\n", + "To guide you through this approach, we will work with the Geneva Satellite Images dataset. This dataset contains high-resolution (250Γ—250 PNG tiles) satellite imagery of Geneva, Switzerland, along with pixel-level segmentation masks that delineate building rooftops. It was developed by EPFL’s Solar Energy and Building Physics Laboratory and is publicly available on [HuggingFace](https://huggingface.co/datasets/raphaelattias/overfitteam-geneva-satellite-images)\n", + " (Castello et al., 2021). \n", + "The goal of this notebook is to demonstrate how few-shot learning can be used for rooftop semantic segmentation, with applications such as assessing the suitability of buildings for solar panels. \n", + "\n", + "Throughout the notebook, we will walk you through how to: \n", + "\n", + "- Load and preprocess satellite imagery\n", + "- Build a few-shot segmentation model\n", + "- Train the model using prototypical networks\n", + "- Evaluate segmentation performance \n", + " \n", + "Your task is to follow the code and understand how to apply few-shot learning to detect rooftops in new satellite images using only a few labeled examples. You can run each cell in sequence. At every step, we provide clear explanations of what is happening. A pre-recorded video is also available if you prefer a more visual learning format. \n", + "\n", + "If you have any questions about few-shot learning or need help with its implementation, please feel free to reach out. Our contact information is provided above. \n", + " \n", + "Happy learning! \n", + "\n", + "Your Public Innovation Lab (PILAB) \n", + "\n", + "\n", + "---\n", + "\n", + "### Task description\n", + "\n", + "\n", + "- **Binary semantic segmentation** problem: for each pixel in a satellite tile, we predict whether it is part of a rooftop suitable for photovoltaics (PV) or background.\n", + "- The method is based on **prototypical networks for segmentation**: we learn an encoder that maps pixels into an embedding space and then classify each pixel by its distance to simple β€œprototypes” built from a small number of labeled support images. \n", + "\n", + "Instead of training a standard segmentation network on a fully labeled dataset, we:\n", + "\n", + "- Meta-train an encoder on β€œepisodes” that takes 1 support image + mask β†’ learn prototypes β†’ segment a query image.\n", + "- At test time we can feed the model K labeled examples (K-shot) for a new set of tiles and segment unseen images with limited supervision.\n", + "\n", + "---\n", + "\n", + "## Notebook structure\n", + "\n", + "1. **Setup**: install packages and import dependencies \n", + "2. **Data download**: fetch the Geneva rooftop dataset from Hugging Face \n", + "3. **Base dataset**: load images and binary rooftop masks with transforms \n", + "4. **Visualizaion**: visualise a sample image + mask \n", + "5. **Few-shot episodes**: build an episodic dataset (support + query pairs) \n", + "6. **Encoder**: ResNet-based convolutional feature extractor \n", + "7. **Prototypes & classification**: compute foreground/background prototypes and classify pixels \n", + "8. **Metric**: define Intersection-over-Union (IoU) for evaluation \n", + "9. **Meta-training**: episodic training loop for the encoder \n", + "10. **Inference & evaluation**: K-shot prediction, IoU evaluation, and visualisations\n", + "\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup\n", + "\n", + "We first install and import the libraries needed for the tutorial:\n", + "\n", + "- `torch` and `torchvision` for deep learning and pretrained vision models,\n", + "- `matplotlib`, `PIL`, and `numpy` for visualisation and array manipulation,\n", + "- `huggingface_hub` to download the rooftop dataset from the Hugging Face Hub.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/miniconda3/envs/dl-tutorial/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cpu\n" + ] + } + ], + "source": [ + "!pip install -q huggingface_hub torch torchvision matplotlib\n", + "\n", + "import os\n", + "import random\n", + "import numpy as np\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torch.utils.data import Dataset, DataLoader, Subset\n", + "from torchvision import transforms, models\n", + "from huggingface_hub import snapshot_download\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(\"Using device:\", device)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Data download: Geneva rooftop tiles\n", + "\n", + "We use a small satellite dataset of building rooftops in Geneva, stored on the Hugging Face Hub. Each tile comes with:\n", + "\n", + "- a **RGB satellite image**, and\n", + "- a **binary mask** indicating pixels that belong to rooftops suitable for PV installations.\n", + "\n", + "Using `huggingface_hub.snapshot_download`, we download the dataset to the local filesystem.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching ... files: 2111it [00:00, 566268.59it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset root: /Users/nicolasreichardt/.cache/huggingface/hub/datasets--raphaelattias--overfitteam-geneva-satellite-images/snapshots/3f90d759384e4cd38276290521b6f6b03ddfcf87\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "dataset_root = snapshot_download(\n", + " repo_id=\"raphaelattias/overfitteam-geneva-satellite-images\",\n", + " repo_type=\"dataset\"\n", + ")\n", + "print(\"Dataset root:\", dataset_root)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Data preprocessing\n", + "\n", + "To work with PyTorch, we define a `Dataset` class that returns `(image, mask)` pairs:\n", + "\n", + "- Images are resized to a fixed resolution of **256 Γ— 256**, converted to PyTorch tensors, and normalised with **ImageNet mean and standard deviation**. This is compatible with the pretrained ResNet18 backbone we will use later. \n", + "- Masks are resized using **nearest-neighbour interpolation** to avoid mixing labels at boundaries, converted to tensors in `[0, 1]`, and then **binarised** pixels so that any non-zero value is treated as rooftop (class 1): mask pixels can be either background or rooftop.\n", + "\n", + "The `GenevaRooftopDataset` class wraps these steps and reads from a structured folder layout with `images/` and `labels/` subdirectories. We instantiate three splits: train, validation, and test. These base datasets will later feed into both standard visualisation and our few-shot episodic sampling.\n", + "\n", + "> **Notice** \n", + "> *To be changed if we do geosplits* \n", + "> *Also, even if we don't do geosplits, we don't need the validation set*\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train samples: 423, Test samples: 102\n" + ] + } + ], + "source": [ + "### CODE IF WE WANT TO SPLIT DATASET WITH THE GEOSPLIT (normal split below) - ONE HAS TO BE ERASED\n", + "\n", + "IMAGE_SIZE = 256 # resize tiles to this\n", + "\n", + "img_transform = transforms.Compose([\n", + " transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225]),\n", + "])\n", + "\n", + "mask_transform = transforms.Compose([\n", + " transforms.Resize((IMAGE_SIZE, IMAGE_SIZE), interpolation=Image.NEAREST),\n", + " transforms.ToTensor(), # gives float [0,1] for grayscale\n", + "])\n", + "\n", + "def get_grid_id_from_filename(fname):\n", + " parts = fname.split(\"_\")\n", + " # 3th and 3th parts give the grid ID\n", + " return f\"{parts[2]}_{parts[3]}\"\n", + "\n", + "class GenevaRooftopDataset(Dataset):\n", + " \"\"\"\n", + " Dataset filtered by geographic grid IDs.\n", + " Can read from multiple splits (train/val/test) at once.\n", + " \"\"\"\n", + " def __init__(self, root, splits=[\"train\", \"val\", \"test\"], category=\"all\", grid_ids=None):\n", + " super().__init__()\n", + " self.root = root\n", + " self.category = category\n", + " self.grid_ids = grid_ids\n", + " self.files_info = [] # list of tuples (split, filename)\n", + "\n", + " # Collect files from all specified splits\n", + " for split in splits:\n", + " image_dir = os.path.join(root, split, \"images\", category)\n", + " label_dir = os.path.join(root, split, \"labels\", category)\n", + "\n", + " all_files = sorted([f for f in os.listdir(image_dir) if f.endswith(\".png\")])\n", + "\n", + " # Filter by grid_ids if provided\n", + " if grid_ids is not None:\n", + " all_files = [f for f in all_files if get_grid_id_from_filename(f) in grid_ids]\n", + "\n", + " # Store split info for loading\n", + " self.files_info.extend([(split, f) for f in all_files])\n", + "\n", + " def __len__(self):\n", + " return len(self.files_info)\n", + "\n", + " def __getitem__(self, idx):\n", + " split, fname = self.files_info[idx]\n", + " img_path = os.path.join(self.root, split, \"images\", self.category, fname)\n", + " mask_name = fname.replace(\".png\", \"_label.png\")\n", + " mask_path = os.path.join(self.root, split, \"labels\", self.category, mask_name)\n", + "\n", + " img = Image.open(img_path).convert(\"RGB\")\n", + " mask = Image.open(mask_path).convert(\"L\")\n", + "\n", + " img = img_transform(img)\n", + " mask = mask_transform(mask)\n", + " mask = (mask > 0.5).float()\n", + "\n", + " return img, mask\n", + "\n", + "\n", + "\n", + "train_grids = [\"1301_11\", \"1301_31\"]\n", + "test_grids = [\"1301_13\"]\n", + "\n", + "# Train dataset reads from all three folders\n", + "train_dataset = GenevaRooftopDataset(dataset_root, splits=[\"train\", \"val\", \"test\"], grid_ids=train_grids)\n", + "\n", + "# Test dataset can read from just one folder or multiple if needed\n", + "test_dataset = GenevaRooftopDataset(dataset_root, splits=[\"train\", \"val\", \"test\"], grid_ids=test_grids)\n", + "\n", + "print(f\"Train samples: {len(train_dataset)}, Test samples: {len(test_dataset)}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train samples: 420, Val: 52, Test: 53\n" + ] + } + ], + "source": [ + "# ============================================================\n", + "# 2. Base dataset: load images & masks with transforms\n", + "# ============================================================\n", + "\n", + "### CODE IF WE WANT TO SPLIT DATASET WITH THE PROVIDED SPLIT BY FOLDERS - THIS OR THE PREVIOUS CELL HAS TO BE ERASED\n", + "\n", + "\n", + "IMAGE_SIZE = 256 # resize tiles to this\n", + "\n", + "img_transform = transforms.Compose([\n", + " transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225]),\n", + "])\n", + "\n", + "mask_transform = transforms.Compose([\n", + " transforms.Resize((IMAGE_SIZE, IMAGE_SIZE), interpolation=Image.NEAREST),\n", + " transforms.ToTensor(), # gives float [0,1] for grayscale\n", + "])\n", + "\n", + "class GenevaRooftopDataset(Dataset):\n", + " \"\"\"\n", + " Regular (image, mask) dataset for one split and category.\n", + " Mask is binary: 1 = rooftop suitable for PV, 0 = background.\n", + " \"\"\"\n", + " def __init__(self, root, split=\"train\", category=\"all\"):\n", + " super().__init__()\n", + " self.root = root\n", + " self.split = split\n", + " self.category = category\n", + "\n", + " self.image_dir = os.path.join(root, split, \"images\", category)\n", + " self.label_dir = os.path.join(root, split, \"labels\", category)\n", + "\n", + " self.filenames = sorted([\n", + " f for f in os.listdir(self.image_dir) if f.endswith(\".png\")\n", + " ])\n", + "\n", + " def __len__(self):\n", + " return len(self.filenames)\n", + "\n", + " def __getitem__(self, idx):\n", + " fname = self.filenames[idx]\n", + "\n", + " img_path = os.path.join(self.image_dir, fname)\n", + " label_name = fname.replace(\".png\", \"_label.png\")\n", + " mask_path = os.path.join(self.label_dir, label_name)\n", + "\n", + " img = Image.open(img_path).convert(\"RGB\")\n", + " mask = Image.open(mask_path).convert(\"L\")\n", + "\n", + " # Apply transforms\n", + " img = img_transform(img)\n", + " mask = mask_transform(mask) # [1, H, W], float\n", + "\n", + " # Binarise: any non-zero pixel -> 1\n", + " mask = (mask > 0.5).float()\n", + "\n", + " return img, mask\n", + "\n", + "# Instantiate datasets (we focus on 'all' category)\n", + "train_base = GenevaRooftopDataset(dataset_root, split=\"train\", category=\"all\")\n", + "val_base = GenevaRooftopDataset(dataset_root, split=\"val\", category=\"all\")\n", + "test_base = GenevaRooftopDataset(dataset_root, split=\"test\", category=\"all\")\n", + "\n", + "print(f\"Train samples: {len(train_base)}, Val: {len(val_base)}, Test: {len(test_base)}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Visualization: image and mask\n", + "\n", + "We verify that images and masks line up correctly, and pixel masks have the expected binary structure. The helper function below randomly draws a sample from a given dataset, undoes the image normalisation for plotting, and displays the RGB image side-by-side with its rooftop mask.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def show_sample(dataset, idx=None):\n", + " if idx is None:\n", + " idx = random.randint(0, len(dataset) - 1)\n", + " img, mask = dataset[idx] # img [3,H,W], mask [1,H,W]\n", + "\n", + " # Undo normalisation for plotting\n", + " img_np = img.permute(1, 2, 0).numpy()\n", + " img_np = (img_np * np.array([0.229, 0.224, 0.225]) +\n", + " np.array([0.485, 0.456, 0.406]))\n", + " img_np = np.clip(img_np, 0, 1)\n", + "\n", + " # mask: [1, H, W] -> [H, W]\n", + " mask_np = mask.squeeze(0).numpy()\n", + "\n", + " plt.figure(figsize=(8, 4))\n", + " plt.subplot(1, 2, 1)\n", + " plt.imshow(img_np)\n", + " plt.title(\"Image\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(1, 2, 2)\n", + " plt.imshow(mask_np, cmap=\"gray\")\n", + " plt.title(\"Mask (rooftop)\")\n", + " plt.axis(\"off\")\n", + " plt.show()\n", + "\n", + "show_sample(train_base)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 5. Methodology \n", + "\n", + "## 5.1. Few-shot episodes: support and query\n", + "\n", + "Few-shot learning is typically implemented with **episodic training**. An **episode** is one small training problem that mimics how we will use the model at test time: we see some labelled examples (support) and we must make predictions for new data (query).\n", + "\n", + "In this setting, each episode contains:\n", + "\n", + "- a **support image with its mask** `(img_s, mask_s)`, and \n", + "- a **query image with its mask** `(img_q, mask_q)`.\n", + "\n", + "We create an `EpisodeDataset` that wraps the base training dataset. For every episode, it randomly picks two *different* tiles from the training set:\n", + "\n", + "- one becomes the support pair,\n", + "- the other becomes the query pair.\n", + "\n", + "During training, the model:\n", + "\n", + "1. looks at the **support image + mask** to learn what rooftops and background look like, and \n", + "2. tries to correctly segment the **query image**, using that information.\n", + "\n", + "The parameter `episodes_per_epoch` defines how many such support–query pairs (episodes) we use in one training epoch. A `DataLoader` iterates over this dataset and gives us **one episode at a time** for training.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "class EpisodeDataset(Dataset):\n", + " \"\"\"\n", + " Yields (support_image, support_mask, query_image, query_mask).\n", + " We sample two different tiles from the base training set for each episode.\n", + " \"\"\"\n", + " def __init__(self, base_dataset, episodes_per_epoch=750):\n", + " self.base = base_dataset\n", + " self.episodes_per_epoch = episodes_per_epoch\n", + " self.n = len(base_dataset)\n", + "\n", + " def __len__(self):\n", + " return self.episodes_per_epoch\n", + "\n", + " def __getitem__(self, idx):\n", + " i, j = random.sample(range(self.n), 2)\n", + " img_s, mask_s = self.base[i]\n", + " img_q, mask_q = self.base[j]\n", + " return img_s, mask_s, img_q, mask_q\n", + "\n", + "episodes_per_epoch = 750\n", + "episode_dataset = EpisodeDataset(train_base, episodes_per_epoch=episodes_per_epoch)\n", + "episode_loader = DataLoader(episode_dataset, batch_size=1, shuffle=True)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.2. Encoder backbone: ResNet18 feature extractor\n", + "\n", + "We now define the feature extractor that underpins our prototypical network. The `Encoder` class:\n", + "\n", + "- uses a **pretrained ResNet18** from `torchvision`,\n", + "- keeps the convolutional layers up to `layer3`, which downsample the input by a factor of 8, and\n", + "- adds a `1Γ—1` convolution to project the ResNet features into a configurable embedding dimension (here 256 channels).\n", + "\n", + "Given an input image of shape `[3, H, W]`, the encoder outputs a feature map `[C, H', W']`. These feature maps are the basis for computing class prototypes (rooftop vs background) and for classifying each pixel at test time.\n", + "\n", + "> **Notice:**\n", + "> ResNet18 is lightweight and pretrained on ImageNet. We expect a model pretrained on geospatial/satellite images to perform better as feature extractor → can be a good *extension*. \n", + "> *Question: How changing the backbone architecture changes the performance?*\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Encoder(\n", + " (features): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (4): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (5): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (6): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " )\n", + " (proj): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + ")\n" + ] + } + ], + "source": [ + "class Encoder(nn.Module):\n", + " \"\"\"\n", + " Convolutional encoder using ResNet18 up to layer3 (downsampling by 8),\n", + " followed by a 1x1 conv to get a compact embedding.\n", + " \"\"\"\n", + " def __init__(self, out_channels=256, pretrained=True):\n", + " super().__init__()\n", + " backbone = models.resnet18(pretrained=pretrained)\n", + " self.features = nn.Sequential(\n", + " backbone.conv1,\n", + " backbone.bn1,\n", + " backbone.relu,\n", + " backbone.maxpool,\n", + " backbone.layer1,\n", + " backbone.layer2,\n", + " backbone.layer3,\n", + " )\n", + " # resnet18.layer3 output has 256 channels\n", + " self.proj = nn.Conv2d(256, out_channels, kernel_size=1)\n", + "\n", + " def forward(self, x):\n", + " f = self.features(x) # [B, 256, H', W']\n", + " f = self.proj(f) # [B, C, H', W']\n", + " return f\n", + "\n", + "encoder = Encoder(out_channels=256, pretrained=True).to(device)\n", + "print(encoder)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading: \"https://hf.co/torchgeo/resnet18_sentinel2_rgb_moco/resolve/e1c032e7785fd0625224cdb6699aa138bb304eec/resnet18_sentinel2_rgb_moco-e3a335e3.pth\" to /Users/nicolasreichardt/.cache/torch/hub/checkpoints/resnet18_sentinel2_rgb_moco-e3a335e3.pth\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 42.7M/42.7M [00:01<00:00, 33.0MB/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Encoder(\n", + " (features): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (4): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (drop_block): Identity()\n", + " (act1): ReLU(inplace=True)\n", + " (aa): Identity()\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act2): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (drop_block): Identity()\n", + " (act1): ReLU(inplace=True)\n", + " (aa): Identity()\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act2): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (5): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (drop_block): Identity()\n", + " (act1): ReLU(inplace=True)\n", + " (aa): Identity()\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act2): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (drop_block): Identity()\n", + " (act1): ReLU(inplace=True)\n", + " (aa): Identity()\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act2): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (6): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (drop_block): Identity()\n", + " (act1): ReLU(inplace=True)\n", + " (aa): Identity()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act2): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (drop_block): Identity()\n", + " (act1): ReLU(inplace=True)\n", + " (aa): Identity()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act2): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (proj): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + ")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from torchgeo.models import resnet18, ResNet18_Weights\n", + "\n", + "class Encoder(nn.Module):\n", + " def __init__(self, out_channels=256):\n", + " super().__init__()\n", + " # Use a ResNet18 pretrained on RGB imagery instead\n", + " backbone = resnet18(weights=ResNet18_Weights.SENTINEL2_RGB_MOCO) # RGB version\n", + "\n", + " self.features = nn.Sequential(\n", + " backbone.conv1,\n", + " backbone.bn1,\n", + " backbone.act1,\n", + " backbone.maxpool,\n", + " backbone.layer1,\n", + " backbone.layer2,\n", + " backbone.layer3,\n", + " )\n", + " self.proj = nn.Conv2d(256, out_channels, kernel_size=1)\n", + "\n", + " def forward(self, x):\n", + " f = self.features(x)\n", + " f = self.proj(f)\n", + " return f\n", + "\n", + "encoder = Encoder(out_channels=256).to(device)\n", + "print(encoder)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.3. Prototypical segmentation: prototypes and query classification\n", + "\n", + "The core idea of prototypical networks is to represent each class by a **prototype vector** in feature space and to classify new examples based on their distance to these prototypes.\n", + "\n", + "For segmentation we apply this idea at the **pixel level**. In this case we have only one class (we are segmenting rooftops from background): binary case (rooftop vs non-rooftop), therefore we are using a 2-class prototypical network.\n", + "\n", + "- From the support images and their masks, we compute:\n", + " - a **foreground prototype** (rooftops),\n", + " - and a **background prototype**,\n", + " by performing masked average pooling over the encoder feature maps.\n", + " \n", + "- For a query image, we run the encoder once to obtain features and then:\n", + " - compute the squared Euclidean distance from each pixel’s feature vector to each prototype,\n", + " - convert distances into logits (negative distances),\n", + " - and reshape to a `[1, 2, H', W']` logit map over classes 0 (background) and 1 (rooftop).\n", + "\n", + "These two functions, `compute_prototypes` and `classify_query`, implement the prototypical segmentation logic used in both training and evaluation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "# ============================================================\n", + "# 6. Prototype computation & query classification\n", + "# ============================================================\n", + "\n", + "import torch.nn.functional as F\n", + "\n", + "def compute_prototypes(feat_support, mask_support):\n", + " \"\"\"\n", + " Compute background/foreground prototypes from multiple support images.\n", + "\n", + " feat_support: [K, C, H', W'] (K support images)\n", + " mask_support: [K, 1, H, W] (binary masks)\n", + " Returns: prototypes [2, C] (0=background, 1=foreground)\n", + " \"\"\"\n", + " # Downsample mask to feature resolution\n", + " mask_small = F.interpolate(mask_support, size=feat_support.shape[2:], mode=\"nearest\") # Downsamples masks to feature size via nearest neighbor\n", + " mask_fg = (mask_small > 0.5).float() # [K,1,H',W']\n", + " mask_bg = 1.0 - mask_fg # [K,1,H',W']\n", + "\n", + " K, C, Hf, Wf = feat_support.shape\n", + "\n", + " # Flatten across batch and spatial dims: [K,C,H',W'] -> [C, K*H'*W']\n", + " fs = feat_support.permute(1, 0, 2, 3).contiguous().view(C, -1) # [C, K*H'*W']\n", + " fg_w = mask_fg.view(1, -1) # [1, K*H'*W']\n", + " bg_w = mask_bg.view(1, -1)\n", + "\n", + " eps = 1e-6\n", + "\n", + " # Weighted average for foreground\n", + " fg_proto = (fs * fg_w).sum(dim=1) / (fg_w.sum(dim=1) + eps) # [C]\n", + " # Weighted average for background\n", + " bg_proto = (fs * bg_w).sum(dim=1) / (bg_w.sum(dim=1) + eps) # [C]\n", + "\n", + " prototypes = torch.stack([bg_proto, fg_proto], dim=0) # [2,C]\n", + " return prototypes\n", + "\n", + "def classify_query(feat_query, prototypes):\n", + " \"\"\"\n", + " Classify query pixels by distance to prototypes.\n", + "\n", + " feat_query: [1, C, H', W']\n", + " prototypes: [2, C]\n", + " Returns: logits [1, 2, H', W']\n", + " \"\"\"\n", + " B, C, Hq, Wq = feat_query.shape\n", + "\n", + " # [1,C,H',W'] -> [H'*W', C]\n", + " fq = feat_query.view(C, -1).t() # [H'*W', C]\n", + "\n", + " # [2, C]\n", + " protos = prototypes # [2,C]\n", + "\n", + " # Compute squared Euclidean distance from each pixel to each prototype\n", + " # torch.cdist expects [B, N, D], so add batch dim\n", + " # fq_batch: [1, H'*W', C], protos_batch: [1, 2, C]\n", + " dists = torch.cdist(fq.unsqueeze(0), protos.unsqueeze(0)) # [1, H'*W', 2]\n", + " dists = dists.squeeze(0) # [H'*W', 2]\n", + " dists = dists ** 2\n", + "\n", + " # Convert distances to similarity logits: negative distance\n", + " logits_flat = -dists # [H'*W', 2]\n", + " logits = logits_flat.t().view(1, 2, Hq, Wq) # [1,2,H',W']\n", + "\n", + " return logits\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Evaluation metric: Intersection over Union (IoU)\n", + "\n", + "To evaluate segmentation performance we use **Intersection over Union (IoU)**:\n", + "\n", + "$$\n", + "\\text{IoU} = \\frac{\\text{intersection of predicted and true mask}}{\\text{union of predicted and true mask}}.\n", + "$$\n", + "\n", + "Given the predicted logits `[1, 2, H, W]` and the ground-truth binary mask `[1, 1, H, W]`, we:\n", + "\n", + "1. take the `argmax` over classes to obtain a predicted mask,\n", + "2. compute intersection and union between predicted and true rooftop pixels, and\n", + "3. return IoU as a scalar.\n", + "\n", + "Metric will be used to summarise how well our few-shot model segments rooftops on held-out test images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "def iou_from_logits(logits, target_mask, eps=1e-6):\n", + " \"\"\"\n", + " logits: [1,2,H,W] (class 0=background, 1=foreground)\n", + " target_mask: [1,1,H,W], binary 0/1\n", + " \"\"\"\n", + " # predicted class (0 or 1)\n", + " pred = logits.argmax(dim=1, keepdim=True).float() # [1,1,H,W]\n", + " target = (target_mask > 0.5).float()\n", + "\n", + " intersection = (pred * target).sum()\n", + " union = pred.sum() + target.sum() - intersection\n", + "\n", + " iou = (intersection + eps) / (union + eps)\n", + " return iou.item()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Episodic meta-training\n", + "\n", + "We now train the encoder using episodic supervision. For each episode in the training set:\n", + "\n", + "1. We obtain a support image and mask and a query image and mask.\n", + "2. We encode both images using the shared encoder.\n", + "3. From the support features and mask, we compute foreground and background prototypes.\n", + "4. We classify each pixel in the query feature map by its distance to these prototypes.\n", + "5. We build the query’s ground-truth labels at the feature resolution and compute a **cross-entropy loss** between predicted logits and true classes.\n", + "\n", + "This process makes the encoder to learn a feature space in which simple prototype-based classification works well across many different episodes. After a few epochs, the encoder can be reused for 1-shot or K-shot segmentation on unseen test images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/5 | avg episode loss: 0.3448\n", + "Epoch 2/5 | avg episode loss: 0.2257\n", + "Epoch 3/5 | avg episode loss: 0.1783\n", + "Epoch 4/5 | avg episode loss: 0.1343\n", + "Epoch 5/5 | avg episode loss: 0.1081\n" + ] + } + ], + "source": [ + "### DEPENDING ON WHICH ENCODER CELL WAS RUN LAST, THIS CELL RUNS WITH OR WITHOUT SATELLITE IMAGE PRETRAINING\n", + "### Need to keep this in mind\n", + "\n", + "\n", + "optimizer = torch.optim.Adam(encoder.parameters(), lr=1e-4)\n", + "\n", + "def meta_train(num_epochs=5):\n", + " encoder.train()\n", + " for epoch in range(1, num_epochs + 1):\n", + " total_loss = 0.0\n", + "\n", + " for (img_s, mask_s, img_q, mask_q) in episode_loader:\n", + " img_s = img_s.to(device)\n", + " mask_s = mask_s.to(device)\n", + " img_q = img_q.to(device)\n", + " mask_q = mask_q.to(device)\n", + "\n", + " optimizer.zero_grad()\n", + "\n", + " # 1) Encode support & query\n", + " feat_s = encoder(img_s) # [1,C,H',W']\n", + " feat_q = encoder(img_q) # [1,C,H',W']\n", + "\n", + " # 2) Prototypes from support\n", + " prototypes = compute_prototypes(feat_s, mask_s) # [2,C]\n", + "\n", + " # 3) Classify query pixels\n", + " logits_q_small = classify_query(feat_q, prototypes) # [1,2,H',W']\n", + "\n", + " # 4) Upsample logits to original mask size\n", + " logits_q = F.interpolate(\n", + " logits_q_small, size=mask_q.shape[2:], mode=\"bilinear\", align_corners=False\n", + " ) # [1,2,H,W]\n", + "\n", + " # 5) Cross-entropy loss; target: 0/1\n", + " target_q = mask_q.long().squeeze(1) # [1,H,W] with values {0,1}\n", + " loss = F.cross_entropy(logits_q, target_q)\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " total_loss += loss.item()\n", + "\n", + " avg_loss = total_loss / len(episode_loader)\n", + " print(f\"Epoch {epoch}/{num_epochs} | avg episode loss: {avg_loss:.4f}\")\n", + "\n", + "# Run meta-training\n", + "meta_train(num_epochs=5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Interpretation of the average episode loss** \n", + "The β€œavg episode loss” at each epoch is the average cross-entropy error over all support–query tasks in that epoch; the fact that it steadily goes from ~0.24 to ~0.09 means that the encoder is successfully learning a feature space where prototype-based segmentation works increasingly well.\n", + "\n", + "**Recap episodes.** \n", + "For one episode, we:\n", + "\n", + "- Take (support_image, support_mask, query_image, query_mask).\n", + "- Encode support → compute prototypes (foreground/background).\n", + "- Encode query → classify each pixel using the prototypes.\n", + "- Compare predicted class vs true class at each pixel of the query.\n", + "- Compute a cross-entropy loss over all those pixels." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Few-shot inference: 1-shot and K-shot helpers\n", + "\n", + "After meta-training, comes meta-learning. We want to use the encoder for **few-shot segmentation** on new data.\n", + "\n", + "We define a function for that: \n", + "- `k_shot_predict` takes:\n", + " - `K` support images and masks, and\n", + " - a query image,\n", + " and returns the full-resolution logits `[1, 2, H, W]` for the query.\n", + "- Internally, it encodes supports and query, computes prototypes using all K supports, classifies the query at the feature resolution, and upsamples the logits back to the original image size.\n", + "\n", + "For convenience, `one_shot_predict` wraps this function for the special case `K = 1`. These utilities are used both for quantitative evaluation and for visualising qualitative results." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "# ============================================================\n", + "# 9. Few-shot inference on test images\n", + "# ============================================================\n", + "\n", + "def k_shot_predict(encoder, support_imgs, support_masks, query_img):\n", + " \"\"\"\n", + " K-shot segmentation for a query image given K support images+masks.\n", + "\n", + " support_imgs: [K, 3, H, W]\n", + " support_masks: [K, 1, H, W]\n", + " query_img: [3, H, W]\n", + " Returns: logits [1, 2, H, W]\n", + " \"\"\"\n", + " encoder.eval()\n", + " with torch.no_grad():\n", + " support_imgs = support_imgs.to(device) # [K,3,H,W]\n", + " support_masks = support_masks.to(device) # [K,1,H,W]\n", + " query_img = query_img.to(device).unsqueeze(0) # [1,3,H,W]\n", + "\n", + " # Pass through encoder\n", + " feat_s = encoder(support_imgs) # [K,C,H',W']\n", + " feat_q = encoder(query_img) # [1,C,H',W']\n", + "\n", + " # Compute prototypes\n", + " prototypes = compute_prototypes(feat_s, support_masks) # [2,C]\n", + "\n", + " # Classify query pixels\n", + " logits_small = classify_query(feat_q, prototypes) # [1,2,H',W']\n", + " logits = F.interpolate(\n", + " logits_small,\n", + " size=(query_img.shape[2], query_img.shape[3]),\n", + " mode=\"bilinear\",\n", + " align_corners=False,\n", + " ) # [1,2,H,W]\n", + "\n", + " return logits.cpu()\n", + "\n", + "def one_shot_predict(encoder, support_img, support_mask, query_img):\n", + " \"\"\"\n", + " 1-shot helper that wraps single support into K=1 form.\n", + " \"\"\"\n", + " support_imgs = support_img.unsqueeze(0) # [1,3,H,W]\n", + " support_masks = support_mask.unsqueeze(0) # [1,1,H,W]\n", + " return k_shot_predict(encoder, support_imgs, support_masks, query_img)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 9. Results and discussion\n", + "\n", + "## 9.1. Quantitative evaluation: K-shot IoU\n", + "\n", + "To assess the model, we evaluate **K-shot IoU** on the test split:\n", + "\n", + "- For each test image (query), we randomly sample `K` distinct support images from the training split.\n", + "- We run `k_shot_predict` to obtain predicted logits and compute IoU with respect to the true rooftop mask.\n", + "- We repeat this process for multiple random test queries and report the **mean and standard deviation of IoU**.\n", + "\n", + "By varying `K` we can study how performance improves as we provide more labelled examples to the model.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "# ============================================================\n", + "# 9a. K-shot inference on test images\n", + "# ============================================================\n", + "\n", + "import numpy as np\n", + "import torch\n", + "\n", + "def evaluate_kshot_iou(encoder, train_dataset, test_dataset, K=5, num_samples=None):\n", + " \"\"\"\n", + " Evaluate K-shot IoU on 'num_samples' random test images.\n", + " For each test image, randomly sample K *distinct* support images from the train set.\n", + " \"\"\"\n", + " encoder.eval()\n", + " rng = np.random.default_rng(42)\n", + "\n", + " # If num_samples is None, evaluate on all test samples\n", + " if num_samples is None:\n", + " num_samples = len(test_dataset)\n", + "\n", + " ious = []\n", + " for _ in range(num_samples):\n", + " # pick random test index\n", + " ti = rng.integers(0, len(test_dataset))\n", + " img_q, mask_q = test_dataset[ti]\n", + "\n", + " # pick K distinct support indices\n", + " support_indices = rng.choice(len(train_dataset), size=K, replace=False)\n", + " support_imgs = []\n", + " support_masks = []\n", + " for si in support_indices:\n", + " img_s, mask_s = train_dataset[si]\n", + " support_imgs.append(img_s)\n", + " support_masks.append(mask_s)\n", + " support_imgs = torch.stack(support_imgs, dim=0) # [K,3,H,W]\n", + " support_masks = torch.stack(support_masks, dim=0) # [K,1,H,W]\n", + "\n", + " # run K-shot prediction\n", + " logits = k_shot_predict(encoder, support_imgs, support_masks, img_q) # [1,2,H,W]\n", + "\n", + " iou = iou_from_logits(logits, mask_q.unsqueeze(0))\n", + " ious.append(iou)\n", + "\n", + " ious = np.array(ious)\n", + " print(f\"{K}-shot mean IoU over {num_samples} test samples: {ious.mean():.3f} Β± {ious.std():.3f}\")\n", + " return ious" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9.2. Visualising a 1-shot episode\n", + "\n", + "1. Randomly sample a support image and mask from the training set.\n", + "2. Randomly sample a query image and mask from the test set.\n", + "3. Run `one_shot_predict` to obtain the predicted query mask.\n", + "4. Plot:\n", + " - the support image and its mask,\n", + " - the query image and its ground-truth mask,\n", + " - and the predicted mask.\n", + "\n", + "This helps build intuition about where the model succeeds or failsβ€”for example, whether it captures rooftop shapes well and where it confuses rooftops with other bright surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBMAAAJOCAYAAADlBk9OAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/Qe4bfld14+/Vq+773367W16ZjLJpCckIQUCCWAIBpUiCj4UFR9F0b8iAhZQ/IkFRBF+gFFBQEANkISEJDOZZEqm3Zm5c/s999Tdy+rt/3zX/G6eO5MJaQMhk/XKczLnrrP2Pmuvs/e3fMr7LRVFUVBRUVFRUVFRUVFRUVFRUVHxOSJ/ridWVFRUVFRUVFRUVFRUVFRUVMGEioqKioqKioqKioqKioqKz5uqMqGioqKioqKioqKioqKiouLzogomVFRUVFRUVFRUVFRUVFRUfF5UwYSKioqKioqKioqKioqKiorPiyqYUFFRUVFRUVFRUVFRUVFR8XlRBRMqKioqKioqKioqKioqKio+L6pgQkVFRUVFRUVFRUVFRUVFxedFFUyoqKioqKioqKioqKioqKj4vKiCCRXPK9/xHd/B4cOHq7taUVFRUfFnam5yXfdLfRkVFRUVX9ZU6/yKZ1MFE75AHn30Ud75zndy6NAhTNNkfX2dN73pTfzbf/tveSFxzz338I//8T9mMpl8qS+loqKi4s8k1XxQUVFRUXE9p0+f5i/+xb9Y7g8Mw2Btba389+OPP17dqIoXFFJRFMWX+iK+HDfYr3/96zl48CDf/u3fzsrKCpubm9x7772cP3+ec+fO8ULhX/7Lf8nf+Tt/h4sXL35OFQdJkpDneTlwVlRUVLzQqeaDL59s2v/8n/+TxWLxpb6UioqKFzi/+Zu/ybvf/W7a7Tbf9V3fxZEjR7h06RK/8Au/wGg04n/8j//BO97xDr4cqdb5Fc9G/bQjFZ+Vn/iJn6DRaHDffffRbDaf8bP9/f0XxB30PA/HcT7vx2ma9idyPRUVFRV/Fqnmg4qKioqKa4ik4l/6S3+Jo0eP8uEPf5her/epn/2Nv/E3eM1rXlNWKDzyyCNlkOFPE9/3sW37i3qOap1f8WyqNocvcKC4+eabPy2QIFhaWvrU9yIKKUkSv/RLv/Rp54njon3gGuJ7cezJJ5/kXe96F/V6nU6nUw48YRh+2mO///u/n//6X/8rp06dKtss7rzzznLQejaf/OQn+Zqv+Zry+US/6Bvf+MayguJ6xPWJ5/yjP/ojvvd7v7d8DRsbG+U1iaoEgRjwxDniS7yuz7WX6to9EBUO//7f//tycBUD2Zvf/OaymkMUxvzYj/1Y+fssyyojtSJqez2//du/zdve9rayRExUPBw7dqx8TJZln/b7r/0O8Vx33XUXH/nIR/iqr/qq8ut6oijiR37kRzh+/Hj5nAcOHOCHfuiHyuMVFRUVnyvVfPCZ5wMx7t5yyy3lovl1r3tdOfaLMVdUCAjEnPOyl72sHK/FXPb+97//GY+/fPlyOSeJn4lzxJz4zd/8zZ82B4lM2Y/+6I9y4sSJcj4U57361a/mfe973x/7t3vooYfKhb64zqpioaKi4vngp37qp8pN+8///M8/I5Ag6Ha7/Mf/+B/L8Uac99l0CK7tDZ7Nr/7qr5brfjEuiuqHP//n/3y5pn6u8feBBx7gta99bTn+/v2///fLimpxHWLcfDZibS7G2z+Oap1f8WyqyoQvAKGT8LGPfYzHHnus/KA+n4hAghhQ/tk/+2flpv9nfuZnGI/H/PIv//IzzhOLMFEm9df/+l8vN8P/4T/8B9761rfyiU984lPXJPq1RARUBBLERllEE8UgJgaYa4u46xGLNjHw/aN/9I/KygQRhHjqqaf4b//tv/Gv//W/LgcfwbMHx88FEfiI45gf+IEfKIMFP/mTP1m+1je84Q186EMf4u/+3b9btocIzYm//bf/Nv/lv/yXZwQ7RCDkb/2tv1X+9w//8A/La5zNZs8YjH/2Z3+2DLKI1/yDP/iD5YLzG77hG2i1WmWw4hqiDePtb387H/3oR/nu7/5ubrzxxrLnWbxG8Xr/1//6X5/366uoqPjKpJoP/vj5QMxfX/d1X1cudkUgQIzT4nsxJ/zNv/k3+Wt/7a/xrd/6reVYLnSIxIK4VquVjxXVf6KNRJwvxnAxpovHizlM9B1fy7CJBbeYM//KX/krZRBZzA33338/Dz74YKll9FyI537LW97CS17ykjJgLRblFRUVFV8sv/u7v1uu48Va9LkQG3vxc3GeWLt/IdVw//Af/sNyDS3GvH6/X66dxfOKBOL1ic7hcFiu5cUYKqohlpeXy6pjsaf4/d///XJsvsbu7m65vhaJti+Eap3/FYzQTKj4/PiDP/iDQlGU8usVr3hF8UM/9EPF7//+7xdxHD/jvIsXLwo9iuIXf/EXP+05xPEf+ZEf+dS/xffi2Nvf/vZnnPe93/u95fGHH374GY8VX/fff/+njl2+fLkwTbP4xm/8xk8d+4Zv+IZC1/Xi/Pnznzq2vb1d1Gq14rWvfe2njonrE8/36le/ukjT9Bm//6d+6qfKn4nX8rnw7d/+7cWhQ4c+7R70er1iMpl86vgP//APl8df9KIXFUmSfOr4u9/97vKawzD81DHf9z/t93zP93xPYdv2p86LoqjodDrFS1/60mc83y/90i+Vv+d1r3vdp479yq/8SiHLcvGRj3zkGc/5cz/3c+W5d9999+f0WisqKiqq+eAzI8ZdMaa+5z3v+dSxJ598sjwmxuB77733U8fFHPrs+fK5xv6Pfexj5Xm//Mu//KljYh5529ve9lnnJsdxyu8/+tGPFvV6vXzM9XNNRUVFxReDWOeK8ekd73jHH3ueWOuL82az2XOunZ+9N7jGpUuXyr3HT/zETzzjvEcffbRQVfUZx6+Nv2Jtez1ZlhUbGxvFt3zLtzzj+E//9E8XkiQVFy5c+GOvvVrnVzybqs3hC0BkOkRlgshuP/zww2WWXWQ4hGLr7/zO73xRwZ3v+77ve8a/RSZf8H//7/99xvFXvOIVZYnTNYQYpGgREJFGUf4vvv7gD/6gzMyLsv9rrK6ullkgkZUX2Zvr+at/9a+iKAp/EoiMlNCZuMa1qggRKVVV9RnHRQXD1tbWp45dnzGaz+cMBoMy4ivKyERbiEBkoUQEVryG65/vL/yFv1BWJlzPr//6r5fVCDfccEP5XNe+RJWE4IMf/OCfyD2oqKh44VHNB388oppMZMWuIUpoReZMjMHXV8dd+/7ChQvPOfaLklwxxos2CfF4UXVwDfFvUYl39uzZz/r3EuO7mK9Fy58QSavEgisqKp4vxBpVcK266jNx7efXzv9cEWOWqK4VVQnXr1+FELxo83r2+lWMb9/5nd/5jGOyLJdrY7Ffuf73i8qCV77ylV+wjkO1zv/KpQomfIG89KUvLT/UooRTtBb88A//cPmhFGWaX4ztixgMrkfoA4gP/rN7RJ99nuDkyZPlBluUPIkv8f1z9T6JRZwYjJ7dX/UnKQQjgh3Xcy2wILQKnuu4uK/XEIvEb/zGbyx/Jlo2RJuFCEIIptPpp3prBWKheT0isPDsPjSx4BTPKZ7n+i9x/15IIpoVFRV/OlTzwWdGtCc8u+dXjOWfy9gfBEHZ0ibOFYti0WonxmphVXxt7Bf8k3/yT8pjYgy/9dZbS60fodPwbIT+kNDfueOOO/i1X/s1dF3/Iv7qFRUVFV9YkED8XIyL19qHP1fE+lUUKIs9wLPXsE888cSnrV9FkvO5xrlv+7ZvK8fX3/qt3yr/febMmVJbQQhHfqFU6/yvXCrNhC8S8SEVC0nxJRYyIgIoMt+i5+i5RFMEzyUc+Jn4TM/xJ8GfZM/oZ6p4+EzHrzmWigWiEO4SQQSxYBTBFSGwJbJSQmdBBEU+X8RjxILzp3/6p5/z589e5FZUVFR8LlTzwfM39l+rzPvFX/zFUltBVOOJgIOYE0Wlw/Vjv+gVFkKYQvtAVOT95//8n0sNnJ/7uZ8re4qvIQISX/u1X1ue93u/93vP6BeuqKio+GIRY5QQC3+uYOb1iJ+LQOu1jf7nul8Q4544973vfe9zjqGiEuxzWdffdNNNZXWzEHIUgQXxX3EtouLhC6Va53/lUgUTnkeEkJNgZ2en/O+18nqxIb6ea1n0zxR1vL5CQIgSisHjubLrz0aIBwpBqmsCieJ7EW18NqI1QFQ7fC6b5j/NYMZzIcQZRWmrqAIRC8ZrXLx48dNE0K7dr9e//vWfOp6maVnVcdttt33qmAhIiPYUUeb6pX59FRUVL0yq+eCLR7g+COXxf/Wv/tUzqguePacKhKK5COaLL6GULuYLIcx4fTBBjPeilFe0BIqSXLEgf7bTT0VFRcUXw9d//deXYueinVi4yjwb4TIm1qVCVPwaYr/wXOPas/cLYv0qAq5in3CtmvYLRQQRxDWIPct73vOesmrr2W3BfxpU6/wvf6o2hy8A0ZN0ffbkGtd0Da61FohsuihherZl4x+n3iqsDa9HKLQKhBrr9QjNhut7RkXLgsi2CFsXER0UX+J7cez6Fom9vb1y0BADnLi+z4ZQfRU81yD3p8G1SOf191toKjz7HoqFu7AD+0//6T+VAYRriIXj9WWzAhF5FZoM4txnI8q+hJNFRUVFxedCNR/8yY7/z55rxZz47GydCDg/OzsnWt6ey+pXZN9EcFpUE4pFv2hTrKioqHi+EI5kIpn3Pd/zPZ82Ngk3M+FgI9bfwn3s+iCBaN26vqJBbPKvtSFc45u+6ZvKcVFY4T57bBT/fvbv++N497vfXQZYhQW90Kq51j78p021zv/yp6pM+AIQpZdCj0D08QsRP7G5FfZVwqpRVBBcL3YisiL//J//8/K/YsMrAguiguAzITLuQthR2DyKgIEoPRKCiS960YuecZ6wfxQiUtdbQwrEAHONH//xHy99tkXgQNg+Cv0AES0VCywhGvm5cE3k8R/8g39QlpYKe0mxALsWZPiTRojBiEipyE6J1yoGvl/5lV/5tEFULBBFFkr8bYSQoggYiCCKsJUUg/T1FQiiJ0z0y4oBXWwEXvWqV5WLU1GxIY4LEctrWcWKioqKP45qPviTmw9EG4IY70XpsCjLFXPi+9///jJwfD3iZ6LCQMxXokJBCPKKqobrF+vPLv393//7f5dzhQjUC6vk59vmuaKi4isTEcgU1otisy5aar/ru76rrCQQa9Jf+IVfKBNc//2///dnVCGL9bVo3RX7CrHWFXsMYYMrqg+uTxyK9axY2wudtmv250KnQewdROBB2J2LYMbngqhiFnsN0ZotRGxFZcKXgmqd/wLg0/wdKj4r733ve4u//Jf/cnHDDTcUruuWVobHjx8vfuAHfqDY29t7xrnC2uq7vuu7ikajUVoyvutd7yr29/c/ozXk448/Xrzzne8sz221WsX3f//3F0EQPOM5xXnf933fV/zqr/5qceLEicIwjOKOO+4oPvjBD37atT744IPFW97ylvI6hZXi61//+uKee+55xjnXrCHvu+++53y9P/ZjP1asr6+XVl6fzSbyM1nGCIvJ6xHXKo7/+q//+me9FmHV+PKXv7ywLKtYW1v7lBWnOO/Zr/lnfuZnyt8v7sldd91VPvbOO+8s3vrWtz7jPGHj+S/+xb8obr755vJcca/FeT/6oz9aTKfTz/j6KioqKq6nmg8+83wgrMnEGPtsxBj9XFaO1+a2a4zH4+I7v/M7i263W85hYi4T1pLi8WKuucaP//iPl+N9s9ks5wkxNwuLtOvtmq+3hrzGYDAobrrppmJlZaU4e/Zs9cauqKh43hB2jd/6rd9aji/X1s/Cwv306dOf0Wb4lltuKfcUp06dKtf4z7aGvMZv/MZvlHbuYkwTX2LME2PnmTNnPuv4ez2/9mu/Vj7/d3/3d3/Or6ta51c8G0n835c6oFFBmVUXVQXCheGzqbuKLLuwkPx3/+7fVbfusyD0JkT0VZSGPVdbQ0VFRcWfNar5oKKiouKFhahW+I7v+I6ynUB8/2cB0QotqhtE1bSwXP9ypFrnf+mp2hwqXjAIYS7R8nF9S4MYsEWPWiWyVVFRUVFRUVFR8aVACB4KHYS/9/f+Xunk8E//6T/9kv8hRJLt6NGjzykU+WeRap3/Z5MqmFDxguHee+/lB3/wB0uVbtFTK/rMRH+a6IUVxyoqKioqKioqKiq+FAhdBPH1pUZoNgixx//zf/4P/+bf/JsvG2ezap3/Z5MqmFDxgkGIXwq7y5/5mZ8pqxGEEJeIBAsBzGtevhUVFRUVFRUVFRVfqQhxSOF6I8QhhUD7lwvVOv/PJpVmQkVFRUVFRUVFRUVFRUVFxeeF/PmdXlFRUVFRUVFRUVFRUVFR8ZVOFUyoqKioqKioqKioqKioqKj4vKiCCRUVFRUVFRUVFRUVFRUVFX8yAozm0TuxHYUi0ymSFEXZRdczZL0OtXVkf0EY+Bw7fJJv+eZX89a7XoetZgwXPpKukxgGrlTw+NYT/PcP38d0a4hbL8i6CVZdQ0oD9HBEkK6zP1WYnX2K/k5IPJYw3VVUY4RLncCOsGSLPDVJlSHFNGQRjpAlA1nTKEyDYh5DobKYzOni4rdXUJQUJd1GSw+iLNVhegnvjE/YrHP4VXfyrW+7i5feforldhtD1tE0DUkpeOjME/zHn3+As5fHvONbD/G2r76TVWulvN77rzzM7/3Oxzn3vh0UKcNuSrSWFHQ5we3okJpYdRtD05jHETU3Jw5k9kKHg05Gt1ZnGkfs+Qs0S6KZalydLnDlDD/TqMkRSRExzBM2Gi3yTCcMCxIGaI0lWnINBrtcHS8YxiGZnVCTTaw0JZRk5NxAU2d4YcH+IGUoTTCbXQ4suayttLAkDynT2RT3y4hZqbXYTBZcHSpEwZh09yrBdpdaoDF2R4TzGq67S1rYDK+MkKI17PacuaqRj1VUFxDXEVpQ7KNnDrohk6YzJM1EcQ3SIkNNApRYJytMcjMlx8eSZTSlThAHoEm0Wyq339xgpXOYoZQzvTTm4dOPMPE19DAmCZdo3iXTWTPBs8gVnzguCIcb5I+dRrtzjY5dw5KmrB87QOvkCC2xyUcaXhwRyTM2Gic51dmgW+9QaDLzoce5vcvs7M6RlAjJAjOT0FEZpTJ+7iGHEzYvTjk3Sjl+dIU3HFxnJ0qY+TPuWO+SSRqRnrMdh5j7MySnjuF4zIcw3Z0S2QqJBspAY/lEQuqvkCR72LqBZTcYeylTT6HZUIhaHugKtV2bPW+P2AvIVA1TV9B1G7sJgbcgnBtouoSqReRYFH5I4k3JZJdeo45rFnjRFLSUyFwilB3q2QxDC5gnCZbao2h4DLcDdnausMhWuLllkq5oHHdjWuEBvv/v/PjnN7JUvKD4clF6rqioeP4piqK6rV/h3P4PvpUXrbr0QptitGBRt0nygL2JSuOYwlQr0LdSjlkK80ihL9ZjxTaLwTqJPsOKMpquyXghEV4N6L1IxbjBxfR76EaAP7/MzlNt7AMxX3dnjf5jdX7jo/dijFocrxXUX2HQDVcYnN5hX805ftKm02gR7dpM9IBeN8DLZTquw8Kb0KitsEgWqEnO1WDOUeVm/OwiyDmtRpNR7BH6Bb1GA8es0R9tMR1I2E0Fq6agyRqQ4JpNLKNJwJyHH/a4+3TIxpuW+O5vuZ2vsnTmc3jk8W0ubT+BaeuYWRdJUYnkCD1VCLMI8fFxTYdRuombLWObLmJK9cI5imPgSHa5f0KSWfhTkjzGNhw0xcAwTDaz09hJk5rSRdFkPiSf5YO/dJYLd/dpbgRYzjLFpEP7iMub33mMV9x+EBmNPJgz2LzERz5+iSfPXGW5GVKsHSHPJTRDZmBd5FB4hO1gwPrVFveM1rHWVvnIj7+RWV3kmiMkv8DfnvDAmdP84gOPcvEJnxMbffRWnUkypWi0OeApfPi3z9Nafzlv/YEbeMWxBY/cfYH/8tM7BOOQ3ivHpJ0jLM4tWFk2WdtooQQJhZEx2Zkyv5DCUo5qKSzpDY6/zOWVxzdwjGOQF4zDHYbOeZrjo1y6cJZxPuGPjlzhSHaCxoMznFhlYA6oW7dyyXyUE9ktDHt9NgYZlxc1gsKjgUTfDTliNHnl+u08ePYJsmhOXCjsxzOaesHAMojJSTt7pFe6aFehUQw50Oph9hychoGt1Jjuh9Q1m+7RA5iqIQZIJFmhUAsUW8VOLSbeiDiKURQV09aYWFtogwZ+uKBht1n4c3737rOccDUWbs7mxkMoT72MC6rExsWHuLOl4S9tcP6wzKKTcnBX5/J9fc5uXSGOG2RRgH8upni5y8oBG9PUmUU5KxdNbl+xMZYVFqHFzB5BPKc+6XFOvsTgXIGkdDmyYnGheZEDkc5SXeH+HZXxlRhP0ckff4S6for6m9p4+2exgjGb77/4/AQTGlGXGTsYophBiYlkHVVfRjU9KGRy38fIA3bOhvzXD/02e8VZTnU6rNdu4cjKjdQdl3kScqlvMRw1SNUIij6y54FllpsgpHXSHDQ9xdqwaOc6fT9DiTxSSWUUbFIMC/KDK5AEmI5JvK2RhhGq1UB3V5C9EI89ZLOJY7QIsj5GFBHGCXmrRpYl2NM5WdRE7gRY0Yyd91/mJ++7TPOUzZ//9jfzrle/lg21RhwHPP5kxOnzEXcdb/O2G4+zLDeQM6hbDeis8IitkI1zJk5BZ2eENNPRWg1SO8Io2hBCik/bsVFsidAocAZDgthkkgSETp1WYqIHPnvZlJZRRylUrGZB7EvMvBgNFQOTMPfx85wsq6Mt/DIAoDoGdblNTRsSqWOCkYmWSWimhJcETIOELK+jKC56ZJDv+CTk9AODRJEI1V3slTo1dQnNyTAHLmsHE1pEbEbH8fWQugTt4CDDk7u4HMSY9WGywTzax1zqkCsaFAGpvI08c5DrOaGakhcZUpyhLeoEfkQW5uS5R2aqoEqk6RQpsdFkizgqSOQQjDlFkhPutVn06qSdEMOSEDc991rI0wGpuU56VEfP5khywSiTkWWJxiJj5l1gqi1oTmeMaim3HpTptPt40SpMJZJiTuR5FJZBR6vhajVyMyaTc/xkThDlaJqOYxioakaa5VyZ5+wO92goObq5BLpE1w041GxitRQGkwlaPmOQukhWRINlVjWDcEVDNxWKmcko9VDWMtpaQR4mTHqgRSYYU0bzkGlQoCohWDKpFuMbDutJHSVRkGoz/Mzn0S0TWYIX39LFqKkUXgx5hmKqyJpMmvmk6ZwgtYiLZUgytqcz7ELBIEOXdZaTnFT28PWIptpCU2BXDZBC8bszpDUHf2vIrOgyH/nMtk3WutPnYy1SUVFRUVFR8WXIu29ssr0n4ysqW6bJpeAyt6hHsU5skewcptteEHW7DLd2uDDNmMQ5o/GCTnqOTGtwdZph3FywvCGxYjc4bi+xEWn0xZokNEmWjqITED8o8x8vJNzQ9XnH617J7z014PzOk7yGUzw+TAnMJidXNJZXTCIiFvULMG0xeSKlcYuOFwSYqkngjcp114rVoWvAMD0D/QnaUpvdvYBGx0Z3A/RZSJIrELpYzoxAW6AVdUzZoJAsFM1CmaQ89OSMJ32Nv/jOG/hzb+hQs3QeHhXcf3aXznBI01pCLmIUw0JTVCwMQnwczWEY72LFJk1lnUzKCJMAVVaRuhO0ySqxnDANJ7hmA9t2mEUZqqozT6ekQUxMgJKb6HmIjs6J9pTGV9v8dtrj9D27uJpE4zaH429oc/iGiH4xYHI5o7hykT1vSj9boC/XmcUuqvcIsdajHdU45TXZlyYUi4CtpZyTucIjn5wyefIG2ne5XPZHDM6k/P9+8g85F/4e71g5QfCqDGke44cxqmqRDDWmRsDhVxtcevBhdi7B3voRXnbna/ngX7mfT/7OA8yutrmlFrF6vMlTo5jLg4iVlkHP0FC6XWLFQ1b7aJMQfzHj4/cs2Lw45i13DVg/5LPirKLObsGv73PyQMSZp+BrNw9hKybTWsFmMiNzmvSUiMHEoLDGKBdMzm2oXNW3OTZ2yYqINb+GmmfcEz3MVp4R1LdYiddpZxZLjYxOYdCfFPTP34JtTXGbIbLaJmwUSAMZNmXGnSEL2US3O8giIiQVJFmEqbjIpsY0nZIsFiQp2KZNTkCkXEbaWyoDDk23wTz1eaD+FEurbYL7ttk5sooutZkOLzAQEYxWE2N6gOSkTq3t4+Nx1e4yqZvUOwc4FuZc3FPY1iTMOKbQMlLm1AYO7VqIZeZYWYfM2iOLdZzpClI4wQiOEC7H1G5fEC9ybtk8QOz6dPIO9cOb5POImmYT3PrtOC97GCfSmZ4pGAzWPuv48DkHE5xmjlyTSXyIJg5qrpNZY5i1iJwpds0lTXKyqcd8K2H46JiHucDD2UOs33QbN9z+CqQ8Z6v/GEvKLrIUMnMllGYTOzeJFhHzIsCQQhp6gdkyWFzNUPUcXfcwahrjokE+SZAicdl9lMwiKOqkTg0jUZGiLXJ9CStqkesT5NoxZtNNitxHqi+Q/SW8dICqGPga2F0X1VcolJB8P2H6gU3+9c4lfuHb7uGWV9/OrWcsHv+th0hmc8wDL2PWcOkgQR7z29NNfvaxhxl+YoQeBrRbCnpisbkn4VyISC7HmBs+g56HrdnoqyZ6rY0bTiGTQQQhCrBGEZKkotbAjVrUtBnJpECWbFRTY2YaOIuMIlwgWTZ6EZAFMcLpMG8ZBKHMLJpg5jmNzEE2YRbJ5FmErCfEU5N5HmI4C5ZslzyyKYqIKNgDO2GaNchyDVvZZpb00FSF7Op5NrM6s4lEftxBtxdomwk0V1AmEQFgtxXCqYLULmiHLtrtDcJYQ41U9Egi1lplFYKWFMRRQLpv4I01FL2LpKaksYSsaGj+FDlXSR2XTIpQixpynDIzRvSjJdaUOlY6R0lDQskkkjPMusfBhsbBky1mucnRlYDxBOaFRDycs7S6gt1w0LVDtNycTi2htxgxDFostFgEOulqTVp6E72uIWOSzhfMBmOSOEYpUtIQcq1gNk8ZXNni4pU9dLXJiSMaXTdFy3MGs30efGKbfF6nYW1QqDlqoTFOBqjk6JZEPkzYUaa0RJAsSlEMA0UyWegzRnrGetMgSJtluCgd57QP2NSWLC7upkzVmFxSsRKTRu6w5sqoWobcVih0UcGQEakFphVjZzJJmjJPDHTbZd32GM+njBG/18XV29Qsl169RZCkjJ0JqRTjLnqYuqgM6WFlMZau4M73KJoFylWXgZMQjK5+seuQioqKioqKii9T5PQA92Rb1M7WmbQT6meXePI1U96YrBNEC/q6xoEowWj2oOczfHKLSW5CuMIRW0c6BpbeBfU8WDtcmuVsdlXajoqimsi6QvrEgjOPDlkYcOXQQb7jDYe5daPJT/y6zNmnXDbiEK0WIWsphVZnkvustg4R+FM+Huq81m0SSKBGOXkYsGF3GPoLNuYb7Ne2mesa02CZRntEridEWYHRNDFklXZPxTZXSDIPRdExTZd4MMZ/fMhHz4d8THZ55zce4jtfv4KHzuMX9tm/4tGMFmUlc5In1PQucZ4Q+D6W8XS1dGCGrPhHyux1IRdlNYKpacy0Gb34MIEc4i0GSDrsTi6z3jpUrkNDQupGk7zIWfJPEBU+siGhoNIanqLWzPiqUx6LyyZuM+XkiTo3FC3qExvNsNjfD7n/wRl2cB77pMMV26M+r5GmL0YqtsugydWiTpw7SCsBjcBmYQRo3Sn3fOi/cVLVeM+HQz748Smj8CovPWWXWeulWcCkf4CJ/AnW1EOEzoRF0aW9vMJiLWf4sYskZhv5jjHf/rJVtPFtOB9/lHfcsszqHTG/+QGDD55NCbxtRuYKLCesrYUMd9vM4hGFoyL5NR55PODh8yNOnLJ46y0+K0sDalqPc1LEe3fPc2hnD16yoFfUWTKaKBMR1JiwaNXZOhdw4kCLy8kWr0567AcpxaDFxbdsc9duh7OTAD1RcJx1dhlxqrVMt75G4OvMi21q2mNovYCp3qSbt4l2da7sj+ktJ7SzOut2j401G11UrxSg62YpGpDFMXZiIEkFqpQQxBGuWcORbkEzY9IsKQNgeqaxtGUzmi7x4e6T7B6/wqse36C2bnCndBDv6mnynlRWRyeqyU3bOqOOQvPlDeLLK1y9sMd0DIe6DkquII98inpAREy3Xae10SIc5JhzG9kGoxmTGRqyH9FJdE496tA7JmEuZyiayaVhH39PY6Ec4ERtn3Phb2KcvgnZmlJvmlg3HH/+ggn1Iw2c4iR+80lMXWMkxYzmQ1JlgjxqkSxNKQIH2c1InAaeZNCSNghnKftPXODK9DJPDafsX53gquvYeg0pmZLOpgxzkVk2MHQNH4XRJGc8L5huB6gDCfOQwYtuM8haN/DIo+fxdwOyeZeJNkOxh3S1GmqtR8wANd8jy5oUWU6mTrD1Dqpjs1jMyZWCIvSJpRgl7yCrS0TqLlIIRQ1svYezB+OfvsjH/vmQM4GKome89M2HeMPLezStGnEGI2/G6ScfZee/fxzz/jlKU8J68Sle9rZTKNE2D//ho9z9uwZ3PJZiHXGwuxMWponlzVHdEL1ZR49kiizG0AumhQp+SL3VQCt01I6EXkjMYw9brdNuzxn4CU6a4dSaZIQYEui+ThIFhJFPmqvITY25A34coKUJLalGtwH9AC4GI/JsRH29jiVLLOhhGCpHM5nhUzv0zYxjjobe1RlfqTNWVOpynyB1kJtLrMceo8Igqc0Y77m0tJjEUomZkzaX0UhwVBPEht8q0PIQR7Optx3a8oIozemPIqZBTpioRP0hgecRLwKSoIYUy6RJQiaryImGiQuxjJzGaHJOmM6I0xGKuYKm5azLObakMJdWcFb22QtjhpsJhdyh092ne9Nx3JpPJg94/8dz1nZkNg6C1Q7QVJe1Xh23ZSErokQpYe6NmcoJRZGAlEChYEoWVxOPJEpooDKYzdje1bjxaIOTy00uxjLnggHHpJDEgoXUp5avYqkKSZrjyQWFkqOGLnpLK1tziqUhy5MDFPKYS+Kebgd0ez3cqOCxeBd1lNPTWjT0Mbt9n0KKykyAKeJPNYfUTdAWOZYmqjkSxnOfWJTttbosNIvRcMGGYrHcrVEzNJwoIcQh1QvcIkd3QcpkVrMYdQFGmHAsbOJqLhMl5PQ8Y7lhkNsmURes3hbGPPti1yEVFRUVFRUVX6ac3tpkfuBJ9v/PAHMlY0NvIRcztmYtVup1DsYh+/M5604dP+6RdmWs/fPsOD7LqxrLRs7E3cVQLRzTIfA9iqlC3mkjaSFX0zlXDy2YbcWEn0jYyfr8/Mfv5rvessrLbrH56HuGjI+mvOEg7OgLgnmPkysnyjZUL69jfeAKmy/ps6KZ+GmBJssUOURJStgLKVo9VNljTZ5im83yOuRoTL+zoOsp1HSbTMrLZFNqDpEnKVceD7knDFi9rcP/89J1br9tmb7S5LHLT+FdeBg9XseQHXJpQVIbMtIiGtM2pmKiSFq5pm1KTRQ9J5DvZ3erSdtZQVUN3NBhc+Uiyn6BVKhIYUzT6hIFIZZoY40UdNfkcu0iLaWJGmrsOhdZ4gBWXEeyZO683SBpLEHucXQ5p1ELkGYWaUfh4DGRPLyZj50pcGb73Lbc4aKu0Bp6LLKC2YqEWQzQ9zxGpMTSLkp3DUu/wj+7T0L6gIXSTaj1TDaUV7JsPsZeltHMayR1n2jrJL4d0XJENbXG1V5E7daI/UHCb3zgXjqDl/CW1+h849u6fMx4MRNll+PZWb56Y53haIkLfRkSGzlPqWk5vUZMkltMJwFJtM2Rtk4wV3nskTHpZMrRV2q8xm3gb+YMn4jJaic5FfUZZDlr+zWijSFeKNGcKlhNgw9tTLhzr8O4prOt5LgHznMTq2yLim8rYt1SWc9cGkqHhqmRiw33pE8iLbCMZYpFl8bSNg1tynbUZjbroNg2szCmE3g0lsds2AfJ86xszY61CCe1CUTCNytQFKX8O4o3VBBEolcUVVGRC5l+uE0YDqnF0Ap8jk422Bsu0OQF8Thn1vaQjBArnkBmMujoHJjU2DVm6LMdlnQVDtfRF3OWexIrXYPNfkHuWCzbNdLpgtjL8QsZSQ/RDIfFvKDv7XJ4Q+NI5yBa3yd2FFTfZppDkS1omQMGeyneVpdgFHLgJTGj/py8JnrYn6dggmIZmGkdtbaGUl9nefwEdn2FeFgr+4P8cQJhjOIWHFlbpVjP8dKCQMqIMwl3T2d1nrOzFXF+7xKm4RG7Mhk2NhJaM0TdUGh1TIokZnHWJxuE5LLMyGsgt2/kpU6fB2KYTmL0eEYwNWjXZVzHIVXOE6VNskWNwlaQRWY8nqDkTlkiohgOliz69rskQYSejFhoY1JFxch9ZKtOJCKakomDTB5cJdc88kYH1BPksYmUZMRpxEf2LvG+e8+jfWQKgwnZyUPc+g2v5a+/+Oayx2hw+1t539de5Gf/z2W6//Ms52c5B2ZbdCyVbncF47CE6oAq9AGiOpadoOtCq8FiMenjLdkkXo6ahXSNOoQmht1BKoY0ZLncxBe6TFp0yNIpWuQTpDKWKHlRFWLVQpUUAjUkUSPqeo2Vms60KMgKDS+3ieIMdTSj0CWaLRl54LCjJRTbPrZrc0tNZ8tw2ZuB05/xODJLWYQ0CbFrLZTRHNuooU4yzM4OhWqVAYX5TCaW5iRWA1lTyg/mKHeodWUOdj38wAQtJstyxpfXSDZTsmDBJIlYRBlhZFLEEKcuc78gDGdoqkGWOUjRNvq8iWlLSPMWA9/HPrKH07LQZiIQtUtnbQlnVcJuizL+kP3LEePzMvcnHsdjj1dKddasNm29gSZLyFlOWgSIeKFot8iUmDjLkSUdWc4xs4zAbLFy8iitJOVquKDQa/TWbWRvxpp3iJoZE+sj8niJNDfw7JxCC9CLDmHi4Yh7bBdMol1awyX0tkQryXEjlwtajhuEhHKBbMHuzGAxvYyTm1htnWigM4xnGEYGxQR/R8eU57TtmCQJyQuDKDGZBxJRZOBmGaacEdgF1DRqsUIzLiAqyOyc2XSGozbpuaKf8CrT+ZSZqbEa+0TmlLpmoskma02PxpLNfPdGrtQvfbHrkIqKioqKioovUxZXUm4JjrN3+y4nRzdx9qun3BUd5IKXsNsbk4+EntcJhqMh2fwsSaSzdpNKT86Qshm6ZXJYscvy/bBXUOxryPswS0KyJQVHdehdsdi90qDQt2nNMu7++C61boPvfe0y61bEL3w44dKexNIxm8G+hWPv4m7M0bOTLN2uouzMCVsZkzyna2hlK8HB8Cjb6jZNo8bB3hFGl/dJyCiaMe3mKm4S4xc+UR5hSkrZ1iAnCp+4b8HVgcxrv+EQb3r1ChuNNo+g89SFMd1zM5Sgi2S7FEWOnDnUwhpypCKL59AVMrHJzAtCfx9PfopHnlT5wAcDbjl1mW/++lvRc4f6bhPDNdmabFJXbBJSVFXDn89IZKgFMhvaQdI8JtMyVKlOFCUUyQIt00GOObXsYqtLpGRMRinTfJ9uFNJeWeboTSr72ioPPmFwPDzLhhaxbR1AF62t1GgsOmRqysrYRU8nDJ2ITqeO5a6gxi51e5tLtU1mfZt5MKLTXWZJbVLPF4SFyqhbEM0yaHhMm3DM0xnvt9hJM858+Dy9fMLLXneKN7yoy32PefzRhxrMZjFZ/wo9VyNq2aSBwu5Ux3FUWh0LM3FYWB7jqWgTnrMxy4m34exHYx5XH8ZkxAl7mZd9jUpjReITj7hIa30m7Qnd0Rr2jRbL5xO68xYvuXHM/3oqpzai1NNzc5ioMYd8CzXL2JQSdNsoE4/NfIWZPKffHtGuGehzn3mY0n8qItwr6B4pONidkssmWSAhTVLyVla2rWRySi5BFEeQSSiyjKRI5HJBLFpTZJ00TcnzHEXW8bclOq0VrjTOsRIsYeXLnDm8y+ARnRfVFxzIb2bbV8j7Oo0gY95TGA53uWz5nNtJ6dRC3OMqy57KUq4ylDwmSspaw0PWI5JQtJtnCNkLW7ZIs4KpbuMeX+egNaUhSWy3JLQkJa/p3KpqnGzbnInnLIZtLrojrCTl1HSZs+Mp7v4jz18wIU4LmHsUdkrC41i2Q1Grk7s2SbSJ4tWJJ3PytEmS5dR7GZbikhGhjH0MS6eldFClCG+wIMYkMTMUVUZr6eRSQZ5J+JMF+TSloalITZdQvNgc+hfmPKxeJd/2McMG2o5M6M6YzBRCdUyrsYTFAkm8Qc2INNCpJTp5c06KhLw3JraEEoCKqogWgzrpYgCpQSGbyMGCvIhIZCEaaKB0JWSpSe4bfPijj/Dh+BzH7zjGjWGL3QsX8M5fwQkCFo7B4VsO8203H8c1bJJCZ6Pt8O67OrzhxA088VWn+M8fP090+jRn9QlXNj1euvBR1m2y5iqJKBdLFTJULocRSp7TnkoIKT1Nc8veq8jMaEoygciiJzp6IQIJMVG4RW5MaRxMyUZt/Fjo9YWY5SCm4MVuKUhTU1OWdIuuWmcWDQhGAZFcFyETEr2Ok8k4LbFZh+EiwlwzMVoStmmwqq5wKH+SdBCWGgqen+EUPkp7AeOEzCsIjBpGFjKYa2TeBFXOcE21LPOZXknRXJdWLaHR1JFUcW0Sdr6B3kq4Gk/IAoO2ZNOiSxx5hHFKlDhIHZjlKm6k4SgZttRkboYUzpxw0WC21eTQURvTnnLb8Tbu62vsbed4To2uEkMko2cb/L3vfhPNQzr94YTN02dRUg1D6aDXLGQigv2U2TQpP+x1vU4hx+X3oS/aEhRuO+7SMY5xbtbEFxNfbY9QXlBXGtTNlMI0STUVS7JwVIksiUk8g9wIKOQQw3BJLJOOOSMq5uzFKXE8wG93WQ1MLkceK5nFjfoaQU+0+9iMBzvEnmh/SKlrIVoRIpl1gkXE1oWYeEUhEsExJaPQPSaFSV32sVsRKA6zeY7TEBN0nYXvUxQLtHlBItpYzAhVUylkg1xJSKKMeV0niSO84iqpf5BjpltW3CwfXKbtOV/sOqSioqKioqLiy5SsZxEkI+5cX+MCNZL+Fl7WwmgNmNeXOOT5pEsDFmcn7IURtu6i91xuNZboJBbzeM6eFZMtJfhuwGTusDTWsXoe6ZpOsggZ1yOcQzbSkkEx81mZLrH9pMz4DV2+5et6SErA+977KKdiBe32+1Hl2/B3XQiu0KpHJO0WLafFgctzztcTNHWI02sS+zGJPyfV28RWjOcFHGwcZpxdwirapKJVQaqhGTr+2OfjD4jXYPO2P7fE17xuhXqjxlPznKsPXcW6uk3QyJE1kyTyQQGtEEkYnSLPycmIC5GJLsrN5DwseP/9NqfvmdLOBpze7PF1gY8qtL4yBU/16dVWmHoDmnoPSYgj2gqbfZl2uk0r62AoVllG342WIMtJsoTN8WWQcurziFxdMCty0igCPSuz6Lqr4rZqvPTEDcz0bXY+FnAy20da2WU0ryPtRUwPzknCEEMR7RgZpmHjNxNOzSK2Gh7J2RpSvYOSxJw94nBLEnP8+GMMRjYXnILgQhvWF2SGxQ2bJoOrWzQbGt2OzNnBRT5x94IVZYkX3bHGS2+7hd/9iMbDj+zRCDwOrsWo8j6ep5MHCmYnh55MtgpOPCNSJEYL0W/s0lXnFKlOagbsj3osaxZqnnLn0gra+kE+dvqPkK8uY7zaw9i0uK9+CcXZ4Nw8w1ikHHZdkkRlbxIRqxFxbKM6OWmalMnLrGizPx0xSjxsv0fLVYm6OdFOg+3zKrXE5ObDDs7qnHGkYJsd8oMyZ+XzHIzXMSWTIgWJggxR2SyhSgaFkhCbC4qFy6AzQ33che6HoLHCYLDDeLCGpmZoXKKbLjFafoLDx25kMLnIZOGWe6JFG3THRw5NDngu9CKiRsBRvyBupqSyi3/FQR96dFY0LFNjLvSyVRs3kcqq75yUFTVjVdNLIc9hmmLpDbK0TbKYQrhKfWWfm+ouDx2D5a0mWiNj4OxxwDpB90Dx/AUT7AgWYYoW2mQzUfbQRcn3kHsa1ngZ5AWTxgJ/VBBERbmhtdSI4ThBncvIQjakIeOuyWjnPBIvQzI0DCtCkYSmo4oceMxSmXCoYaVg6AmSEWAWKrPtK/gu6JqJaRaYbYOo2GCQblKMPDpuj1WzRaxvorQ79EceUSgCBiGa7WD2PDJvjCTqvEVLgDMmr5tldCmaxeS5Vqpwir73BLOMHuVqjKTp6PMA/+5LnL3/CiPdwnYSmnqTqLdE6tjUjvQ45tRKxdY0ERnkDE3ROLLcY+VVLrrj8KuhxF97g0qWqvzsJy5z+2BEz52zn7tI0ZRHtoZcHHplP/36asCR+gxbXyPOZ4ykhGae4aYWqmGQpEIwRvTPG6h2D5hhSQFprJSuFSgJkawgxQp6IKpkJLRWC8cysH2JfWkPxR+X1QuhNCYcOczaexSShqy6ePE+nmoz2lPwlC0uSim3q6vMNiNmnkGwBBvdZc5PZ0yjKcWWV7ZMqHWHSJdIazlKNiDZFbUzEq3mgMitM3UMojAkXjgMxhHeYoak2zQVnUROmKU1DNukLvll35vmqqTC8aOIkWsdZDcm1wKanTa+qWNEE6K8SaG0aMhCY8JEUkagHKDR26O7s8LJozdz84tvodZ1WBlvs787Qp5GGDXhRKIgxxqetMVuskc4k6grOooR41gmkmNh5wq5ssTpwSqZavDtBxYQ9nlgLKFZDgdbGVFS0DNFS1xEmC4ocqV06ZB0ibbcxMgkprOETvsAOgsWU5VM63GTqHpxdZK9TSZmRlfSaYqIZrpFUeuwH6hM5h5tu4XleCyKnEJKSHRFdF0h5SqWLuaOlFkWMlIUklhHSgJaFBSxDOJvLwVMc6ExIlxNci7NNtFGLlMpKD+XtVR8niaMkhz7SpOzs6cwDt/MTd0avZZHkYv3WMVXOkLRvXJ1qKioqPjKQ7oz5fZLS1wSYtHmLusTG93JykrVg9OEySGoDTVkbYW15pQsyVDmy/RXEhbuAndLIplpzJ+MWas1WZMltp2QaZax7E9wdl36ecT00IR8vIp2xOeUo+LMPf7fuy/z9jd0+IaXG0Tzdf7ovsu8fkcnMSMmkUgYFtjLFg/267TsIfFBkT2XUYY5RTOhLUTv9uZI0i6yElLM2vj1mFgRQvIFumZgpBn7pz3uvhqwrEp89zdtcMerNyg0nU9eXrBzdYC6CFHrNoquPd3GkKblvJioARN7iuu3yzZSUV1QaiRQoOYKNSUgkhz2mgnqYwFSWpSi2SJIoOQqqq4iFd0yyZMlOabi0LAGaKpEGM1RTQU/8jA1B01WiZIFliqjSAZTPSMUmmpZQIpMJvY3wRxrOCp796WmziuWG3zywBpPXZxxAInLyxLhSEfd2qUlH2FgjekuUkxzCSXcJwxr7HV3WF7cwP4Bnbcku6wpL+PY8hX0+FVsNBq8xu5zSR0wbvY5dXWZYbrJSE4IGlc5oh5mo7HOZH/Me37jCT45i3nz16zxTW+6DaSLfOD+e5H6MfWwiV9PUaSI4VTFtSWMTDjNdWAlpb1okBQa8/k+Zr+G7QW4vYJ2e5P37x3m5Hab5doOtRMbOI+n7G0lFAuPY40uk2HBwvfotY9yStd5YrbHrlHQ8WykPGVZ0UvB/6Yp2oobPLBzjv50wJraKoM8ycUJW+ditoYRNx7OUI7EeH6H+W6dxsExza6NJS2jeCKvuoM6s4hSD0t1sUwXTJHYHJOkM2pGl3myTbuWocTHyKUJ8ZaK1CpoiVydcLKrT+gOG4Rb9bLSw3qJi2WojFpz9MDFiHVWJROvPeDcfoGR9FgyNkmVkGxiUtNByd2yaqKh+WSJU+4T4zhCFm03boAazojNArmoo44CJmYfR5gpKCbeTsLs5JTDjQPU1FXw9tA7G9S8gqLef/6CCXu+ipHsofuidGidNJuSpDL6XFj7GcSqeEPXCed7DDdlzj4Z00RneiUpbTCytoztFqz2OlxZmtO/PMGJTZymiqJlBIlEEinUYyFSkUJuE8eiH9whR2I+iGjGHRranGwtAXq4jkcRZpgLjbY8g9opitQl8AIsWSWrQR6YZJlKUm9gKxFJJJpUUmS5jSPs/8x5aecSJCFJoCGLVgZ1hJwkSHKI4sRIqY0ZO6VQoF9IJJJQx1fB0DhsORyILLbmI442hCWMQlJIFJJcRg09OeNX+0MyR+fFL35RGdFqHh/yoQuP4Z/epDmTeNyLuPCEz3QxZS2Di3HErNfglnaGa6u4yBiFCEgm5LpOZmTIiVQOKgUOTmzhFzsMsjlyapVaAFYWloJ8oaqRopAFIVkRklPQtFcJJY80yMglGd2dEMlrRIsd/PE2/jQhyh0K0bsT7hImXWrtMX5sMOvv47YOoiXQkMG39FLVNNNnGKmBKewBooCcOpI3prAkkrhAyRP0XCbQIVPysmTLMHWcUtAyo5gpWGFIqmVln08hXGm0FEnWydQcW1nQaiRE1jrOwQtln1g63ySQRsR7Te67MuP8R3bo3LHEm1+eUig9PvDhPd54dAmlvAMx3mTK9t6Eg0KzQncpUMjzgEXoUXgSiTJnasrUsyZWVisdMQo9ZCZ5uJLPAUXmtqUOTVqsjHZ4ZLLLoPDK8qw4SVEliTyTGacphlqgpyq6Fpc6B6nvE6YKHX0VpR6TFQGqmZLOEnTDRpnMeCye09ZGFIlCLs3otGQKU0NOM6axTteoEVkToiAmkhQcLceSJOLCxiQjC33CuYxqi9c/JYxryElEU/xNwg7nJh4tM0AYkUzCQRnQc+ptdMPEDCRqisL5oo+/7fEQQw7ckFEoJv3U+2LXIRUVFRUVFRVfphzZs6CxYC1pMXFGjN2ALMpp9etIGazILrOFTsSUk2sNpt0dRhHUB0KcXVScJuydNbiwuU94QKF53GUQaPCEynAlRx4XKKHBccnAsGo01h2c7pz9MGfykYTfcvt0bl3hTW9Y4m6/4OOzIXdlCdkip9e2qbsbHPLP0X9YR7kzx9vZRtI0JrM9uk4HrVcny2PiKGJpXdj4LUob+IbThrHH1pltfn9i8OKXdfmWO2xOHN5gU3Z58JFt/O1dWsKSW9ZKYcQsy3A1C5yMXI7Q4iZqYmAJdwMpRZFVkli0GacsDkXcKB+ma23j9m7hdx+c4qcLVtxVPNGqK2wpvV3qar0Uhw/iRWlV2Rb6/P6oTPqpikZDbZe/dxSM0FWdntMmjAI0TexGl1l4QzJf6KfleBO4OprQDTI21ENYDYubbl0miaZc3T7HkZrJlXlA0XWJ92cIBfjMF+X8l3BkleFqTmvLLttXOp8s8BYOL1+t4SydRJssExsPsdo6yJIxZGfQYWTuEesmtkg6YDBZSalNZPQ7VFrNKU888hB24fHaN27wTW85gmZovP/D9xF4M2480OTYus5erPDULMKeTOjIImmrYAsR87mG53TYdjziLOVAmJbr9/BKyHsCj69/g8qJHC4uK4T316kdCRkHU1aMNk1N6Adc5t5MIoqPoqxeYF4o1IVqYqzQOeDR1nQyL6GVgJe6+PIcO8uQxMbcmdA5soTedRleclALFaezR9OtIeUr9JIOmRJiy03SUGivzVn4C9xE2NI3SA2NVnSo/Jys58sMsiFJEHL6k232u+e4S3HY27vMUydzvERjsaNw4dVXWaKOuRTiBA6htFxWHVztTTnrhWg7CsHAw2/NWVZW2J30UeKEXrtOQ2i+pQqSsKgXe8C6hKmlpGmInBcoWgM5Vkj1iGI5I4qEicEh2vEV3OIg+Ry02ZjaknAVOUzQ3IckZ0uuPX/BhJtvavHoMGQ+ynEVD322wBBWjFJEag2YznyyiY8hLFmmU576pMlqPsWsFXRWD9NsKuS1lF4T6nWLgSIh6xJ6Q3wQEoywoF2rsdxbEKgq0cCgiHX8ecH+cE4oGchWTKfdxGpG7LVTjtomo/lRpnsJZm0FmUmZyc+yBoam0mpMS9/Q2f6U2n5ApDZATpB8BbulE2ke/sKlsD202EETivpxQBj6ZELRVVi3xDFoBljCVjIgVWKyGMJgDz0asZ9E3Hvv4zyVTTn0ypfwj08cwRDKtaXQRs5kOuOhB3f5kTvadJurFIrBi4/U6LRt/ulDEjdunedqEeNPfRRNp7AUbG8BuklfbDYxkAoLp5sRi3S97GGYHtLcIktUCnOMYWmYtosaKqSFXtosKhSYpoQu1GujsBRcSQMXV0nI8zlTv04RBjS6GjVEubvJjAajPGc3yrGGwgYxokjFAHaFSxOzLN8XQZf69oiLGxqpkaIqCZYaoLs1bGnMaC6CHSJkIaPLNSQjLyOt08mYeqRhCttCOcNwhWumyixSQLIp3JQ8zUD0X2UFiaVhN02WFJ2aniM1DQ4e0bDbTVbXjqK5Jr16j/10nZ3Nhxle0pCVFjcctzi8ssxvPTrgzKNTBudO877wX/KO2y3amz0aoVS2YMiKaEfw8eMxWSCCNQqSLlozJCTxvmCAEorr7WKrCcedSzRxmYcrLHc3OGwssx97+GFUtjYIUdfI1xAmPghbn9TBsoQwRspCyWgrDXQxYCvC5yFEEi0xY5nL3oxMWEMu5iz2E5KOIx6C6uroUwmLgKIIGI5VfDWh1YqotTqk4ngckGcOcREThnOyUYafa9S1DCeSkcwEWSmIMokg8hn6woqzwWpzGd32ytYjpZFiyRm61eaIZDHvjdh+0EG/Mma6rTNXJ+xc/OwDScVXlt98VaFQUVFR8ZXDztVZ2Tp51FY4p1rsbCvoHZOGX65S2cmFyPQFbKVL22gwV4cUeoE8k4l8k4vJLntJjjr22JfrXJ5njM5PabtiI+JiyxN6ckpm9ZDXZhgHwZw3WZHh4FJI/8NzPloY/KVXKbzrdSm/80EDb3fIoewY8lpO7g45evsG9z4G2ZkHaDZrFLpZaneNJh0kYwtj0CTUWwQHQrQArMBAOevzwM6CTxhLvP6Nh3jXy+ocWHb5WALnz57F2t7GLUR3rkWUCMcxoclmEIZiDSbakY3y/sjCXlJVEPXuYSSqjAsM3WCp7eBoTW7qrRA0PTaHTllVkJXdyBlR6JePFeKPgTchmppEK3uYtYRYVJeKpGASoakaUSEExDUKI6NQJRiLTeOIQJozHs2Yz4StuYqpecyTGZtbElIRsnwsZKUOxokTvK8/YnA5YO1kkyt6xry9hz63sFszMrNNPCqQvZxUrEEnSSkO/7Gzm6wej1nVltmq38vR2UH82YKb5ippYiD7Kr14hau98yRxi8G2T2oV6LLLwTWJRsvnsbNPcObKnG95y4t5+xss8uUWn/xwxvFU4c8dDbgcF/zm3TabSYHfDEiFLacQM5RdrKzgDjfg8qUa+0eERp+PE+T0pZgniwav676MoH+G8doOVzoL9P6NT7f86mN6Voer7oL2/oRmoLJTiOSYi1PXOVTPSEKFi7sDLu8pOEabhTXj7GKT6bhXtlaojsbINJhlYm+YczgJudFqYXbFuliIZ8oouY6maxxcOoYXLiDOy69422ckh+y5PmvTNna/xWaxg7UbIusul5b2yeoubl9nL9xDTlVe1HcZLs3IkhZPGSOKUGdJ6I/sFkTpLvO0ieUGJMacRaiwmGgoVkhdq5PZGnFWYIoCeV1DknJSU4KdLro7pnCENohNlrgYtseKKzGd72AUDZLamCSwCfUBtQsp4YEZ2lhnUy84GSw/f8EEo6vz5toSo07OlfGY+UQhTwKsVCaepoRjGSnxyF0VPZXJxilbhc2yLmMaFpIwLEhgFgtNkgLbEHYVCnJDyK2a2LLG4Y7N2kaDOQlS3WA899jbnrAhKTRu6NB1bBxhumfZLJIJqZ3TNloURkwqHAP8NpjCNnGKIRT0my6z4ZBiGjBNDYQrja4PUf02kZ8TKzH+XCGPfWQ1RlGapaWKXdcp4uWyIkJsvDORdU5V1FwlT33IxAbfJJMSonCK//Am/YuXuPTQJn/l1BFOvuIw33PzEYZM+ZcP30vy8FUOvemrhcwkGiqlEKfr8viOz+jCHOomtBW0zGDmhZi6yCSH5ea/70sYWkiQLKjrbXp2EzWyiPKnvU01D5SaRkM4K1ga03DOxMvQVJWGqiDLCg09Z5Jl7IveeQ1cw8BQA2ZKRo6CLzuo8ZiZnqOtWDhFgqPH5FHAiusSuQ5WapGJD0ery2gRwZUGTttHypfJUxk58NmfZ8z9CMPQqPVyJNcUXilk8ZzBU0qpfyGy9HLNQM1SIqFYomvokkQqeeSi/EaxkbQ5apFSM+usyBqGmiJpDZbWW1iHEiTnRjB82t0TvCiLuWev4JwEx17Z4403Wzw5GfDAvedRZhredMH0fef5Hx/TaSbLdJbW6B5Rkc0GMjXyXCbRLBJlhBSq6G4Dcp9cfBA1m1iMC3GMlE/ZzofshiGXhVVlsmDL75daH/FC2FW6KGZII7KwVL2MVotwSRGotGUbS9Fxag6qNiPTNJy+T9/cKfsG1djHzlP0Zs7U85ETmdyRCWSFJKizWATMBgM8ycYqHNYPySSRxoUAhoMJVjyn3jJwbI0siPAThf5co5Xq1F0V05TpmhoDP2YySNi2JjSXImzzAFPJxw4VMlFmolm4NFFMoXQy5u4HNhls15CiSjOh4plULQ8VFRUVXzmEhc7lyzskG02a3i5XNtdL1yhFSdivzemkMj45qpzw+Hgf39fFshbF3uO4fRgjPUFcv8RsxSCa5niLEXTycq2axirZkstkJLM/1Wg1hvScBl1anFX3mfdhey/h7G/sIy01+LrDSzz6uiGn39vFERXTqUne95mu+nRvs9g8lyJ14Xh7nUU4wulpTL0CpR3Qrq8gFQaqoZM8EfKRcwGPHrR511ss3n6Lg9Fs8r/jjIsPjOnuXMVwInR5CakQyaKQTBUxAyEeL3ZsordZKrXhLMMpBfaEIJ9oc07zEFWWaevL1FZt5KUaQbDgNaeErliMLEmQUuofmJpROnQV8gJdCOYlNkoqQz5EllX8aIYWi4CDcAkwMHKLKPAZzPssogkiD5f5NpIUk2o+imvQbRpCXgEv3mRy1aS7cZD6sZBTaZMH39tj7+oerRtziszBm6j4UxE80EgaHuYsZ3+e0kliUqlLcec2E/sAS8isFuv0nwzYGQ6ZLKtMD6e0IgslXNA2TPpJwEo4oxY3mUcxUa5RE+vt5jbnz57hf30g4Z3vOM7bb38Zx5QRk9NPcd/FkM1pzuWLHmqvQ1KozOcJmr6FkxgEuoRqFbR7aVmxXCgh28oRDioeNxgBy0sWq5NliiSil2QYB8WGc8pWEaH4DgcXTXQjYTHx0VMLwy7oOcuohc4sDtgdF+wEY0w9Z6mwiPwmk/0Zab3O0nIDqZ7T0grMmczOlZiPPj7jDmfKoZ5ZOjRQ5EiyiqdGzFcoW4Bi9lBmDpujy4T7BZvzCZ0o4BOXJaKbr3Cz4+DqNo/fuEdxj4wftBkkp9m81yX5qgaHLgdI6ja+cyMNr89UOF0ECkN3Qb1Zo2s1SYS2Xt6h4UiYSoaaZ8g5T1fHZxbKKISaj9wsSGWLQM9RoxiLBCWXiJKMrm2QicR+mqCldaZ2jWLfQBYyA/Eyq7OUvLF4/oIJOw/vIK8u0a4VaFabvU7G/njB6OKcuZeQDCcYhYxqFORRRJwXaMIRNdGZBj7CKiESJUahX1pmqEsOWkNHToT9XYrbsmmsKKh1HS3SacsOTc3CFLYHks6pk12iekA8VZjFE9qTNt7+PoNQo6kVZKEGXkhqSziGjWvUyMyAYKKTxlbZH5/szdHaEbGWk0d9MrFTlDPUQCtF9wo5IhZZdUlYNhrImQm2TaQsiBYTMkUWTSmlxYcihB4yCS0rwJtSLFSChx/j0cef5PGPd9k8dTONzmU+cSaik2s8GS9wh/tojkFbLfjkE08wfvBRDC+mpUUcOdBAH/psRwuKwiULEyJvhF3bwLUCJtMUz/TRLQe3lpFIGUWekWd6eU9Fj0+aeXjJGFmWUYS5aK4Q6SmaU8MSIoP+mKGiYxsWHcckEY+PUvpZn2BQ4OUTzLbNodoSmTQmGRgkHY/FRGHZVJlKTQ4e2WPzzBRvOsKqCU2JNslswbjfL8vtaz0D0dGfR3OkrINSpCi5VpYATbOEwldQhhGKIWF2FGw7KEus9GwJxxSBGkrtBCGk0W2kuFbOXFJJzRo9W0ZfzlipGzSVlCIb88kz+zy112CtCze/uAZqxuNPbRI+bmBlPrqtYIQ60+kSMz+nv3MRqVcwr6scb23gmHnptrDIawT6tBS3EToKihQgGR6ZIVOI95aQopBjcn/Alj9DU+RSJ0J4yCIGTNF8FSpIsoStKURKgh46ZWuJIvyQawqWn5KZGo3UJLByrg5civmYvUimZzrorRlFrDDbd9BTsN0AKReVNAmOqZCFAXkhItkahVlAMWU+GeJlCmZTp+nqKElKEE6FVjGEQgRGlBdKmI0OyysOTw48dkdTuu0lAiUqlYgTUwyIGaa4v50QGireTkpyfk64k9E7oX+x65CKFyBVlUJFRUXFVwZr9WXcbEp/mqAUx0Van71iygnLoUhsckMhWbVxRwrDq5cZBGucHYX01kfohzuYkYyBQaQu8FQTo9miZvnU8gx7qSBrZxiZweF8gp1JJH2DHWcPYyqzU4SkLQ/p7pjf+X9i7vyeNl/fDvjk4XUe+P3THFYjotyg2Us5vmEhey3CLY2p8HonxalLTEXlaSRhGiJjXmdy+gofeCRl50XH+bavNXn7zQ0ytcX7H96nfzZgLTyP4+TI8poonibI5qWgoi42m1pAYUMtrpGnOaEa4DshTa+JXohNfIauOiipgjZJ8JqDUm0/O6+R6fcgmS8ljEN0xSirWSWEJWWKnJjlnsSQbC7HWxiiacCL0Q0dSdeoWSIB9nR1YLmfkhLmcw1JydHsGCNO0YuUJHOZR1bp+qAqM5TYxbHqpIrF+vEbMO6S+e17h6iTXcyWVDrXDQ0ZXRlQG2vCsbF0Mxisu2RNj1etHecO40Z2+uc5+/GEWXie/dREt13MNCG3p+wJlwNPo57OWZaO4AaD0n7zqc4Yfzui0dN4paSxfWaP3/pdg69/w6285NAhLvVafOSJR3jo8fOMB0InIcdZXaHbMxnN1lDSgJOHmujNQzypK7QnMxJN44jsY3kqjewo+/MF2cqYg9FhavGWkNnnyZmEkSj46bRs5Q2F6KCxhLOh0YlHFL7Plqjalr2y/TrJRap6huw1sLWCwvZxU5WjLcgPN8jnGZJoYdY1xn2fex45ywVH5UCnjtLRWG8HqBxgKWyCGTFTR2jeKku1Vbb6u9TnBQ8GKefOLbhrpYaKzOOdBe5eyoOBRf/CZYpzKadfLCE9vo9yoYt+2OTEgS3S9ZRYbcFpjdZwwslGjZW2zWISQFu0fYCkyqRphqQkpXC/0EqTjQxftDmrI+q5iS2ZJNkMWbbRCqVsv5ipHqbsEKJgFzmuUyNpD3HiFVI9RQmnTNve8xdMiHKXh/cu0ZgvsVyvcdAoOLJRZ+7scuZMzJVQIsosciEuxwBL6CgUXll2ncQBsRdT2BpNu8PGAdFisCDPJXRJQdN0LEsn1mNU1yydHJJMoVAKDvdsXGmZdsvg8WLMzPBwVI90v8vWnkoajKmt2MzjqBTC03yFuKuXvqvjYYg/19BkUYI0RLa6sMiJFAtZS0q9gAy57Ecq6hkEUVml4MURiaaiKQaK4aKJDL+I9sgSGBJSKDZ0AaqsoVlZqfmAZKFGC9J5SvrUFg9tz+loBetHDvOKN5yk12yzO5ojTcfcs3uG9/ynD5GemZPUXIJij0XSpa3UuOlmlzRewg9mZZTRiD0iRSH3HMYDUXK0xcZGDVmxyDKZWI5Qgxg7VogynyBUMGMDyc3QmkXZ5pAqYDoStVxmHoR4sYKtW1iaRxa7LMqMdVgqC2imhZzLZMLWM1EwYgklkbgaxohc/iFTZ9yqUcQ2djMt7WvSPKGwTZqFhdFThf4ks22QwxzTDEkVh7TIyqoOWQidykKI0URSJQyxyRZlKmmOH8vlB7Ur3C0sDddS8AqF8QR8r8+BnkGvKbPSqDMNEz7+savc974tFmaDV77G4sblNruDAQ/fn6HuzjGawmIoLQMtsdQHrVbaYz742BW2ZThydMbtolrFz5AjGbkmIgahuFlPC9d4GWkcoyo5ppg5xDXLBoWeEPrDUuhGyy1sQ1QFQOQEBAvxAQ3QxCRSyDiNOrVmjVQVnroRWqThBwmJIWGHEr6eEgUug3CCo7o0DI2oE6LJHlpqoesqfi0kHarkZgM/mrMIImwh2pPJmHmbOIgZTYJycvH8BWqigpax40/whfJsTeOgHnKo5RIe1BjkM3ZHYdnGYrdtbEPFMmRqikbdTVGyEZKw+pwEhHqKnqZf3Cqk4gVNVaVQUVFR8cJmmEqMjkJ+cU5TtVmXE0YzCU+FTJ2gJS30gU1cy/HdGmlSsLkzJI4NGmK9bxmkYt0iJbhBQU0kL1YkrIaDvSHEs1U0PyScagSeRlOIOi4CIqUg64R0QovHWjPmj8T8/P+w+Ka3uUyOBPQPa5zdjGkEAV97u8nh7iGSdY/zF2ecPZvTXB8xCwJqLYOm3Spbsffu9fi/WxK3vukYf+mNdV56yEKovN3z6ID+R67QLGKMdZlUt8q1aZzNkOQCR++W1Qe52GtIBmmWC2k0cj9DLbRyLszSpwMDimyQCb2r/oCkn+ARY4SiynO13D9ohUEhSfjZnLrRZG+6T82oIyuiQj7GjCUif0ohWryF7aCS4WgtJBG8KHUbQOg8dtpa2fIgKxnepBBulNSE6HwsMw9FG7Kwkk8ZLHZw1WVqa2ukL0q4yzvMR58c8iJ1yqy5zBV7gTYumFkSaZiT37DE1zQPsLs04Y70ALG/4N5PjNlrzlBW6hiyTOh4ZatIhOhVSUkGKh2twYuPmGzNTqAlHkcaPmHg4tOkuGFKQ4kYnj/Hb/1OwmtecpI7XtTl6+96Oae6J3jo3A6PnbnEhZ1NOoOCRD/O8rGUkyfXmLZNXtNXeOShOfGoh7SUc6yV4ToBi6nDrBFyrN5GDm/n8s4FpkVIJNqWRdU6dTR/m35jmU6RYRQGu16fSRFhi6Jc4JiS0bSbxLZ4TbBsrWJbBcdbOh1rhVyVSgfCq/UFFy6P2dmasTedcG5zVlqKHj3ucPzABdwNh0a+jskh4lqEG9TQWgPkIGJxVmf5lMSqFFPEKn7ike0oeBeGJDtruLLKbPdJlEaH6MIO2ZkE7S6DjfUOlqiKGEYc0iXqDYVkOi8TxrqdoSZCJ0GEJyIUTUVONZJgTlEzackdsmBCkglRdo1FEWKktVITMFBCLKlGHs7QrA5xGpLlOZrQGGy4+KN9gvUm7kh9/oIJNx1sMI5ET3zK1e0LjGUFp92itrzMrUt1untNBuMp/XMDwnmKGkQoSU4Y2kipVG668tgsbU8Mq8ASgo3zmLqu03PrSLaI1EjIqolqSAyipz1i27qGITwymRNGMrPxgMhrkodTYjXFbVJuqJOiIDcNlMJC8ydEasFsXDCP+riqyNJq6JaKSY2FUFmdCaWJBZJdLwc58qezz0UaI9RkUlUENDLkYIql1lDrLVTNQ0pC4kAFyUSShKXJhEwXzQs5ipojGUKNXyMORvQDCWW2w8xfIxR/LEXl0mzAe3/vAS790WUc32HayMlTjVaucOymw9x0cgkKl91hn+HEYxpsl3oUaQKLic443mMaBrhGg3pduDnkTNKcLEvxwpzYy4jzCZHhkEUJphySJKALmUzLZerN2N6f020l+PGcuSQThwq5nVCTVEQ7URQMy2oBW5NIAxVXTyhCo4wij3OT3FKxeiEtVcdoZmQdUd4m/GENMEXbSB13kjD39xlMQ0xjjhobpMI9QlixBCGFsDRMXZBS0sUU1bLILB9Fb2LLcqnFkcQZMz8mDYT/rhigHZJZym6+x9S/wsUnp6SpzC2rMu3eCok85pGrC0ZPJNR0jVyXypK0tLDL/iLDNFCTgHQyZu+0zGJvTN+1MWQREXZodXRWG2Os9oTYMMgjGwoDSYgoCi0EVUZS52iZiPTZzPKE6WQbvSbTVXviDpQBEtGSQmZTtB06ThO9LuxnLCJJZTGbEOgqegiuLaLHHi0tLINXrmSRRAlNJyGKbRShRkxWfm78eIGt+GRyVDpd6JmFzRzHyZAkCwKHsS+EM02aekEczZktYhRLx6q3WAhHEqES3HVoBCbTwRBprnPnwRWalswwmXJ+c8LOJC59cWVbwdXrJG3xVgi/2HVIxQucqkqhoqKi4oWLbA25VV1nsOzRiHNGDZ3CX5DlAQflBoFfEAZT4lBlXWtiOPvMD/qkksbFmYdcTJmMNQJfot4UGV2T7gELxdKIpIjAERZuBYUhIdefTpIFgc4VL6DjatTrPvmhMe2dJo99dJNl4yhveHvA2lfdzv/7wEfZ/KDC5EzEjrGNIRvYbotJ36ej1ZklA/JIVG5OefyROR88p3PbO2/gnV9d4/CqTDhp8sDDUxY7D9NriTbYOrkuevZ1ZFVUeJqlpXmmLihEmUJYJ4lC4iLH1B1MkXwp9LIyNScmyZOypVkEFbJYIktTTFmItgdYyQqqrJBlOYv2EHVglhaFiqQQxDMkTQiDJ6Xjgwiw7IYN7GJOXdNL1wZRdBplAb4Q3E4TVBVyQyUJDYowIXYLfMVHEZ6HbQW15pCrAaM4xL86Q64p3FQ7SP3Fh9iVtggvmNRPZCgMCYIDKFaKK2fcUj/AS1aOsRvvcvn+p5hZNS61r7Kib3C1fpGTizXyaQM5zJitKKz6EYthiztvPcBtN7ocz5b55OknMKOUpL7Nrq8xVE3q7RT2JC6PNvmND29z9twx3vLy23j97RvcerPL1Ytr3PPgNu97ZJdu7rG+puM0aoQdj4biMM/arDhjNguFW285iFmbMp3GrM2OMIkep78nJOfqKMkMJTHoteo0nBa7/RGa0JUT+wrTII4zpDAm0xK0xMVy2+StAlmOscc564mE3tHLv5vmeeiaRXsFDpyy2TjeZvv8gIv9OecuTeHShMyXeGorZKlt89JlE7npodddDKVGoqi4wby0ul8/Iiwkt5gOX0Sm7RBOW8y3fHLvDPhH8c05tbiFpl0iHats7sh4A0j9p5jlDgtV5dKwj9ntcOvRFsu20MWIyveeZJrkYv8qSxS+RDrLSaygTNwTt1HSMVazjmVaJEFGO5KQahqzLC1130RSuBEvCAzIpmO8OTg9idB+Hq0hB+kc3V5lpZAYmzlxPmR/d8EwLsrI2AmrzktWVuivbPDo1T4XrgwI9zJqexHRAZ+0sUSSaUhxUEbKul2DkekzTnX0WUEXD7Pew8oMNDvBFUKHkohmPa2KujmfMs9igrnN9GpKx41p9lSyYcZoGJcbdVVEEbWYWqQy8S2i2RS9tOGLkeWESBIeDDJSNqPQRKa3jiEcEuIFsWqg6TYaNooCqZyXQQERXAgTD1kXm6oALRMRQB1JyynSiDyNyTMVRQ2JnYIiisq2DUU1SYoZ8/453vehCTtbF2iuGFwc9Nl9fIFqFhS9CYpkI096FC89wcteczu1Tr2sDGjPlgjnCy4XGwzne4wujNB3YLHwGfQD5mGIdCimJllkqcJe7DGfeaihUOxUUMQbQ9hEplrZMiDK2U0hCqlo9PcL/EBCMwwyN0OXZBqOQsOWmGSinCd4+jlkudQ4sKMedkP8zUV504zOqoU8colypVTf1bo2HScnWkTEixmpkAtwLdKZw9RT8KIBrqWiyzJeUhALyyBhoSlEHkWpjahCaehYgUQmBVDTcBqiMiSlENUAporuJ3jziOQpmUT1iSMJZSyjCUXdjotTU4nSEU899BTGdoNC2yOeCYvMAsPMMTyHsB6iSBJqmiMFGdkgYTCSkfSQMArRruTs2SoHjrosLbulTY8k/hdIZQRPkVSUQHgLZ4h4gmYI0R8R7YNJtEuUC4VXEZxQceoqsmujGQppHjOZDpEjpXzvZNIAKXSJkxAvjWnqGrFUYIr7nYMhC9VhiLMYXXhO5As8Jyk9lu3MIhorhFaOqkjUuzr1zIJEZRZMsPIMExNfqCRrkpD3YDKT6fdT3NqAxlJBGhssPB23JuG4GYYcsbszZ++pCfkMbF0iVArMRCIKM8Zx9sWuQyq+QqiqFCoqKipeeBzWNRZWQTOqccit4WYJe8tzlIFCnope/pyFExN4cqkuj2KwckMdNdTxFQ1dVjFqGm3LxLRVRNV2amdlxlTxJdxAJshCmjUFQ1YYmDJb2YJox2CQ7HIlcEgVjdd+7VHuv5Jw9tw2Xzda466bRiR2j/dsGjxx6SzrB8T6T2NdlMmfX7AIFOS+Tc32uLvv84R5hDvetcRf/Oo2h8U5uxlXLm0x3t/G0gzcVoscsxRbFJaRqqahJqKVQCZmTJTGFIlfBgpstVa2norWbeGeJqsysiIE+dSnS85l6el1o66S5ymRnWB5JnmegQJO0mSmjnHlJo4QHpf80qYvFor7coZrdch3DOhkkMQkkkYo9iv+gki4Ngyfrpy1mgbzyCSUVUwpwvNm1FSLZadZBi4UtYFTpAxmAYvHprRfvsfSisUbb7yF+4bnOHNpRrtjI5tCiFyjfsrimKJw4Uyf04O7uby7jn00YFmvQ1uiNWni+AMmi5tJkh26loq0r6P7q/SOrlCsNel6NW4+eILByOTKlsZyuksjcNgyNPLDHgfmEaP+hI8/9Ag7/Qk3TFa58ViHOw+vcPRglxtOHiLcucLRNQcrlmnuq4RRQiYqCUSrr6xSW5mTJCZyrCJnEl5kYhoKO62YG851GdQz1tod1JbH2LdYm5hMlrbJshaOLDPITbxwhip049wpSiwTpgF5qGO0IupLYm8ns/Ch5hjkmoKZa5yq1zh+W5MbU59LN4zZvjTnE6GHf6VP9FRBvNcnYUjvkMFSp0UceFwaJZgnJ3iWw6VZkzV7zsa8zgP5nChYINtN/N2n0NQTRLsy6lINuZ3gLDQG3ohAm2NNZfYpiHOD9VsiAmuHJLQpIpnC1XCEOGick6ogC826hWjpj8lUicKcoRZJ6Q4i9sO5LJEIS9IYDHOp/Mz54v1n2KR5QFTk4IpKcwW9Jez1nqdgQn9vryzXdtIudatVZlUzU2G7iOjv+fjZgka8jNZt8JKWy8n1Fc5fmTHc77PlR+SjadnXIZs5dbfOWrvFsFhwVqhdbicg+rpFQCGr4UoGvrLLTpwyF1G9SGY/8VDykFmkE4yn6OIDJweMByFhCo6ZkQYypptg6BH9YcgkmCMLcZd8HzMXApETZolLlk+QRO+R9LTmgDBYFIKHsmwhdobCG1YkooWAniTOUUQPUkrkCQcKBV2aYxQ5uWlRKA6yL5HLGcn/t0kWQQilEG96UWKvsxjMeLR/AcmRiaV95NRGarZIwx3UxMebBBw9epATx4+Ragp+nGGaGXInpm7maPIJnqxvcs7cx9vPWMQL+kGKtJihmMIaUAheCn/VCEVxsfUamuwjWWopMLKIM7w0w5FS7LpGLZIYjCPMTMZWRe7bI0oTFkUNVS2o1XXmWYJXGChxxHpzBc/1sPZrkE1wbLMMwMyTnCIKWJJWaAZjLvkB/gQUIVIp9BeMArWukKkdLFH9kYnrkIjnGXE2hTwimdco7LwUagyKBbkIfCRm+eYWNjzzIiKWxP3QKZSAZFR7uvUgSDFimcKJiXWVhD5bmwXTcwHqZIm0JsQlC6bLoO74NBXRa5aVG/yUBFlU7qcg6zFmJqphYqbzMfO+xH4WsjYLWO9ZdJs6mmQjFG4y8YC0TqGLv3eElosCBRMjEM4aYsMt2mZiMepgK9bTKr92XFZlhLMJs4WPZYmKCRFgGVHIGrpRKyPZUSHh5SE2Bf5gwcBTymi466QYZS+bhlXEZTnVPBGKCGb5XIX4BAvBTmGjKeVoqU40E8GisIwyynWLXIpLoRULh9CTiRZTkignq9tcHvss0pS97QF7O7NSQbetaky0AuwZUn4QI6oqEyo+d6qAQkVFRcULi+3GgmQSsOqvIjWgCDzU9SbF1Cw3LB1LZz9waOgSoyxir6+yEq/RXANzOcEdFIRti8DxcZSURaSzv1hgifYBpVlqD0RjGUtshMysXPtloqJAdZgPHYq8wS0nl7n1rhbDEAa/H/ArfzjizzcM7lx3WLx2jd+6p8/s6j6NG5bwggzLFNWuFrW5wpVzCo++8ijvePkGbzm1jFOLuXxpwdblAbPZAEOXkKUaoTJE+GilhUqsxtiFXfbgq4oORV14lpNrErGovNZF9kWhFS+TZfHTegZyXlqK54kpjB2QZJH1V8u2bSnW+fjpfXb2p5w65LJ+pwUTlVwkJ4uMtBAODim6bKIpOmHmY7VSPGlOmsl4wbR0ipBiFUkrUMusdFEmyXQpQnUlGpqFLMkURRMpcJAtUZ0sKiM0XGnG4qkpl7sh+q3LdJfb3HriCNt3P8Vaa5n2LSlm2mSUwblHpjx89QKBm7FU9ygki2ZRo7ZXcNmBhXCtCPdJ9QB5u0eUrfHmVxzj4OF6KaqJoqKvdKnXElZilcu7EUbsY/kag+xpMfaWbdGtqYymE97/kSEP3Nfkk0eGvOZVx/iqE0tEq3UCOWYuEsI7GVv7A+Y7AUqssXqwSWH54B0tW4iRC5rtdVYPLnAjE+mQCJ7sYdn7XNnLGe1rFFJEVqhERsrK2CDtGvi+TScuRD0Jia+jzlWywqW+ItNp6uJpUTUJwxQ6iwYEJorYMqoSjmXw8oMbhAfhaDxnZ9NkcV7mw4MF0ZWUTuqxvjMnnFnQU3ndwQFPtNbx1fPMhz32L8RkU5mTt+nsjXp4+ymSLpN4E9JFQeEWZN68rFRWpXUMfc5C8pGCNdZF67q45twp9wF6InQ6bDKR2CYk14WoR4pWxNiSSNTOSFIFJTIokrBssREOhp5ocNcgjBZIocKkUyDNZaamX1byI4XEmf78BRMKRccMd1mkIgIUg9nEbhcctg3imcLeImNn16cYT0ldtbSvu+kGk2TNwZcTClVEQoSCqYmh11npWvR0IZQ4ImoU5LKDWxduC1L5gfNUg2m+QFFCMtlAd32URUhWum7k7OxFzNIBMzGqqBaqFVOMFkz6MotWhr8Q5fQ1Ihks0cQvSvjFRivJyaiV/U0yQ1JJ5H5FEEFsED1EA1SKLOpQSiEL8UEVffKSpJRVCoVXkCkFoVqgFA6yJpVes0L0RBL6ECKo4aelqqb4nVmRYql1iigkneZIdoJkJeiWgaJaSKMFyTTFF/aXBXRMB1fNSbW89Iu1DYmWIfOombM5XiCnLU7etsKJmsK+N2S4O2BxpY83VsmFC4AVo8nC2qUgcQLiQidfFIRhRKgbWI5MoxsxCgtUEREmR04MFllIJB4fjdCtHE9stJEwFjZCT8SfaNREv5fqMl2oWHmDtjQjskLsWcRc2LnMYtLcQstSNHEXG9BqCIVRs7TXFJHaNFWQUw8/UNENpawaSac+llDE1WLmuUQuJdQaKqbhUHoiZDGGo5YVI2JfH2lDGOtYTsHx5RqWBdNxzLn7ffxNCzXbwpEO81VvWEI9qXPvvZfpb2oUV6bE3hTDMklj8f6wUeoxas1CVV3cGgRqwGAB02nC7jDj5pMKR4WopKSRZmk5iYh2FlU4loiyNjSspoWuKiixXf69Nc1EU20UXQh2hmX5UxL7BFLEdDEgoYsmTal1NerjDqN0SljUCJN9Uk0nCj36sYwrBFPMtHTcEDaRgXhT2nMyIyGmU8r2+EFR2nOmeYHvica6tGwfilIN08iBBYapoPhJqa0gauTmsxA/Enc2YVM2CPOI4TxisUhImg6kbRRtSl64LLULGqb1xa5DKr7CqNoeKioqKl44TBoFrV2VdLrgiW7GUN4nS9ockpJSP8CrqShxyIq7QpHJjFOP3dmIZqeGO5TLpFZoJhSuj6XIWGLTKhJDwn2gUJinKbsLj6ns0KjnREONpnSUbn1IP9BpGTa3bbTQWy3e3BEJGYlf/vXLfOB/z7jj9TZ3vkhnKN/ERx5+gFecLqiftOkeHdHdr/ORSUS4fJh3vaXN1x9tl5XMZ8/sMr6yjyi8VBWrdPYSdvBZJtZ1MoZilvoDQvcgUnxUSUONdIpCFRrsWKpTJhrF2ks4MyiSEMAT+5yMQI5KsTtRERxmXplcmnOFxx7pct/uVfY/cZHR+ATf/KKDNPUO4+wMcWwy2mkj29ssN5fKaxFrQafRoAhzMuHgNteYxgE120bTRStHznholLaShjYnlxQyIYQvq8zDmP1wTrMp9gQy0ywnEnsx28O/mLKrLXN8XWbt5CovG3vszAbcudQnCFtcuvc0Tw0T0lWTRHPYUCT6E4lpq89U1pEHCp58HCn2UUbLuEcP8DUvP84dJ9cweiZ6NkUxxT7OxGxkrDlNnIsG5x88R3M+ZyqbjMT6VNUwdZkD9YDODKajfc7dPSKdRcSvWME62qKpiUSwTn2ushwV6MacqzsSty5LkBwondzWbQPZ2sWwD4u9Pss+7DfnjPcH+POC8ShgPAerrSPSxfUoY9SdowURWmjhTwJ0W2bqTKjjoshi3Wxiqi5yqmBoRbnGVzOhrpDj5QFBHCKLlndZoe5o3FVvM7kZvAMq8mQT88ISpy9uMtobsbhacMONEoesI2hWzP0HavhSiOTV6BgeN653uLCwyFYOMWzkXBVOEnkPKd9nPI7IjBqqluFnoi3eZbk75eByk3rRpNxqauJvXjzdsi7a+LWIXNNIa3lp423PNGRJCMOnoq6BOIzK/UriJqiJV+5XIh9sUyfORWJSpvA64KaoC4Vxffz8BRNEewA4ZYuAeJME0bS0zGtEa8jIrFs9uj3hngCz/QxvsEOjY+EodVbbHdY3RJlPwrgfomkpqGH5AVzudtCFjWAkl+qnYr802B8zVj0W2YS6WaCJkntVJpwFOKHOAoXtrTGlKsksIXEk0olZKuDPRd9QlhMnQ9wiJBSbfO0wcbaPHITkvsh+i41gjmIJ0T0hkpKiCo0B3Stfi5K3yPOg3GgXSVG6PKgI2xUN8V7KRSWAEF4JIVM8EWkpP/jCvSKTC1QnKUUnRfmWGHUyPUIRWgE1IdyiIAuRSGVKIQQnDZnMj3nkI/fxM70WN958nLceWWHJNUtxSEWREYY0Z3YK9s7GKGbBK197iNtuOchWf8If/MFDXHrMx5ul5f0s0iF+lLAcaSgRhE2fJEgZ7+TEVsbqsourqdQ0EdEKWZCW7Q7yWCujqsIlYuIX5K4BalCWwkynA9JomVheiFoN/LBAV1yMLEcX2XErgx2JA0aHJBetIUMCsVUV7R+KVUb1ClEK4Bd0ujJ2Q2E+6aJYCpY5Zz4VvzdHFsEYL8VPJaZmhNExSJWUKEqZY+AkCvVaQWzJeK5KRzVwGw1hg8toK2Tn8ZTUC8iTGSdv/Rq+4Z234qya3H7zHnefHvHAR86yPXqC2MvRvBQzzJCypIyy67mLqjgY5v+fvT/9tS2/0/uwz5rnPZ/53HOnqnvrVhWryCqOTfakZg+yWuqWNUByK7Jhx3kRJHZiBPkHkjd5kTgGAiRQFMQyIEGyLEVDW60eyRa7STbJIos133k68z57XPMcfNdlEiAI4FjNN3SfL3BR5B3OtNfee/2e7/N8HonBFF027TyEg9in2hJflYFSiTsGKORNRoHARDM1PNfH852u+FPAPKkotokIX1Lv2RKdrokIaRuxab2otXGkZiisaASmqKsYtcpANVk1fVRXx28yTCvpeCDxeklZaERia9NcXKWlFsdGTsdTqLWUuDPXqOiJWPCkmsgSxAN5KpJQRSKE31DFLZ1OSGjzlrjKMZRFJ9as8pq8NjoYaSFRIUOnN7mCWkQs60sA4+X8282lS+FyLudyLucnf8YLG2XTIukXGJVCEBscP2koFwULe81GOaGnWiwDoZXneMOE1FhwvAD3aIDd03F2pQrSRCk0VKvBWlqETUVlrSnDDLlp1XydUrLeaYq/OWAY9OhbMMtzllXGlqlxoLZ8d+yQzqcc3jvnND3gP/lfPOPf/cJN/mV0g48er/nzFxpqdsA35zH7b+/x0k/t8as3QYnhk+NTlu8+o7U0LL+P3NZVlcST5aQzohUIHWZ3HijbqosoCGhcsucS/22F4aW0OK1P57uXisjumCku5hJVnA3CPWhVNMVEU02KZcYwMPh3fvk6R47GP/1XLX/tL9U4gcPFwsY1+8yt57hG8MIdjfLifixrsbUX1nPhyXmKidG1DxQodYMuYMAmR2k0UkmXqAUDW6GlxjILXOEHKDqH0wV5omH6dndGKk9mzOyU3o0Rr7x0hfRey3sPV+xutDzv15wEIa+sdWZGzjJ3sRWFvLA7m/x5GbLRrzntO6x+0OcLnzngz729TW8wIpajokDNW42BrqPbA5w+PJ+tOLrfEjY5vF7Q11vq1GWqF4z6CgPfxxxVJMcly3RGGjnssMdQMTDMimqr5IrT4/Ov1Xx7mbDZy3ANHbducWyplB8jp7BVrRO3Z+QiEqUO7z8uiXtPiIodJqaH3uT0JSZhtixOdSJFYSLNF8Iqi9as2yGGY2LZso1vqOIfVdbrauc2Nxo56WnYrYEirSOawPu17jop7IYdu8ef376CPRpw62DCyeNjnu9lJNWUiw82ubF7l+rGmzzbfcrISdm463J45Ywb4Zj60w6vrnSO9IhmPuGJbrJIclZtTrVeUYqFIHa49brK9c0erS52/5pKaWi0mspIO+C8nLsE1Kml0tRhUlY1pVHiWG7nspe2EbmORXiSVkA9rNFMl1aJMVubiBJXly4RaYdQMWVR+eMSE6RVIDM8FCdHsYaYsmlvck4uVpilhuvkaIHY023cas2yLSiqHqXrs7+zyc0b/c6is1w/6TgDRaSQ6SqOG+DJId1POhfA8WnCvccnzNdzFhXEAxVvVBFdKCwuJEOeU0UuVVmgSveoGpC2NWEpSfEXG1ol92iVJY1qo1aSRxH3gEpZndBqkhfpoceS1e9haB5asaTVa+qsRTVlD6xQ5XWXbxcRo6jirjJQlye5HUIRoeYGtbqirQva1iSzpLEgRtErDKVGNQVOk1PiUTfS+Vl2GZ9Gk7aLhjJZo/stiisW+pzw/gm///d+lw+uPyX+jRv8lU+/zX4wwVJ03o9DTj6Z0Z7OsV522N7c5mC8jVrKITSgWApscUUr1qtcoYjlZ6QwEKt8uCQrc9Yzi0aevFbDpmGiKRVZq0LaIzFjdCmKEKuUfN1NJiRKiiKlqRyCVUnt5yjtjDRr6Qs91DeoLgYgQEpXQ+taNC2s1qCsPVaJhZZq5JLzou2qFIUzYYiw0jqdhd/xG3pDn7CvEsmmvFK4EIBMWjFfGp1dTL7OeL0iFYWsHzAwA5zMIRXy6mjEWhF4YktPXvCrlDoXsGOfL//iHTZuXqOwLT4V7LK7F/OZmzd5OL3GNz/+iMNv5aSHBXU57yxmiq/QjkwUJce17O5tpFBW1JXYyOQ6M2gNX9IENKpBYbfYjt+5a3oSK9EMNEvvhKkkK5lla9IwJDUGqIsFjaWSpwVK62BbKVrckGdCxJXsnKiOwvVwqI0KzzS6CsmsapkVFSsRKCyFZiUCUItiOSRIfCJHqw2ypujEMUszsHsGZalQZjXy8IrVLM+lKaN7zenqjVpV6pF00konjzJWZUiumPQ9E3fbRG90PD1F1TMWT1PO5OK4nMv5t5xLl8LlXM7lXM5P9owiF3U7p1a87v5+X+IHC6nyLoiylHC+5IYmUGmNwgvp72UEucvpSUCkZ/T7Ja5iwVOHp3Jv5YeQOMwvdDQ1Q1FVFHWLwajGFj5XL6dvlOjuAPMgRT0teVwf4T5R+JNqwQ9+q+H4kyN8JUM93eFf/uuY/+A3vsfPfOktfkt5zB98PcIIatJ/Z5u/8fZttvcaJF179+4TjhdrDLXEsQPiJsJULMSzbAgcrVHIJO4sCkNdd+0NlVp1bQ7iSJBzvmxuhYXV0HT3h1klaza1i9ZqsgREJVWWWPSIqdHiGjO7xpUv7LF/4PBWMOYPvvGYumg5148w8j6xPmMwbPBUn7QKiSKLUOj8jYppNl3Lg2YV+KZLLu7tbIlW5WimxBzUjgMmUWtpZVuaIWqgspFNujNZE1SM0gGzuoS8j15OCRfnRNmQm4MKf2eLV7ItvvPsmHQ1YyPwKQqdWTLHrnsc5hmDXQUONQJ7QC5LvY01WuMSqlPee3jMdGqyORrQajqF5dPoJY4A7c2WZxcFf/DOxzw4P8R7yaByDayFfC0CizfIWh2tbggqhcbzGWz32d7vM04cylWG5xrUgUFsJ+y9OeYz1QY7oxjXjemVgy5GotYTFsYKh8eE8z6uabKpmnztIuXGoMdoJI9wRe1nVIWBstK7ZZzmRV3TR64NsBbzrpmtP+rh+zZVo2A74poPsHSTWiuplRpNFqWt0T3+3Qa8gTIuUAo5L+ZdWwRGzK19eGVyk9PsAR89vspvv/sR++9nfGaRMnm7oBxdJ95pWO0v8E71Lm6gDAu2rlrYfZ/+hkPTX/Msu+D8pMfs2EDrGezdGGK4NtNC5JMaUyJHZks5LlCFM7dSKJQUC19aKonLrIPY96SeVc54ikEiZ+6sQLc91quKvtsQlWeYyi2MUqU2wu57vbAPUNL5j09MsCW/4/noRUuVlt3Wu8sElSmLumbexIyVa7jjHsNdhyueycZwn0nPZzLycAyNaXjGus5wc51EV6jE6tTWHVWTSp6IK+LwgvPzkJOjGUVusvZb7H5OepFTlRW1KlZ/eXINyJUFiu11tNUiF5Bi2TkPVNfoci5lIJtkl4YLSKRNAFTVptWlRkMiDSp1lqCnGrVSIljUVlW7jLkcppuqQhEVtZIoRE0pHIKq7Wo3JIagGXLxWBJWoUkX1HZLo4kUoeHI4c7qYbhDyjCmNleUmWShhMMwAqnvELJoE6PLhjty4ckp80cK/7p9xPPsMX/t7V/i84NrFNKh6p+RvBTxy1+5wyv7O53IcbIumJ4mlPMcxYPt/QDdtzhZq8ynKvkqwl5Iekbi/CWVXnJxnJJL7YfSdhkxse7krY81XpEoDWWo4Ws9ynrexRycRlTakDxbsZSWBWnm0GryvMb0WlzDwm5Mip5N2SQ4RolvjDD0CssuuJiXFGXRgTRdoeKWDm1VY5ovKLSa0qM3dui1IUVYsk5LqnlJEspztEXJpNmglA4O5nbFNApI4guOwpZXRjq1XmL6AYN2g4ER8bRR2bv6Kp//1C6x2pDHSafYDuyAn3ot4NPNhFdvXePuaMqj9495dHjC+mRBuS7w8grf1TFsE6VjNChdXcpkKLkvv4MlIlyM1kFxDWwtoK/bGK5QettO2ZbmjCaGi1WElhWoVkzbpB3wMsmlsseg1QoyVSOwPCZewlFmUVTyDQddxm/o1uStQV4EmMRo2oi2XaLWOY0WU1Ztl18rWvmcJUWeoxoWrqOjeU2X6yrOoMlqDKvtFMhCmia0pHuBs/0+mmGQhE1HfFUtV/RHlIFN3xMhyWW6WrO8d0o4rzHGlzGHy/nTz6VL4XIu53Iu5ydz1KZimHs8I8VVjM6mvtM2pLXBNFHQZmvWQqr3W/KVyp49oNmQ+w+XPMvRjbarLnzyaMEsmWL1FSyzT7p80fClbYwJPJU6f+FUrZD8v9Sft/QcD31/zfRiyfffqXicT2m/7RHXCo/Mmp0w55u/U/HZV1te+WzCV+sh/5vfSfgLrxv85Z874MbA5PHilPm9gsPzIyy9h94fIAh7iW1HwiHomAUFlu7SaPOOm6C3QXdYVCS+qlpdnEMWRgLH10yzY3ylpbhh5V5aYNZ252ro2hhqydlblLXJItQxfJ8bV3U8s8diq+AvffUAtVlysTyjT6+7T3YR+GNBlq+6e0aJ/hqmwaqMUOIhdlVQWwmJCDjzFr1tSTULz2kxlaprfxAQZB21eK30ThQ0sTDHdDaCDdLmgrk5ZyNTCKuG9UXJ6L017mfGDK6rvK28zDsf3md7qeCNA74/VKizimHsgDDTzRkMbfpzh5USYzcXvHbH4+H0Hf6Lv3vO//w/dLl5ZwvL9GkaAY63fFIkfOMP73Lyg4+x+i1mz0OrKopSmBg5hjOisDVW65T6SMNXx3z687uM3A2yOOZwFrLUR4w3FHYGNbduGvTzPpZeSycnmmpQeccoyTYkcpQ08LM+Wi9iuGUJ3IFhOsQflqx658S5QZ61TKKSgali2wWto9BeeAydCTuBzc5wgKLXHK8rzIFJMyipZQnbyJY/7xbOAteUc6ZcH3VTd85kqzIpxIWO3MNn9JAFY8mm12PjswLSvMa3/jDlLFnzNiWW+irPRh/x0+qb1Nvn6GXLh1WNa9iYPY2rfk1zYDFutzi+ajJ/ltNXHUabDnHtdItUTc9JCwWr1TErnbosqeqaQpe1tYJaeV0NpGWYVEWFXum0mY9uld0vS9wKzgs+YN14qGXeRbrLskArHZSmIfMk3vFjEhNKHJrSQJ8p5F7EMi4xWg92XHzbYNvf5Ob4gOHGTlcX6BkaPdPqcvEi581ncw5P59S55M3FFZCj1FKj+KK+r22khrCikQxVm3ZxAU1vqfKK9UUGzQxTD0hWjZBfMIQIWtLRT7XGRhExoZSsR41izFEyhzpfd1A8TWkoChPd3KEV9WhYdl4no+MlxNT6Rpfx1w2pWBRiZ0FrZSiFtDNonWKqqvLACEhAR6lbSVS9YB40Ka1VUK50VPUFZyCXZ10m0YwCfdigZyrqoEeTpqLAdBl4yZRJSEVvG9Se1dV3aLLFrjIuvnPIby0f8/z7Z/zcnZ/h7UGPP//TAdlPfYE/d/01rm2OiIqE509Szk9z8rbF6/X4zOdvcOtTAQ/mKe9+OOfowTnhUQjhikrLZNEPZxVhKt29MJioGL0FbtcR2zIk5Xzq0feksjGmMWtcKyOvG5J5CP6QkdOyqAv05Rxtv49t9zCk81a1OqYBAqusHCo1p+erXVYrrdLuxboRXoUAMOOQWi/IJN/VXGB7PTRTodBznJ5wKSBdFp3zo1F0ytbq2ACruOaJWrKYHXFyZlLHCtsv+dieTpVm9JSWyq75wq98ltHIICormqSSR6NzoSVSyWjavHntVV7xlpy+dZW7j1f88If3uPfsKYvzI4ooILArdLeg8RRa3aE/2WRnNCQqU9pKXsClpcFAUcXhIdcFNHXVHepnUUp4EVKXEbpuUqmL7g0nL2JMu89420QtB+SkOIaBYzgEeo4eezQE2LVDloWcp2tqdLZ64ihwiKcJoTSQ1PLi5ODZPWrdQ2vm1JmwKJTu+yyltqgUm5NBUWeUsUpjWdimjW5qRIVEQxqCkdPxR/pLcS24iD/OdMZo6pzVes3yQlo3DGxfBJ/LNofLuZzLuZzLuZw/qzOPpQY8Z2j3WBjnaImHOikwjwXV5LE1WrFqU3a1Hpq4GStPdixY44wwqiiOa87mLc/PY9KFR69qMQ9a+hs2ZVmijRQ2BiWGW1GftLSVSrqV4YtrsoJFr6H/fMBhVKIsGtoNAWKrRLHF8WrODWXBBz+8zdU3LvjcjWt89W8d8Jc/6/L6QOX7j+b8zvc+ZqeWVqsAXZNyhJpKS7E0h1rXSPJQAAldzZ64OgVzLW4EaWrQSrPb+uumLAmdHzkR5DD5ovZRwshdzFikgDbv4OFqZVIXNa5qsBI6/jGdE+KKUrFqHD79asbR8pQ2F2WiZebYuKVClMjiMadRW3zTwjCkItImjBuKOidT4s6qrmYG64FCmuhYcYnZMzAFi9XI0SKgqcVtWxLFUlVpo5k5lkQz7Ipeb4CaClQxYf3YwnFyep+bc/3K28zqgm9+7z7Do5wvXfH5Xn7G0PMpZnIVKFyY52RRn97S7ha6/Tser19kvP/f3ue/8Ex+46/f4dO3X2ZoO5zHDb/z3Wd88LU/wRE39s6waxSoo5xEschMhUop0HKbYgnJiU3/xgjnakWRzSmSHlXbkswj4qclB591uX3VJQ1UHj1as3WlwjY0lEaAlAraEpZxv6vFdI01k50DbscrnCIh7tv4lKzONYoioRIkuddgWjYtFnqTIAA2afPIvJyVLGrXGuZI4iZySG1RSw2jNrplrkxR16gCLTA0Ofx1LpZMTyklDoHJQi/Rl9CkJi99Bn5947PsthF58RjXu9od1rWBwU60RTY5p+q1XE0n2FVEGWkkXkt2VjKyxyT+ms2XwTMMmtygnDmY1hJdrjNx1Fg55sqgRKHxlc4FpEjfo6KCZXY8DYlmyNpelyZC1cBrfMoqxAgq9FUfx9kirs4pbQ07GlJkJrbygMFg78cnJtTiRDhbsSwV3LHFlY0h4/6I3o0hY2/EyNIZC4bVlExGQlbWxFlCXKs0GtxdHHO0CtnUfYY+rLW0ExOMJsDUalZ1zOm84eTCpGx0VEO+tJq2bsVE0pHqK8nfS6ViIvJT1mWvGr3qABSqbIRtg7adU6k6prZBtRpAL6PJNVpTCP4WBTG6nqLVLhouatNQuy66nnWHMKVSafX0RSyhkZyMC1rZ4RkExCjZFIy84yO0edJ9PqWyaYw+VRFj1SW6Y3RxiyJeoM0bzMRB70kERKWtPOqs6KIS8nOx8k3yMhYSAYpuoao6FQXe9+GDD/6Es0nEvZeu8j/7X/88t2/fwdDsrhLm/afnfOuPn3F8eEbl5rx0e5fPv/Uyt2/tcSvLuL53wbPXQk7vX/DxRw+YnR+hrFJa6VVtqs4pULc1JWIhUjqOhDRUKE6E5luouYXWUxloNWeiOi/qrkrFNgIyKyIol13EJJEXrjTG1iFwxD7TslxnlErBjqex5QW05YCsmLFep6xKgRxCnaoUmUJTpqilVG06nYgzlsfYaaiLWJ6pKPJuVBmE8xf/ph03ZGsbEpuL0EJPWpbxBfXinLRpcG7u8tWfuU5taLSlOExqtKbprGsFNXVZUFgKZt/l+sDj6s097rw54eN7m7zzwOHD99dMDxW8RUyjZ5x5FsvXSg52ewSGIx+uU38Vwbm2IpTRwRylxnMZrZkt14TREtN6kcErNRiPHQalhWb6bO3bNFOPqH9BG1odsNKWV0CB9rgtVmp2b46VbjDWNbYGe1hGwunpknBtdz3CXauQHoNhSwlG56gRtTRPJKMnlaYSJ1GoTI1U0bv4SU9qYpQX7Azslq39AK90yU4WhE9iTEvt3vQsbYLeRvTk53fgYFQRqYhgl3M5l3M5l3M5l/Nncu5NPV4eLnnFGnJs10xaiJuamURLIzgPVKoHCbXddPcyh7JQEjt4oKIZOUdJxDQRB2XAwDdwboTsD12G+QahM6WwLCZ2HydYoaxcXNmsS+uDtSauS+ZHBb5qUA8r9EOFmad3TCepB0/jhDs/Lc7KJ/zmP3ub//RXB/ztP7/FFbelzOecf+0hj79/jn1bZTK4QkPWHfyVRkU3dQLdJisSDNWhqGTxJvf+OpX6ArwoPY5FHnWRZNUdU0p7QIff1rHlNKAJXUGl7G7IZBFTUFUZmaTrjZzKfk55f8iDj6ZY3g3WT2PC8xMKvWJsToiTJbrjUVaSrY9F0+hcB0XYUNgptmXiuSllmXb3aUnbovs1uaFj6nIeabvmB6E5mPqYXOLUdoaiKSji6JY2Oj1Ed3O20gmWaaCZBpW1RCkVLqbHcFIxnuTcPLjGN6uIx7//nNcXCS/v1BwPCqqLHMeyWR1ZHTetqayurS0tSsabQ155OeTBd+/yf60W/Ie/Dnde7/PB3XPe+70PyJI1/pZP66jUTdG5YpsmoDVimjzHlXvbYxvHM9h5ycIybJbLkCr3CBwDdZ3x4FnK8OeD7s/yqubpk4I3P1VRu+c42QGFe4EW2UTRCstwUdIznH6P8XYP5Sgmj22KM5VREXExVFgZcgJssHOdubTwCfi+X1L0FfImoWxbAk/DM1Sc2uueA3LNdP8VMP//GyMg+3+jYw90ApOqois6Vm2xKCM0AR/mUr+uczxY8vKWzyrd5LRdsteCbQ6omdFrb3Qu/ZfUOc1oh9I+5LRfYc89ll6CuqoY2T3Gk03y5zl5lXfXRnHhd60MFDqpWaH3wJLCgFoc+BIvl+ekqGcqmrirbbACae9TyYQd2GpdPGPVJPhqQFYY4KpYikM+kDOUQr/Qf3xiQs/xYWQxHAbs7fhc3Zmw3fdxfBNVtwnziiKNSOIZaV7giAjQNJQSHVAKZiczsqhg/+Y+u5se54lLETXYqk3OikUZcxIlHE4LoqWohk1XtNcdsNMECZOI1qM3Ja2ldgARqU8Ru5EA6MQSpfg96qShyTSKNkVtdNpELB8lil1ThzpqT54ECbW2LRx+UNPu83RkRQF9iC1IFrG1T9W++Pht1XSMFaUtuw7P1tCp1VS6NCg7e4uJtEoqogCSohc+aVNi6A31SdQ1EuC2aGZNI9tsUa3shLoYdyC/RplBNcSwww6C19gedt3QX1uUn9zn9+4es/HzL/EbezfZCgy+9eF9/uk/+gYf/P4h4eo5/msun/3SFa5fm3RCiqWa3Nna5u39A8JXCv7k1i73Ht3l+OicxfSEbKZRJBpxs6A4zklcG8PXMRUD1ZmiahNqC3zfpGe5nCcJbk/D8XV002XLdTteRSXybZvQNiLCSC1OTVzWZLWKY2kYpjgTxMFh0PO3GJmS/08JcVguEuJZRiXiSmFiqgWmRAZ0C3Nc0ZoJ68UERSmwrbiLVywTUXsPURUdXdIltUE9rXgmgMhlQ1U6fOoXX+HmgXgsNERDaIVM2khbiIVWiThVdPDMxjQ7LoFimVzf3+NgEvDqGzt879Vzfvj9Cw7fe0x6eMqTjxbc3X/Oja2NDhhJqaBIQ5CwCxTJzNUkecSymBFGMWoiVY4VautgmRq+ZbO97VNVeieS9U0Ie2rXBkH84hmoqgGGk3T5q0rTMAuFEQP8vobquvT0hs2gYm5p8rxGt4UunJImBUlUIAkdsTsJ+MdQ5TGy0QyTYaATjD28gYli6V3sZSNW0CrJB6r0RwVRlND2XFzTINNymlAgqDHKMMPVfQJ/zHL5301yvZzL+e8aoQpfzuVczuVczk/eeE3CcSrb2mc0C52nXo6jL3C0PnW9ZPq+QZPMOZtcMDQ1xkHJkV6wVU3YLQNMz2JkNjjDGlNT0Yceum5TahGmq2A5A3zLxC1tinFX0obTWlyUIXUK6UkL5pKsivDKgjDu0RgOdTLA2bH59b+6ywlj/m//qxW/PH7GW79uoFUa/9Vv3eXubz9icyxMMLF8q10Tm28q5OqqcxTLWjmwJd6bo2o6lilbXfmDliQXnltFW9ckYv3W3U4okIa3RtyneoreCCCx6u6hgtonSleyuiIxYsyiRrdV1K2Iw28cs/QVwvyEdJ5ieAdYA5NEhf6sZV7Ikk7i3AasWypF7l2LbnllWh5pGVOkPlWSdHXmo0qnkE1qBw5XyWW7pWXoHTBLIUslCqC9iCNrNlkeomlWx3RQTQfFmmHH4uYuKR5ZnDaP2fVe5s+9fIM/KmL+6Def86a3QbNfCn+fOChQHogbuKVuQsxMIUhNlrL9/qzFnacNP3jvKf8sNvnk5zyePn5GOV9gui3FwCBvzRcAxgyUpKXty+mpxQ8zfM3Fv2Nx56bJMN3ieWLjqTVGB36UuvmCwaAizgvWswVK2pBI9EMWu02Jal8ww0FRJAbcEK81+qOGwWDC3eyYs2/Bk7Nz7vR0zgoP19SZ2CGGYnCelOhKw4btoyoVdqwzHLidC8WWzWAHxGxpBKShKC8khZbOtSI8vbbuABtdbMap5GMonYskiIV/EXexgcVTg9WTI6b0yeOG751/i++tf57GfY5lrflZ+6dwhbEnFamMYXTEftti3nB4aK8ZRRsExZix5bFMLjBeMZhdG3Hx/ZTohy2c2QQbIY5aodoqad6g1EZ3Rm8jgb0pneDRCrzT0NCTisKocMVhvyqobVmyV4y0MWlU0xoZA0dEBo84/jG2OXzhi6/g7gzY6BkEthBN5ZCosEoj6mpNK6ecvOiADkK8FypqIxtoob4lCfVJ0oH17DcUruxu4l14PIulhqRCsxwcw8Kwlh2hVGARogR2i185uGcCDzTR2pSqTJDCz7Z1aAt5YA10O6XsG13vqmZuoZUxpdrSeEKci1FMs4tBVEaN5ZjUuTxgYg2Jaay0O7ypjUXjp51NpRH6qql3B76qTgTrKPoVWl5A8wJAoypSJ2nRSqesqFES29A0GsumSgrMRtwIJWUmWlVLXafU8QvRQ9UsXGkP0F1aS+IWYzKtT9POX1RoFialL39TpxI1MTb5x//46yTlE3ZGJt/4/Wc8+p3nMFVQgobdm3u88tpNRoMNVqUccLOuPtPVdK7v2tj+ATde6hGXBUeHJ3z47oLZsyWaUfPkacJibWCnJcOeQdHklKZCKT+rVCWzc7Syoek7aF6CrYToekBuBpiZTlmfYWoDFC0nUyXDb+F6FqopzAm942KUtqilPt5Aw64TNgyFlRUxbWddlixq0k4QklqFWrdwtJJxLf2mUMlDnAq7oaTQJKKRdZEYcdHFzjFM/W4jry8dyonPX/3Ka9jjgKSQBgKl4yWorbysi7LwI7u+CAHyn6qhqQtB3GCaPgcb19gbXOWN62vufmqfh+8/5ON7z/jw9JSDjz5mb2cEplTZeC9ouBLHISNMRUKKaSQWo0stqN2RbHtDlw1jgmOZrIusU5vTLIU26JT3VElxVAdX1Im+RRs5RIaIHDVmLQ6KglQAMDQ4vtXFaSzXoy+KtN1Sh1pnoxMnQpuZpEqJSY2rmZRthlt4bAUuWiBVnzWmpTDpu8SJxXLZ4joNvfG4Yz9UyZKLs5ZlnXSRDE23sN2C0cTDscd/iluQy7mcy7mcy7mcy/lJnn1vzVMSpiuojiAaVOzs5NzyLOa9iNU0QSvk3lzpyPfrecxyVTArZ2zutHjKkJEuAHLBR7cQWaS2QuJFODgMXJ2JVPBFAY/dGWpto2cV9tolF+fu0ODZYUH8VG6kKspsAYN+F2m++bkJxxOLk5Pr1Gd/yN/5B4f8x9fm3J/n/B/+L1NubXr8/G2F3q7W5dm7mm9NoWji7h5TbwS+LVFRscf7WIZHXqRdPFbaCxq5h5TtlKJh6haNWtKIwNC2NErTCQ9Sx6irNXVcdxC+XK+6A2Vdtrhqj6IXcfRsq1sAxs4MQx8gRQBV9aJx4SyasshjNj0b01CpFGFzNRiq2OwFBm+iWyZJrpHmLa6i4A9N4khcryFDVedsPiCOCnxx9OpK1/AlS8K8aFFkmZaoFG7dbajVpmVo+zS+imm4FGlM+PyceHPEwajmZ79wndWy5Pt/0uMX73xCfvUqv8sP6JsJmt+jXUfoRYA6MklLlcxJsQ50XlFU7t5/zHnU0lhLGLjUiUEYr2gcjcwTRGTTWf8L4ddVCsUqZzRw2Nl1OlD98yjvdm09aarIM8rFjJu+zkn4IbPkCmePp9huS1tfJStUTDfsYuXrpKA5naGNByj+VYxizBsbJyxtnW//i4JnpxfdfbjVHjAeRFSeSi5Qwsgn6CXsVQ7Zhbg2oOfa9NwRvvMCsC7LOkQ7qF889oacAUVC6Jo86o63Iaw9QSKWWkslrW5qThbbndtaBLTNKYT2jNXDGc/ut3y8vItTPkbZ3iI9+oTrL7/M6/tqdy0mzR4brbQcxtx2Y1RP3NU5+armh9NdfulL+9z5ssXx5hnfH85YfTOlPCk4r0LMDQ1bBCm1JskcyqJFs8AxgxeIgaLC0MXH4nRubQHPB5oLdULhepihSdxm+I3JUhbGgx8jM+GNT+0jPMhO7QojLKNiIa0EeUndlHi6IdBOCkWV4gRyXaj3GmoTchotmYY5q3nK6iIiOyiY1wkfJxIm0Xkz8NHrAc9ascsv0G1RAQNqaVHIC3RXJSkb9CJGsa0XT3qptZAYhISE2vqFCyCvO1p+qxedyCARiVYbYfQM6qM1TW9FUxjo0iFZCAFfsk2DDgTYKpXITJ1lXDgGctUoQlCVLJQIDV2FRkmlyAFVOAxK11KgirjQpuiVNEi8iDGU1oqe2lCkCqrjY9Qltfjdu5fQjLLxyawRmhxq2wqrnaD7JVrkoBVixW8pLbmgBQoZoFsG+bee83sX30RpC/LZJkrtCCeP1nDZGgQM+h6ebaIbBp3XokkoBKIBmJ7DdT9gy7aZbe2Tru9RXDxmY3CA3q/JY42LJyGkq47kX0UlYSHQRTms6ijMcR0HTx9QVglpZWBZNSYmSaug6RWtapEXAk+puhqaRKsRUVQ3pKpG4huaaC9o0jtrqpiWNAbY9KOSeRJRlBplpZHKwRidwBtSMmMlfbONg+N6bOkrzkVwSGOI+6TKjDwUAUjsIzV+32RojwnrunPFqIY4J2waebJoUrYj10yDo3bs1865IKCcrne1Nrvcmq6q3Ngcc3MyYPbqPu8+esSjo6ecJTHGosAc2F3lqPAzcuF0UBKLcFG2XX1QamYY6wGmb+C5NrbldTGWOlPIVmEHFnLKkEacNsL7EJtRLRYpo3uhHUgGz9TJ25QyhrAR0EvJsjJY5RmOgB9TKMSu1Ai/QVofpMUEBG1QKTUrVXgN8uLVcrawcFqNtugQoui+QCM9Kon3rBU2d7bAfs7DBynNucZCmkjUElu6dy2V4zDjwL8EMF7On24uXQmXczmXczk/ufN0bjNITFI3x/IFTrjEuhiyGkWMtoOu0SENbeo268z/S6OkWcnyIuGBbGyDKZ4mMd6ALCm6Depuz2KnkZhwi6GfQ9Yj2/JoZwbRWcVUmeLkHmlfI9nLUO97PH+ooTcpeEc0uY9rh/jRFv9N3PLqx4+ZXIP/+o+fsfovU6ZlxZ3RVX7lVx18V5oGkk5IkDhuXkpDmSWrN+pijWU43Va/anTM+sU9j9y7SZNX6eZUVYInDmJdatQtKllEV5JD97GcoGtUaIqKtKi4iMAbt4yrPpUFWSztXimF57Hru8zCmh13B90PSUqrY1vZhkIgPydbGjFy9CBnXbUoiSzG0u4QaBv+i+i2tBIIcK80MGVxK40WeoVt5yS5g6oW6MaCIvTQsUiIibISLzA71tdpkmL0Sq7XV6h78rMoUZwOIcjJ2RlbrsOOsc+vfE7h7x0mDE8ThrcH/GBuU490subFz6sOFWZSJ2g5VEsRABTcGxaOuFvLCjXooVo9UlXBSWvcOuuWvmkgFYsmGgb53CYqffqBwdARN7hOlIdYmrhERizOI/L5mpfeUFkuD3kaekynK6xhr2MThEbKQAnI24Lt+ir/4k8e8JnPlIxeH3XLWXuj4sv1DX5/54Td2QS1XXH1asNeVRJXI8Ks6jgE26N+FzPPcw3T9bBMD8M00YTP1xE0KtRapZLSAD2mNWq0RJbKsiCWpaXZnQe6ogBh4aF2tetq6xNYeidAFbsaz+/C09mCwfY+b+/n5J+MeVwN+YPvPqH/fsLoN2q2NkcMs00sNeaHz2acRiVuf8lkXDLWx5zZV7Dc2/y0NSK6nbJx5ZDDq6ek7y15evERp8kMTzXZEBEk0lAVA29QoDkNWaRSFyXq2MHK9a4JI3NsIjWhX4ljvcJ2MqpIpVRzhrGFYr2Id/xYxAS5nNd6xTBrmedZ1wagtCY9zSAWqqXkheRMp8m2V55lKr5hMYvOeHSxZB5mJMuMs+OI5Y01GDWjDQ9T9TADePI848FpQRoKVTWnFThiY9HmKYojT3ZRoWrhHyLYAt2soTA74F6ZeZj1qgPgtYUigRE0S/6+jpIARtSJBXLxKlmDqr7YIButjtpIBYbWbdZVga9oRqeUtcJgMBpa08Eoa9oipWxtdLGEiNhQ5+hSU1mIDUkOgwptK9wFaQJoqOyQBrdzFahKSmNL/Y1FsRSRIKTR+1SS00kS1N6ZsDvQzE0KTrGaQUdCbfU1SuVS6gla4NBmW2iiMAkMRToKswIlXnF+fMaj4xN2fBtblxc5gcjUVGVLXtsMDL2z40hUY5nUPD6LOZxHFIbHnS9u8+ZWj4/vlpw/+YiPHxqE65YoT6jKlNX6GhuBxFHEuh8wHy1oL2JKW9gHDW7QkyJNKB1MRQIdDZrW0lcNDFFtBRSTqKjy4tF1olovek1NldGGz2jYspNGLOIZURixjmpKacSwKrTaRFmKAy3p4g+uIqplw8xWOh6BbW9AFKMVOppToC5i/tnv/SG3r77FtT2bq7sDLHtIKQJQm3eQEnlKCCtFpJ2OWCrRAGn1EAW5kM5YFVWT70FjvLHFV8cjFi/f4NHze0SrEzZqvRMNGlV6iK2up1XX2y43JuKEWutdY0PfCHBboSdWIl12SmfZluSxBe2S2hBFXUjIIaUPztqi8YRbUGLWDauWToCo6pxT7QX8qBFwTZZxqrm0cYWWhbSxKErSNZzhSLewiBRCsx3a+K5Gm8Sgjzo2SFHVOEObQG1ZJg2ZGrPK5Y1kxarSydQly0QjD3PM/DlqPaIfDOgFkgO8nMu5nMu5nMu5nD+LI8epCzOh16qoBym3Ko0wVVmzQptssRGNSYcL0lDBsDR2d4cosUM01QmrMUtjSlqEmFVFP3PwNgPGPQ0jLpinKc0jhaM8Qndr2tYmXEVcNCm9QgN7A7WNueoO+WH9kCa0u7p3XQ7iiwUffX3O3tsTLp4d8lAzCRydeaTx9tUNfvoXb1P1npDLkiQZkpWyoDTxVK9zDujCflBrNMXoCP4Si5a4g6XZVJqICCXTOCdOCnRNnKirHzkWDFIledEAYcsyUZy0JUXdcLKOeOvKmEAZkmQxsSwBmxZHO8Hp3WBQ6fQnGvPDBGPLIpP67rZhNOx34sKsWCGc+LCSyvu8a4eT3L3R2t0i6cU9q0mxbNB7Ao70u3tQpY7wZJkqSzyBBjYFaSJRh5I6L1C9ET3VpKgFxh1zw9O6j5XUWQeVt8we82xBHQ4xqoy9yQa/8rMhp9/a4NHDOa/kI97djkgWKZ+yBhxJW5yS0V9VtLqC5faonYzr23bHd2t1k3CtsNBDWmvYxU5MIuRO3JOKwlhnETZkAxNrc8Cm57Ht1vj1GYvKYbFoeH4ecVXP6L0sgtVL1KcBpnpGvPa6w70jj1Od40m8xDAo+lfI1LOu1nORzmnCEUbps3vziN2lx7Knc+CZlLnNbK7RuhH9DRXd8ggTlVG/xA+kzt6gEYeB+MlbgfML8FNgjwaGZlGrBZoACCRqX1Vdq4QAOeUaULsloIon4MthTt20qKqCqSmU0g64fYVfe32bI0enOVhwkIR8ZDp89N1zHv7gKhdffs4VNvjo7C5f+6NnHB1ZlCOf6xsObx3keOmSSolI5fNrJp/t7/GZPzch+VzN+d0d3nn2gHfn5zw6TxidlQzyDCXTsFOFzBYWSYsu51qloVVs8lpc5glVtoVhSqxIofaqF0KJKn7n9McnJvQ9B08gEwqsRC2jZqAZ1FqNkTWYtcqykW2p5IY0fNPAahSeTHOWq4qJWXJm1MzCiDTJubq/y/XBPk3Z8mR2j/cPn/Hk2RxzVdNYUtF4TimHfdnqpxNKpcbR2u7vN0aEhdMdTutaQCkNRZR1bQFiQWodDd+zWLcWhjYFL0PxFDSzhyKZ+dZHk+yIvDy2dXcByCZb3AqNKS+a8nkFrtgdPbvDsmpo1HIh8aLipi4sNBE7pJ6kVanLOa04QUwNrXYo4nPwDZT1osMxqGbWNR3QeC+qKI0KpRS3Q0Wiiq1dIakSKl0lKKxuk16bKWrS72iczVAaEAZUgTAdVjRZK/EcND3j3g+f8g973+D4s0+5OtlCFSEiLXGkyvPaLhgBHhpRmPLe3TNO715grENWvT77oo69usdLtzROn/S4+0+/wfSTI4xmgFovycMlx6GPpq8JtUPMssXTI/LKRoCmZlhR2daL3/fFNtNDt3Ua7cUFWaYvvkZRUMeN3QlCwlaQasJaF0WvxTFtDMujZ7QMBXgoGaNGwZrYmEVCssqo9BbLG7ArzgjdpgoyJvs+xWZBNR9grWdEUc7T33uXJ+aMrVcNPnX7Kjc+/Tl2HWE4uGjy2MgLj2zlxT0jMZlSSoMlo/YiY9aJS2VOKU/62sCzPYb9MWrcJ0lCjFrrXBBib0NLO7sTUgfTSo2KiauauCNpAFG63FQqzh0RphSpYTE6S1xZ6jRphlJpXSxF8VMMoQULzdLouma6a22dNwzanLDSpGuEoGdiSeexRH+6l+PmRQRIHBJqQtYIe2LAqGczHEp1ZSVON+IM8qYU5CZpGXZQoCoXAq1COZ2RpiZOkKNegyjS0e4VrBKwsxg7MNCEmHo5l/NvOZeuhMu5nMu5nJ/s2dguaG62tA89Yk0aD0wMP6eIfXqaD7sJ9solr1X0UcCmZPMDldovsWydi4tdFidr2kGIf6Ol3xPQnkqolmSnBmePVYzCYNQkUhJPfaGSSk5dqRmsFuQPVKJW/NALKnEux3IPU5CZNfUy5/TvL4i1BUXl80u/cMAvfFViATtksoxMPCInwVH71G2JJkR1KXFX5Agk5wlxGzR47Yi6Yxasu023nADExVDPXJqqZe01rFchA4HYqRapgBhbjVxPaTQBXwvn4JBVOyNeW0xLj4vllIG9RnE01FAjK2P6bcX5WYjT+nhOj7NwzSwKcdOWk5WcN+TzSu2kjelIw92QZbHC6irbG8pCGiZKYrWgKEsaTTy3NaZqMnR9NEucuQWt25BUNblEqu2SWkvQlJaBfOxjh8WVCNdQcS2Bgcs9ccKwZ5JlEWkeMdGv8MYNi4/zK3z9X864Ew546SsVh4bP0sxRrQCtgPkF7FwdczAZsOfHOI7GR6cm8zCmJ2fF1idxNEJZ7pYBunwtmYWWKnh6Tn/f5pXrW/Qci9N6hu3FjFYt751MiTKF8cs9Gn2fs7XL0foEp6+RLVsWF0v2+i6lEaKu+pimwV/99wasFz6KJmD0Bv/UYLU+4cA2sN50eXdd0lYVp1tt1y7neDV7fZUgd5lWJXLDLtF0DKkArSiaAk0ODJXSMROkKc2ogu4siibu54paXBg/qoh8wdoQlEKFKZB0s0YpJRYtvI2WV/YqBjODeTNEt3q89uoWb9Qpo42S8zwlvd8S3jmjTmb8yx+UnH8vxpRrMqx4fN5w8WDJnd4Ln/U836aIJt3H9TwPt9/n1mc+xa3bN9hd3ucPzh4S3b1gcRixvdaon7eYuw6V8yPQqCZFCSam0eBYwthQsV1I1lv0Rxc0SUPblzbFH2PM4XmWM12EvLJxlWsDhSiO0FSdWpNYQ8M6yzriak8gW7ZFY+pMjxbcv39BESdsDXQa36A/EPiHHKbF5t2yXs55fHzG9GhFHaZkmTwgSkeYrIREapUoYYgiPbNFQa5VqJJZX5lktjyRCspSql08fNdl44pJ4w46+3c8XdNa8qz3UPSwizAoedaRT5VWuCRmFzNQhGAnG2fV7dwMTSW8hrqr/5PqGUoDxRemQ9I5FKRiQzGlCUJFjVeotU+rB7SBTlWqKKlOk0lPafdJUEUcKXQKpaDWCgxjAtoapQjRHaWLEmhKryPy01gU7Zq81DAVtVNQpaawzGqKsETNoh9Va0jln4LmK6jriA9+9wPu//AeV/d2uRb4Xebe3Z7whlJw6+XreG6fo0XEd987guczVD3D3b7C69tjKs3uFLjN7Qm+OeEoPkU1gq6Rwoqn1IZHkVSc2DNGTzYwXnYQY4gof4ezHCWomVgKPdWT5BBZUpIbFXbrdKJAW1YYZYtTSrVmIYt0zFbvYB+NtGZIREYfEgxGBLbKMMsoSoWsKfGbC5aDlKSn07oekV52H2uyobN/q6RUDJrMRT095/gTjXRhEZ484cF7Bg8/POXaUcmbE5ebN/bZOhjge2MqcShIT6b0AzVtB84RW4Giil+hfuGmQO/IrRLtqYo162jd0VNTtUWt606MqDS59gyKcgWFgd3oeIaJ7RhkbYbTOFRFTZKWREaGVbVYlko1VIhPGvTAos5CRrlOrTQsVzGG8A8l6pLBRV5QKnN0Q6VnGZTOELOO0XoaRWMTCuzSjGgrG0XsWaJeS5NDvUZPPUIhuGoFi/Ucq1bpuWJxqgg0seRFpOs+buMwtgJcp6LcaWAtgohOujIIO0pxhBUIgOZyLudyLudyLudy/ixOoPs0asrs5gn+s1c5LZ4w3PKEZsBGUmPsmF0toX5aU6wans5TvHWK71vo13R2dlMOfI/U7pH7LWZSkhXzTlDoD02OohLmDdl5SF2EOL0Je5ZPLVDqqGBxYXPUPMZtR8R+RCtQuMqnNWU7n3D6/ZD0cyVf+dKYv/7FgMYJOxdu7qw46Nkc1Ne6PL7pSg2gRlgvMXOHXBcIY7/bzFeVOJflLJCR1jlNY1MUEZabMuwFJFlAHOUoisQZos5BLAC7qlmjGj6FHmFqAl30ePfhIQ9WEfnFjFubNXtbJj1vt6PqR6c6WCGbr+zgmQvuL3y2I5VlEROtdXoDi9AoUZYJRVMTtg1hWZENa9TIoM0UTDvB6Fk0pcDGRbDRcGwDrxx0zt15vqCqpDJQwep5bDomlhlTlHknaJhGxfGFRs9zcRyF/mSCI99fJUHpllV4gq05jO09du74/MLM5Pf+yylfepqyOVZ5qIUYhYPT6oI741PbJq9tbtHzci7WCvoTnbMkYaicYyYN3qDBkRYBQ2cpS65ER48Ugn7L7SsON6XOfanyYethuVe5mp6gpQWfH9RYO9vcf1azTJ7j1Bddo0ESn7CIhkwk1ryeEBYw6OX4G1v0N13S5D18c5/cnHE0nXFtZDK5coXD9+/x/OI5pj3AGyh4BPQVWb6ZDA1hthmYIo5pAjCUSIwpQWjZOXabek2c7Iq04UmEQWrhRVSQKERLq7bduS9XUozMQpdIjCrCjk7RLnkerTn7JOW735qyGE55df829Wslb1w/4MbrO9x8ekL/Ys1QFbbGJySPLQqJ5hQDSqtCWS7I1iVv/YrOziDm6Hmf87tX2B46hDd1npimyH68rI75wsZtvrx7g2+/dMYfz59jv/+ccFmgPyvILIM2UOmbcjZz8W88p5Vay611xy3UbCFWKCi2LEXlqFf/+MSEJ+uEdw5jNswQLShJyxLrR7V9qm4wU3OsusXRbQLbpigbPrxYk55EZPM1T68YvP7yAXd2NlHkG8lT4jjiB3c/5Dv3njKb0qlqtd5SpRWN4E2dlFo3aKsQRSwYak1TOWhRj0bTaasTrB0dXTExfY3Nfs3Gy0KebFFqye+Mqcw162mNaogVRuxAKzyplDS2QQlRNZW2lc9BZ3OSg6UiNRuGi1wpouJJnqtWaprSpBVFSiIRpfASSsxO4HzBb1DyhlayR1I4okUdqFFTe12UQWnll99l9VsjQRG4S6N1h2/Lsinle1NlW2108QJVsbBHJto4xdvoIWi99GlOedRSCAdAjrulbPZrsGsCwQjcnfPsacvKs9G0JcbGiEO1QQlga/cmZbwkXUy7/JU97PO5L73KzY0BCzlDpivOpiec3JVNekppryjXQacCt1qJUdWo+YhIn7E6bOh1h2Zxe/hYpcK8XmDoLYZjobZZ9/VrrYpQG+KkxNVj0m7rLod1rYNqOOLYEH9IVXR0UcXUsQ0LS7e7jl0RawLV7Gix6UbBUyuhsDP8dYCrCBSzoue3GKOU+opBENjcf7JC93wmzZDiLCT91g/5nt7n3o1HHLw14Ob+q2wMr7Ox7XUAygZ58pldy4Ooji+SQQqNKpBRHaUsWIYLonguCTpS3cIS3VIYBLVBVakU+QpVVEbPpBcMMAXEU6Xd9SSulThecb9Yc6C0TOxJF6/p3gTasntjE9bHsrngIs5RUhGvShZ5i90U3RsJSo4lfA+5PuWFThgfoU6ZiB1v3TVLGIrbuWeismDWNNhDg6GpEi9iJH3jOZs4bc1ZmBK2CXaZoOpaR0VWRyppnNEaHl5pdy+wmroEe5ehrmPkL9wSl3M5/33n0pVwOZdzOZfzkz9btsJHhcLewGTm2aRpwSDfonSESRVhnnhdHnpUZKzimKXTUsi9Cy33jIZ+UHGz9HDX4v50iPWCOi4wYg9nBK+9YcAClq2BvQ7wHR1XH7GqzjhWTXqhQqy53NgOuO/otEcZyd0WbRSQjHR6hcenf87gL915DcV5wg+PPB58EjLOGvZ+KSJSBmi2h68H1FnV2dhlEaQy7s4w3YZRotptS5V55BKBUCDLKnTVZhKMKYOUsJE4gSK3dui6iuWrHddKYN9tPkBVpUbwEx7NSsrVKc2FwftSa07Dl26Z3SLpmV7w1qDPxtYme+MZ9anO+h2XahCDalMKL+HcwBf3aLWm0HU8E2ZSUbiw0CU2YRUMG6Vb/tRqSym8LTlhDCqqJCae12Qq2H2FnZ7Dlm8zL3SeXEwp84aXJ8JoE3OuR5nOsYhxTJ+Taspu7GOYNnEyp4lNxtoGv/jzbRdZ//hPTHa0Q/raJq2r4JkZ164PeWVXR5mmzNI+Wn/IL7yhMqgNHk8Nnn4zopdm7DkFe4OWYMNiXmos4wZrJDw3h2JVk0QRW7qKFvo8WnpkVc5Xrh5yvFR4ejpn3AvYdCf43pBnzjkUO5w8MpiGF9zZNakCqYB8jaK/6JrTdDa4r/0Qw76KunVI33H5zBWTu9U1TDmjqDD2AsSSPm8bJNC74U+wLBejMjEkIt4dk1sKTeo+y65UQNV1tEKc5VJxKQKU6Al6F7UXml6kLRlo2100QkSKWDllPVty/NDiX3/vAccPBax/zCMv4ns/POOv/doXefPLm7x9ZbM7z/TcgI/XBelFRdUf4VRrarMPvZqeaTO5WrPWVJ59subsWw9YjobcOwz5beWY43Kbzys3+YujbV6/dpUv7B/w+ZcOONmfc/faMcffecxq+pSzU5NsaTLsr1DnEvlXMHZ9VoVCfDBFP9/AClZQ2yRr98cnJtwITOqtfca2ZH9y8rIAoZBK1EAuWNuhpwtkz0DzLdbnMx4erWjnNetlysZrHrdv9vA9k0oAiG1BOI+4d3fKvY+nVNJbWitd3YrmmuStkEJVnKJPbU4ppAZEEdqk03W/2hMfdzBi8lrAaCgKiokj9Ytlj+l8hquX3L4Zcd7qpO/kVIZJO5PMUEClZ6iGZFjMFyKDAE4EaCdcAPllZpRVQ5VI5YrTxRdku67Vko+RvLyQBQVOUaNpzgvwotQjZiVG7aK7AXE9Q6uF37CkLTSqqkX1aoyu91YaEgTC15MVPWVrYWZrslhqMELyVsOUWsZdF+/ARxVeQlnhqxqhuUUcie1KqLHydaa0VYKh1bieyMJBV88oB0gzj3G++zHf1dYUry0YWi2vHdQcO5vs3L7N3/qp25jyc8tytFnMb35wzMW9BYqR0nhz1CalLQY0qkdSHGIqQ2zVI54fk9sabrPHgT5FU66QlQarMGHD1DGFzyD4BD3DqHXqvCSVyIMrEQeFPGuo3FzyD1iCuBSHiJi3lIZKqjcVcfs32LaLPZgwcPuslBmp9Yz9VzawSod7T2Mez2puJxYzJcfx+wT7MMYmHvRpS5XeTsvqxKJapRw/PudZ+JB3ejOuXjnn7c9dZzJ0mHh9fNehbTyqIqUoBUCod/2s4loos5R5NIcyw9OFtfECyimPp5lXqKVKUYpNyMAOVExP4JLmC0dGLTa1mnkSk6Y1F25DG68ZlWOscU02L4hVodnqrOoQU3pfNUjrGq8Dg8hlaZFGNpWSM3BNWiEJC5tC+AueTZvtkJQrFK3AFviIUuEHPjvbFpZiUWUO46qg31PQagtvpZIVNZrpEGCQ5CEn8xmeCG0MqNKWxE6I1ibeXoHwTbUfdexezuVczuVczuVczp+9WchSKbMIpgfMvSmD2GGuFzgzsc8rqKXOUlVohwoXT3R6VkbgBRhDi21FJ1i2neMyLFPOdbmnUnCSgEWUs1ZjtnfH7G0HeJqKHbYEBKTzNSeZgRzpNLdkR9lh+JJKNcg5tHaJPpii1gqf2rLZeWOPt68beIHDnzzo8bt/ckRVrAhmeygHDnfuTLHaAqdxO+u6qwWEw2O0ekxZlViq0zlSZTTFxBZ+liIRWR/DNjAlKptrlGqDY7gotsu6jUkMGChDMnLidcp37h7zwYlK39YwsoKnuoedFogpeMuZMT/fIn9L5dqNgMFej9je5G/eWfAPf/uc5GnD9e2aoo6pkiHVWJyzGqvDGrNXkneOhpjJpkFjWpQSd1YbLGn7QqMs1C7G6xk217Yg81tScS9HMc/XCf/mySn3HpfcGni8dXWfvS1prch55+GUk3fXfOENn3QcU88CXFfc1San4RHX6quo9pC/8Ot7/MPvKJytaq7ZI+qRysFgG3tgc77aYHaUMbzpsjPq49zsccOtuTNV+Tgp+e7xU95fhmzEc3bVlKFiovo2w0DawlyyKkO34UDa98pKUufUnsbcuMm79zMmuoJj2/SDLS6Wa+ZLjzQLcdanROo+b920iTSPIE9o45bG3UQzVIxmj5tXXB4Z25Rqj8FVjbe9Iag98rzAxWARTkVFYjR06PUEEi8Vk+qLaLTA/suKSi2QPbOISFmTd/frEmlQW4G7t92/90y34yP4kUVhlF2M21Rd0npG9nCDsj7hla+8jf/aEeXZKc/+lc7p+w2/uX2Plzb3uT30SbwDnoZP+MNnGuXYYuRcw1q8z+KwQR/1eePNPrc+dcYyvEo0lTNmxvTojMffTjEXLXc45ok15X/vb/JTN8/4ta9e4dNvXuOV8Q1e+cwNpp+6yfunH/Heh3O+fz9hfrhgeF/BrmsGdU6VD3A3SuK1T1Qm9AY+dZfh/zGJCVumy41rLpFkrtOSieFzmq6pybF1l6u6QWqoFLbRZTk+mKccn69p84jaybky9hn5Q7K6IY8K0mrNxXrJ6bIkXhVd3kRXfNoq63442M2LGIGX0pYOSt6iBw3NKsHZheFOhjXZ48p1n5e3FpzmAsZr2MhWhP2EZ8WE3e2qyxqdP44JpxFVucI0tjvKv6YsUeXJUglIY4Vm+V1lI0VIo+YYlotiNJKqQmmV7qArEQUkU5MKbFJgAEFHTa1ZUmF2IBPNlgsow7A3aNJl13RQqQGqOaB1D1GSHlrrUhQZqmOhWQJGmULjdz2xkt0qm4oiF4FCIRhIG2VEkpdYg0GXyzLPQyKrJoyhXugY0tcqiqqjoxjS4arTZgJ1ibn7/oKPTxacz1v+3S/fYf/mgINrDm9+7lPsDoZEbYVb1WhRygcfLqjXU6yJWOXle9NJDQ+tXVJkQ1L1EE0do+kxda5QRgrHaYzdX7AVjGmanKxaUXZsDakG1VFim7oZEMmmPS3QFUF1CgOgJhZXhyGVPMLjbFGk8UCXak5pRiggatHkzyUPlA95NR/R68VkToh1bcYnoUH6eM0q00kvWh4ZMWMjxhhsovlnjJsJeBWhkFCXA7RFRTo95+njnGfTJwz2Brz90j63t7YZB5vYhoEm1T6K1tnhpG3jJA1ZLyImEmFwoCykI7imUkN0EZzyHpo1pD80GDkuauu+EFIaiVilzOKIi6rlYHuIUmU8z+EkXjJmTdD6KKWwGXJ0fRPbFdBkhtaKY0Jh1SSs1wlaMqY3Vun5Um8acBa2xPGMMms6bkh/18X0fAwR86IURW0piqYjygrg1Hctykq+DgVDK5mMFKztDdR5wXufVF3DiB4opJaGVSYIs7GyM3byIYmwfNr1n+4u5HL+TM6lK+FyLudyLud/GHNuNWwv4EJbszR1BrLAOnsR4VzqNXvikIxg4Bjk46o7ZCeNgmolTEIV1TWZDxRMQ8crG2ZRRpr0UVodfSFb3xZ91OBbNqf9mLhO8WYv7NW+BzYuVaHDpOaq32d5GJH5BRvX9vgbX93AGe/gj3za+gEfHGskDz0mW2ecBAYPznJee63EybZIlJiyyKmNEtptcgFq603nOJWDo6pIjLTsotKqLHEGbtdON8uPaOMSRfO7iKpA5MXunui5YNm4P50xvRfyvYdn+G6AGmnMew16HGM3HidnBb+7cc7N117nV77csGO0FM0malhQjzV+6mdu8nd/9z795JR6ucJ0Ao5PoTcaMTZS4jyjMiw2N1V2d0akack0DGl6KkG/h9XWnJ+WnJy0+AMY7nrs1B5xWPLw5IwPH625d5RRtSXTHD5+tOBTLzVMy4yPlxUnjxxeurbkIBjjTVwBfXWQ8nHq8WR9n1vm64w3dvgf/+Ut/s/vOJSHp7z5tolp7VKvVzybaTQbN9m6scUbLzvcGDh8nFYkdsXqiwa/Uva5mM/5o999xvG7U4aDijt3bN64bZJXFWGpMPH7OGrD8+mUxiy4dX2b5cojTp7yyg2zA/wvwxnff/yIR3OD0d4JPxNssTGqKQqPcpkSB2uCYkDr6ZR2wmg+4tksZLVo+XjrkKIcMyxV1EHL2NyEIifPPTy9IvAn1ILPK7OOsyY/A+EgiEtFuBiWOKdLs9vii1tdYJgiOjRVQ9Hk2K5NKotphGWWyLGOPC1Rkl0+aY8Y7X2GX/iSy1H4Kt9qP6JXPuXZ/WuM5vDBs0OubTZc3+zz4ETBWHmoUY0yaogNt2sZbEQs2iopezvMD3PqWYPWVzhcaxxe1GShgd6TKHhDM035MHpAL27oCVvwp0y2PJ8tfYeN/SG3tkNGn4n4zr0jVl//hPXDY5xjDdfIEY/GUA9ZLK+z1mKaG+//+MSEs+UJgeUTKbJl1bAtB+KWxWoFvsK2/LA9jw1bh2TFkx8e0hzOwVzgD3rs9gbolUoehywkk1P6LJKcOEu7LIpmOLSmgO1ClFwqT6QxoaLIWmx1g9JcdIBEqaTZvDFg86aLGfgMpf9SN0mXLXHpszWoeMudMlk71L0MPSmo5eC/UjBwKKWDs5HqvhXtWjL8JZbWYVZQ2oDWKGiqHEMRO7mBa9kYttX1uob5mroV8Ils0lOoWlo57LYGRm5J2oFGiWmSFFtxhMsnRvxO7dSqFc3aJ5PqzNKjLOdoruTGfCpjSc2622hLVakYGhQRZ4oSwQxoK6knkdrCtrMVqWJDtzV0syGWpI4tDQ4aZRKihBFaW0q9KIqWohcKdjHkam+Eo/j8zif3CdcRW9s3u6jDTUfjWbzmw7v3qI6eo9lTbE/ALWYH49AFpNgscdgjCdbkF3XXLmF6fZr1BTNDxUxWGImNs+myXGvoSotryhNMJWFN0Whdh23tavQsj6FEI6SwphR7kDQqdIUEYEhXb9UJKrWuk1TivChR1RyzsjBDl6pxKX2Nm+YNNrZtPlQ+oZrKNWSSLwOKwsc3asxRS2FMcK887nqC2+MBtYhUNZhRRfv4iOTZU37r8REfjvq8fv0mt/Z32djuo7iyszcp64izdElSxQRKipIbmKVJ1UZkRUqUtBRRzYY7oNffwrJMciOlSkQuqYnSkPOF2NZ0RuM+Q3nhyio+ep4wPykZ1EkHxsz7cZc7sy2VxSKnNYQcKxa6HM9RO2WzJ1BLYqZhTD5TSEMhz5YdlLQ/nmBPVHw7xQk9VgJ9XGad66Q0ok7wK4oXCnZ/x8Tes/A9jYgVCTaBMUS/kmHObEaGNC0vmZUjQq8hSBrW0+M/3V3I5VzO5VzO5VzO5fzETlFOeVYNuNASrk3bbqHlVS2Hg4KXwk10CVcPVyiKwc62wVmi4Yh7d113sMa2s5zWpHaDtTLorzMUM0U3A1axhpXXxGHIbFlTr01yK0ExbKxcJTemOOZG196mVRX7d/eYOcdsvf46t77SEIyuMItOSQ9mBA9Lsou447ctahO9B28MRl2uXWobe1ZFStVVvUs0oTsEtjaao4kC3kWWKwrUokE1D7GleSsdUsRyv9pg2RW5IUDFhnGxLUYBnjxc8K3vLqnSjKFj4UlDhFmTZtIIkFAsHJLM4C++fp2//fPXKHotTahidM13Oq4S8PbPjXiURXzze0/ZKDfZSmNGV3TCuUe+pWGuMq6MWhxVJ4lj5olAxV0cs6YvTWdhymIV8/14ThjmvDz1GfsNT+uMe4+gOE3xWhNrvIHCBX/8g2dcrCsWmsIsEyA93Hua87POy9ieS5ZnnYASGC5aozKbnbChHuC9Av8jx+M//0cOd84aFlML42qP3Rsb7L20zZsbHrZjUuoO81LlupPz6c9b/HFacn1pQqLzR78XYBoRtrQqZCqzPKVRbbS64HyZUKYpd24OaZqUxbqmLlaU+pgsirrv8cHplDD3Ma0GQW3E0xVxpOIXS3rmqxRuhtvWrLM1tTXl3icNZ4NnNPd2WC1LdvsFPx/cYej1CQmp1fNueapqJkWZUklTnRV0W8FK2j8UjWE7gVJa4Mou+lALyF3OjVI7X8vlZXSuFfncQa2RFxZO4RAXEdPzhKeLK/yNX/RZG2O2tyL+iv4Zdv+z1/lP/s47DI5qer2ccd9nbj7gX71/xio/Q9N2aEyBZo4I9JaZ46DeAksA9gkUtkptNlwkFfW1DH+jhzLVqRdJhxKgqJnPjvjBn6w4cm5x/a0NRsY2A3RGisHf3rzCv7c5YvGWx3ce1Tz8QGe5jjm9O2B4JG2NIUVo8FJ158cnJni5TtKkGK3CwNBIygRbrE2WQ1OVhCj0WsmhFzw6WzJ/mlIcRqQDeO2Wy43xkFJLWBQzpmtQvYysPqPtakz6lE2DJpUn7QQ5zrRyGja0zpWQ6Cu0WuuAkoP9KwwObPBzFHNO0thc1BvoLEgXLR9oOlf9Cb1hhduo/Pa9Y4rnhcTOu1oUzVgKpJMmcTqqqzgiFK0v6E2opIcw60iejZ6SVx6tWnQ1Ia4z6FTXJGpJpYZQlE1RFE15ooklXRpWTeqsobZdlFqqJGU7L9B82SCr5O2UoN5F9VQsZ4BZ61iNRpwvqZoJljQ8WC6uRB6SljhaESfyIl1j2SPUdk5VSGeoRAN0lEKe/jO0/gBT4hsrpXsRpWxQYoNG+huHBb0DhUxZ8c/f+S7/+rfvk88XvHtU8dO/+mX+yq7Pd5/c5f/x336D9JmGvd3i+gOiWYS2qXS1jn0+RRw8wmwCrOGQ1rRRiagyEVQSCgxO1wm+DpubDopZk5Qm9VogiilWz0QzdfR8QFaURHaCbqs0bdtllHxd6/5cLEkvbGZa93go5osqE+nTjQNhVjQU4Rol8ymsK3iDli9t32G6mVOoBZ88PKa8KFinEUrmdDwJpW9jqWtKa4Gz56LWBtljg2LWx41PsR7OePzhnKfv5Tx49ZAvfmWPGzdexTI0TsM5UTLDNqQzV+9YD4qASYSrUdgoBRRpwnkVo5ordnUXUxerWclFlfFkuuasWHN9Z4irqVhBwDV9ibXj8Njb5cGjM8z4lANFNPE50ShhXStkmQAuS0aeQdgfdRGLxi6ITiNWy5TpIqLUXMy+h51n1HnIOm87S+HmYEi9XLLI5qSWRd8OsE2JlAiDQkSEgKFY4lIFTb/F51+ad5yLjd0d7ioFyTxmENgs1gmmtkZngHpx8Ke9D7mcn/Dp2kv+e8ylK+FyLudyLud/ONNr9S6CsCp2UIv7LJMJjlOz4fhYcU6z4ZP2bYoLjSuqxS2rIZR77KYiaixm9pLxEvS11DkahPYApZexladSgkahNkSxwUqarlKVNIAT75zxoz5jxySUGvjSZKApbO/G/Frr8XinZfeKcMZqitZkdDjk+++c8nR6F//6Luauivs44YNUxcsC3ugbZNUprjnpnNBRvsLo7r9aGq3ClDrDsqKv9ynDOXmpdpXiqgD63B6mMcewC1Rlp3tPzLSce0eHfO/rR5ykLT3ZF6UCedcp9IZ226KMPJbKkKBN+elXX8P1HZBFoBfRKwVaXrPR9siCgr/165/ipesLfvMfNzB6JGWNJNq8a/dqMo84V8iiF1WOfTPFGdjdOSI5C3m/8jl9yeWLf6EiTgy+/07EB3efkZ5ckJ/mlOuEwlfB28denlOofS4OZTnZMhm0lEnFux8u2B74vHnjJVzbQzHc7vc3+/uk0YpovaC5ZbLnqXzxS3t87dszvvKaRXtnj6/sb7A/Urj7vGboyXVRcU1pCbQBiuPyU05K5lc0XxoSD0z86BgnaXh2XpIaVQejPw9DHj6ZYbY5O/s+Z9MZ51ObYVvRtArLpGK1lqjBCKs6Zqfc5tHZnEWUMdCmfO7L18h5F5Nd1Gc9jh/FjPUeuX2PYGZy73yOWc9Z8inOigJnULBIlyhyf147nRPBNj0Su6GSo4hadE4OiVZ3bW+tLEtf8C8k4mAp4ryuKPWGTKvwC4sg9amqAtO2Ogd6HBWcfOJxcG2AO+ohOMArscvxZtWJaRenCr+8VRMMVILJGf9w5XL0zgIlNCiZowWn1KHKYmXjvKrzlf0+jh3zvDbQdI9FUjCtNQ5e3eD2LYPmxOHoWcXD50dMjxJmucsym/Hw68f8EzZ5efsKX6g3edk22dsaYegDXPMVfvbVl/j0KzHfq2IeHD/i9B88Ql0q7MwTPrz4McYcpvmSA3eL80p27cI0aPDQqawaV3WJpfZE01itF3zt7kPi5YKqbVGcA0bBJq1EfVSP/d41qnLJxeIJF6crslTpDoJ6EwnphFYq79yCJvGxRPExMvI4Ii9UBkOf4Q0Vf2yTlhV5q6IlAgy0CRSLvUFJYYqLQFwNCUepzfH3deqlDp6O6ViUOFTKEkMOSWpD1YaoxRhNLo9apSwM+iMF1e91oJUsydHEjz+MsX0T19joekfj0mHZLsQ8QSPNFJV0kZYYqoHeXKCUPUylJZFDsiqcCJ82bFHEQl5MwS8opAUibKlyDavfe1FvEomgsqIQqGQtzoUWaxR3h+26kIx+Ti3Z+gqKrCCvHBR1iRMlGK2HIRCSoiJWwXI9XnttxI19IdA2PPj+fdSHC3qqQvO1d/jdj77Db7l6V6tphz69wT51/JxF3e8OqOpiiDMwUPI1bc/EDj0sq4fpQKH00fQIIhu1bcjicypFw3f30YYJ6yVU05zWLXHDHGcwoT/p0IYUecOqzcibGs+16Fs9jA6AU9LIm4KofVWLJvESQxwlKmoqpoKCVhO0aNlt5Y1Cw40DtsdBJ0K4V3ucBOd8vPi4i51sNPdprG1CsT4tUhQrxjdc1OsjlJ5Knljos4ydlUc5q1jdP+L5Tsr2wMN01yyjI6pqwQiPps2YJjO0hdU5CJyehjq0WFdrnoZzzs9KsqbH5qZG39mkzKacLaHfuXI2MBxp15W637irnfyMBfqg5CPDRFV9Qp53laL77qhT+KdZDG2fkVTC6Cmab5MENpQJZqliqAqOLm4ai3mdUy8hNcUSJ/VHBUlao7lSlaqjqsMXHbnNklVYcnq3zzDLaZJjVH+TrX0bijVOmnEcn+L19tnyRDip0VZwvFr8ae9DLudyLudyLudyLucndLJPhqjXTT5tL3lyeKWzzx+/rvPTiceFERIpKVae4RpXOAsv2DR6TDcithKPQg6/iU6btBy5MVbTp5/7ssrjtCl5Vif0zJJBMyLVbPqVyVbpsjxaUcrfm0iqXmHWJhyfTRhcT+j7BjeFvj/aZMMYo+ULvv/gIV//xEUtbMbDQ+bPXsfUK+4+W2KZPTY+/Ufs9v8cqtInytdd5FZs7Ea3hZaotDCztI5oX7gWbbNPnJVoxpq+P0bXZdkpd5c6ddRyfHbB3fdXzNqGYD9hPXNYX4RMvZZA2t1CiRvrlPEZraHwz4+PGGUmvc8beJb1I3ZbRd04WEaLt2ny01tvcu/rj7iIArzKRwme4Om7VEMbQ48YbpX0/F4H/9aqhvSo5rumhfm5a/z7b1zny5uDzk2w/NKaDz6+y8N7T3ie1fzgScTJ/WPyatFFO+rzkEzZJrjIOTpaomsqWTDk607J68MU2/bYTTZY6XN8JyArEi4u5qhbJlvG6/zGFwreK2Kuf05ndGeTHb/iyTP4zX9zxN/8ijRubJPLElVRKJslsVStNyZf3uuzueGwmps8uRczf7zCzDXMomU6r0iThoMdhfNoznlSE+srNg7G1IpBqjYYrcrC9VDKjIfrR4zdW6j2jA+mRzw8ecxfPP45Zlcf8cE7Hk9nK77seQwGCvckkqO0bLY6jw/X+K+KI3yAJbHquEWT6IqcjYQdkNtYpo5aGcR51AlNmiLQ9BfAfUloq10cu0GTq0g1X8Qh8qQ7i3QwdCWBJGc2TXleDviPf86nsQX2Lo4XlQkl3/vBFPVsyv6bLmdXppimw+Ov3UONNWx/h0r/hLTdZ+9WTnrW5+WfsXht5ykP729TR9udSyY6yVlN1xilwUe6wWigcv31HvVgC61acOWKyu7ru0yOU177Wkp28CF384c8MAO+clvHH+zxzPC4Elxjo2/wa+YWf/HagA//05v8Tqny3eknrP7+yY9PTCgHHtJs6UhOpCnJixSlbSnLprNa66o4CxLuLg45fHoMFxWZXXJwzeXVGzsMNyyURmVgGwSGwvtHDQ8+iUkuEuw6pzUzNGy0SqMq7O6BcqwatfWoJD9v2rjmFmo/IlF7jAMbE4c0XtI4J8ylm8RM2e07rHOVJ8ct5/dPKVY2Eo2CObVSYDditxqj1NLSUHRAGaGlYreUho0RqGzubXQ5+Ktu3dloZrFs4qU0IWEVSe2Hi9NaaKbZdX9GWUpZZbSpSl1kKFpDpUrdZItZGSjFBZolsMFtIuUYVepD8k2qOKYy56i+QhGdI+hV0x+gFh5GotEsNeykwRxXHaymKQfYVkNtKCTLiDg7p8mE6WASqfJiW2OYanfYVyYGN16+yr//13+eW5MB/+R3vsUfrO6/+NwjA80c46/m1KmHZvagr1Lmj1Fqm6wq0LVNmnRObYxI/ASvdMlauv5XzYkJJhPy2qdct8yP59SzF1dTJgqh4hAmGaEcQkNTXFxY63OsbEowKLvak7Hr4HolPcvCNBSiLOlYCYHjYJUtZV1QWNJYoaJIVajUcVYVhueRlyVaI13BJqtVipI6DAObveAWB/t9Nkcl53pCEVocHTWESUC+XJMuNap+S70T4Uxa9KKPO9Y6VVcxM9y6xTgymfvvk22McBBqrQnGmsPFER8/LDFzj51t2FIdPE1nd2eLzf2AfXmjkeoeJaMuBfNrsNVX2Pfk56tipG1nu5qvhQK84DzS0H2dV0qH8dBkrVzBNg08UeSJsfUYvbKIs4Ra8enZLoNeTBwlmL0+jqWjjGpMv2C/8Hi21kgkuNAuCLOaaClgzwWxI2KEfAsKTuR3dUJSSxpjsoykGUSAkDOW5S5RssQzDcJFgS/uEcUl26pwko0/5W3I5fxZmp9kV8L/y4Hxk/w9XM7lXM7l/Ljn2Igpq2dcs3ewdhNeV3bpO6eobJMOj7iy3sIwxzz3liy2c/yLZRdbXiRDolVJpKZsOj6j1qXnqihuyiqpKZYRG01Jv+oRtSoDw+Ngp8HpmzQpmDsFU4GSL0tkqR+PHM7Oa/a3TEzbxbqmEj1OWZ5t8t1HC7biY8IbN0jMexRnLdoBDBYGH38Us93bwL9dYagLonqBowWYuocmTWTCCGgqNFVM7Bq5rK+MHFuVO8GQul2Q2gqJsaQ4jrh/d8HzwwXLc4e41elVAg2vKGR5UypUlk4xT/HjqHM/t72Cb/yd77K5V/MLt97gmrRABC3LJsZs+1j6ille8HF4hrN1yOCkJSvgqrfFeMvqeAF5ZrHR36JtEoFykZ/AHwzhtZ/d52+9POoA3+/fn+JqNrWpsY5NlN4NPv2azhuf10jqgsmyZV2s+c7pfX7neE3+LzK005ho7yH2xls8+fYFd6sl+ztXKFMN9w2LKkopyzXLh2N21YL45gqt6fHqL/bYflljoDV88mDN737jAb/UHhOeePwT/XN80dtld+RjSqtcrbDIBNCuc1X4YnsKTtZytKpYHqWs7yU8XybsXVe5+qkJVRZSrjfJg4LN6zXxUqHoF1RHa7TcZtu70S2aHRcukhn75iYfvjflv3r0Q4I9hzkVn7nS0FQRx6cOcWwzmkyxM590umB8Lk5eFd10SfR+VwlpmAqWaaLbUosuWHgdxxIxLO9+/lqtdo1v4kwo6hSlVNF04dyVxFXYnRmEo6Fj4BUNp+slZ88cgs9u0+5J85vCVqZRbjToy5b/3d875Ks3C+xbe+wOV0wPX+bkg6do7hVstyWqb9OfGSi2Tank/PJBSh2PSKY2ppaQFCmHz0qOH4fcyyqURz32btRcHctZYdWJU7vXIW0LSn+EYUZdNNs8LbDLC+5+L2Ouz/m+k2Fce51bd8b87dev0w9sXguu8qas2Uc9Lv6XUhX5YxITrqkBtqVzFgtlM2XSOizVjKJuiB0YGR7las7dT6bYFzmLNqYYKbz0Wsv+ftlZiurCAV0aO9ecT+dcnKtUlQHmGl01MN1t7KqgiVdUVg9NX2OrOllSks4NajPv6jqUpiU0LvCUHkXtUK9bkvwM3TLRylOiWiU5yrn4YApz6Qm1sGWhnUlu36eNIgjkkCUAliGqIjEI4QyojMYetu8y2bK5c3ODXl/hk/sxD+7PQKnZHGzQViZi7o8deYInWEUf4cDGZxKSaFG1Er0RRS6iiSUzb2LkLnmh0eoC7zvF1vtonlSZOuRNSW3nKOumcxoYtophGOSlwunigt3xyyj9hKIuZLVNrlY0Zo1uuFR5i5quO4gelrgULNEwOmEmUX0OlZYrsrnOU5JMw1bFBSBVPgZKb4u6v8TQdapYvu4NsGZ4aY+VCCC6gpnqJGsonQWW/3LXHGH19mnNstu4HynnaBcDvGGNoiqowTWW3oosK2lMB00O1mVCWfbI1jVL22GhVeSTBQf2GHfi09QZURp14EkHDddxukqWtGnQA3lMS7KqRCtb8rLCsIzObpRWDaUeYZQmxSrvOBTNCvbKz7K1U7MIzhlOZnygzciXKXXbp16WVNURK2PQ0YHtkYIn3I2hxfRhzdHxOVeSJa8eKFzbuUkvKDhennDvQcLzhwW6qPGHKpNra3b9ik+/9AZvfuYtxht9ztbHPHr4hGJZM6+CzrYkjpWj0xNKx6LnepgSiSmcDqTZFxComWDnYKQVbQrnVU5kwU4+IAp0ekqfyiiZZRHlOuze4gaTEVpgogxyNod6Vw80mKZMZ70OmGNaJbZldI/BYpFQFusOzjPubdDksLqI2TRHbF4JWJkxjT5my61IrqScntb0z3OMPZ3+sE9vaJBJme7lXM6fobkUFS7nci7ncv4/8/Zgk7zZpT4rCHwTrVmTuiqzcIkvSzBD4flkxeJRjzMtYc8c8tJ8l/MnBmnTZ8erMA2Xwi9oq5oybFklDUo5xndq7KBkKAwwReFQB6eZ87I5pLAM9iqTRXVBnOZ8+nr+ok1LVxg4Q/T1lH/xzke8970K/arN2p9hmCZhosPglKrU0AqTuo346MOGnvaMqwcpTaDjtb0uShDWjzDqAYrq42jiAFAIDB+rtrslqC5tA0pMGycskoQ/+P4jPvxWjRbIPfKCZLHi4ryPbiTolkZRufhxgb45Z/3MQL2mUp2fkt/T+M33XXp/eQPe3uQtz6MV14E2J3685O8/P+P46D3U5zo3bipobsxJu0tZLdi0fYaujSWNZScLjh73+OTVIZ/5lQ1+fXuI+jTi7/721/hv/tHXSeWMc8vC0B28wZA7L93kLxy8gjHw+ciwUXyPr376S/zq5x2efXnKu/94xeq1ObPsAe+vTvjPn6T04pAvbh7zxW9/jtW9mOqlc55kGoEek61N5k3F5/8S9HWT3/2jC+q77/E3N6aE5pD/+z/PeP2Nj5i9HnO+2mN/P2WvN2JDs0jKiBMKTAW2R31+8bbGD4KCr0UNTpJzayci01UuHps8eDpl6yWXfOXyrQcl4zplebzEbwy2X9kkX/ucDE2avOKG5+E+iHltnDMJdf7V+BhX2eDJ/BHTohFqP8O4T6yqXLnWULYRh4cFE3+T2m4Z9fe6lg5N0ynVonMfiItAxtYsmh/9b5ESJA5hqS6FKueJkratMRsb07HRFaNzKaiGjupqqLcCfva2xaR0iCQaLdeMkfGdD1KGTws2fvYRjfUSt5jzdy9+QP58h6Fd4dxY4bQ2q+UxTx5b3PlqQW97h+fzPqqpoWg5q0XNei217gp9z6NIM6YfJMQDH3SXV18a0vOczhGUJKe0qQ7DAcbgFNWsCMOGP/ow5/y9JcTf4vlrI976z87Z275G/2DCpjdGZ8JkOPrxiQlqrjJrI4Zi7xE6gGcSpAqVqeLrBgoVh8uIx09CyqUcjk2u39rhzf0rWPZGl/UXXMUivuCT06ecxAVFoaLVYse20esaJcu6ihnL6GNvGnI2JjnNiFMNpQgI9Yh65rI90nCaCa102/aHUPSo9Rkn9+e8exrhlAJaOYUTh2a9xt0YdjDFNU+R5EfZG6MqZ9R5v3NbCOWwKqLOctQTq4t0yyYOh4clyjxnvkzJI+nOLTHMmO1+zmSg4zYOhSYHXZ2q3cFUQ6I0JxOQTKairgvqTKOdFKhSPTN2UOoxRRmRx0s008fwK5x5j9rPyX2JLZyi2xq9aMRZnFEshR67xpGmibLsyiRyRYMmxKpyCgFe1gOMssTsW6i+h1LkmEpI+vSbfOtrTzjf8nl2usQcqSh12Yk3hfAItB6TKqWxc2L5d6WA//yOV7DVG5DUx+hWTn5yCoGQRReMX9O6A7jt6KSxyfrMwVZacr/CtkycPGI5X5HPU9o26aIPqilQmxitkjoViyw0uZ8vOLEyzvI+10cufTfAM3SqUmA7FarQdVtbmjM7x4LEPFrLoq7yLoMnT2ZdVbGbUZd3yuIYTbXQBArq5egPK7a2rnPgvsbu5B4fjh/z/CTm/GlGHFqoZwmlrlAsPAY7Q7SNiN1hxezE4MOnOfe+94RXt5fcvupxWuScn2bUVUphK2hJSvxBzGKYsrV9lTcNUSlnFOUCv9aJtIoynWG0Q1pHojM+vaSgzDN0z2AdSctDjlbnjHsaSpxgmBaKqdKrG0ZqiW2rpCKimDaaPJZHKrO1xnjsYO9kxMuGxdOcRdjieC1FqnNRl9Sx1JX6DLcVKCrOdal4MbBx8EZ6V/GSOQ2t02M8GWMHBoriU5o625NR545J4pK80dEcg/Msxvd2Lu+pLuf/r/lJ3uj//+JC/H//3k/y93c5l3M5l/NvOycHJ7ymbnMvSNhLfdLZnPO6wk1rtk8djvUQNYCrdszm6gpZpHGuLWn8lNaf4et90oOwi+qWD23ma5OMDG+YU/RsFE9hUumE2YrBQu2irE/6IcnCIhq3DH0VN6+lUZy94RUq9wMWyoAf/PaSP/jeIX3jBk6d0r+5R55vsrfOOLuRU7+/i3awZLCaEZ96fD0a8BYmv/zGa+gCStdrtHS7q+gOtIBKzUm157j6BKecdIfHXD0hKzKeHcJ7H9zl8Ycx6aKmV2REvks1yWCp4w1NdNfBkXr7J2uas4zK3YLVU7RySDCqWar3+Mf/qGE1+GlefellZsMjwlnIu998zvxb93jTUch2+uRZTM8Fx6tJNhYYrYZf9jh89wnfrRXqn9/if/LT23zR03j/e6f8H/9PX+Mbf3yXgTHiC/4+2onOYapxsdL59rcf8fs33oGRgn444fbmLq9+Wufutsfb22/yK//TCZp2m6z+LO2r8K9fveCPthQ+XBW8+7VjcD6BK4coj494+s4eT96PuP4XCrS/dotvn9ym//7X+dLBBdPc5Y+nLX/x9TFXXm85LU74B/8ixH3rgl+6ecDr2h5Bz2YsteSLmijWGG+7/OrtCfu7Hu++53XnyfwZHC8uWOawXS84yt9nujzgokqpDJf9QYGyqxCNYibLiqre5MP1nHnSJ/BLzu48oresOTzzmFoh60QheM9i/WZM02TcMF/hIAho9Bl1Vb2IsKgGhm12opihei9gnFnVuVSqpu5+Na1EUuquPc/UTUxTojA1dV12bX6mqlPK/1drzNZgy5+wEZR8z3S4RUZgBGReiNUY/G//Tc6vvTXj9tYvstkfU6YlD77tsrupkC/3aPyKoevQ3C1I9C3+o1+84MAd8f2yhzMSmpnG4vCYbCWtEjaGqXetJwKuz9c5/U2DvT2XkT8mLRJ0XSU057SlyWo6wb1q4P/GNfbjmtN//gnpv1pw0zzm4Tsh95QzPvXWS0SvaOz0Xqe2ZNE7/PGICYpRohhQ65XoNCzrFbqiMGkNfMslTua8f/cpTz4+5/B0yt6NEW+97rCzMUTVdMxGw0XnoqhZrWKqNO7cCtJSoCj1ix5L8wKnp6MbPRRhGoYGdVTi2fvUkxZNqxlkATvaOU5hEUUOyfqM8+ScyfYG7o7LMGxI759QL2106wUhP1EbcnuNnY0oswTdC6mFVWDk6E5Ok0nVo4mpNCyrvDsEu2XO4SwjPIrQUml9iNGtGsW4IGwN5us+ltmwNe6hWwrLacuZM8IJ12zPYdXPyPTbTJ+fgtjE+zlFLSBJFVf5DKWVoGlLVAa0VweYywck6zF9t6GUtgGtxFTUrilgd8PnTPpslR49Xez9CYWusVIEHqm8QBaabUeoFYq/W9udY+EivODBH+Z8a8Ng4qrs7QfUAVTVhKjyIF+QuRV2XmCKsyQRQm0flJTWqTAVAfz5DF7dh+o+mXabSVKwcTBhmmc8X89R2zVOT0UT10VdsiieM1suSRMwLQ9DccjTU1DX2I3RCQWaDVYO+ccz7j4+4vTqhNsHV7izMcAfehR2Q/j/ZO9PYG1L0/M87FnzvPa8z3zHurfmqq4udje7m81uiqSkaLBoSbERyQ5sIIplyAlgwEBsAwkcIDACG0kgx3YSywhsyopiRZZEiQolUiS7OfTcXV3TreHO98x73mueV/CvUgLbsQMn7EDN5vkKhULdqnPPufusvc763+99n7eokaoUpxLlnAqmplBJEZUid24YuWo7mGJt66h1i6zWZFqLJYA/hUJklBSzJV5PAD5tPjW4y6uexZP9E86XGbOHD1mFEUmhUJ1sMSb76Ic1dz6dcHRQ8eDdmI+e5FTZgGZgEacWeVxieALWktFEKlmY8eHTB7jfU7D8hjpVcOoKT/W5OxoSVB6L+JIk0cj9isMcrNLoxLhFlOGOUtJ5D2lUU7YFilzQN/o4+MydHPkiZZsmXV1RWGroco5hCKUc1LLunEBRIKJDBuFmznZVMfAs8EpEg9Kkr6FPm+4Ha7/S8XoG2bahYUNbiTBFiNcX0M+wiz1kTcOR13JyWBNKGW5co0mXnAoS0tVczdX8V8SFK2Hhaq7mav6gjL7V+d7dU145PuLx+Ji+2NhvM9xsxLm04HTdY5SE7Ax8zjMBXwwp6yUTxUYJ+mSaTr0y2PQLml6FJ/vc7sVMLLG9MzhTAh7vpehBg3s8oUpspPQESoVqqTCXF9jlBPm5Y5x8yuNLj6eLLT/45inPyxWz6znxA4/lz76H/s19ImVCvTaZjh6TaSPK/T7STsvqXOFbecPrxQ+Y+rcE9gtfGXSQPdEqZiAekl+krmrieo6kqF3k4Tcezvjt3w5pVwFOkzIWOy1/F72v4SxEvX1Cs24oWgVJrlBejZC+5mJYJZtHMLgtIU0VeFiy+lbMbx5+g8/9NPzlwcesf+OcX9iEvNy38J4bUlQbzlIb2Wnox8cczn3SMuHd7z3i62uDz/+lu/y5Lx/RlDK/8bfn/JX//d/jG/c/ZMcfEw0lvrEDvbFgNjRUgcbYGTBKfeoLmXa5pnp8yi9/NAcl5x3zd/hrn93j7uhl/vTQ4puDl/hPrDdoG5/Ckxn+QoP8CwktG2bnNX8pfEr9i29zc1rz53WFpQAS3oj4+MNr/GfbDX/4izfhlsy5ZndMs3/mc5c8nq/55l8puefPeePzE+48N0ISC1JVgsZAbTReOyjppTon5xFNHfPcrUM065JEtGFkN5mWIR9tQl7ZGWPvjcmUklFic2qkeMcjgkamtY/5WjnliAG7skVYFJjzIwZiU39H4+nvLml2HAZ/KGA0Eq70AxRR7djUpE3cQScTZ46amuSKuOob3KKH3AhOgty15IkGh1priZUEK7c7V0LdNt15OC1ySr0iN0ocwWJr4LkbJfceBvwHeci/PLXYayoe1Bq3Vytuj3so/QbFf8I3v3edR98MeW3HI7g9x3UFU0Thch1z+xdmTHds7uUtg9hjrFodp/69syXzcw17kKHJMm02RjO2lHbF4aHEyzsFbVOhti1K51z3CJYKUTGm8Pf55w7u8M/JEF2/w7M/8l3+r7/WsCvNCZyCJ7/7Te5/PUC//Yz6DYl/6fW7PxwxIUxCXLNPmbcUVUYqNZ04YA09JFPn5MGSb3x4yvLJBnu/x8+9cZ1Xjm6AOuhiCZrYHjc5a2F/L308NUG1M6pKqEAakuFRNQ6OKWE4GnEhE4W7qJU4gK8pPRXzmoVyw+dppBItQ05/95hW1egfSIzv2rx2ZDH3NzzQDML3PNqLZ6gHI9QipipCUIX6lmKU+5RagSmVFGFI29rYrYNcZCzOW3acHgcjia2AO24MCtnvSKNataRIbbLKpq0z0TLIRQ+svowlaJpun3NTIXOGuMkCx2wxmlvkUk1cLWDSUp1bIHgL2rxrrGga0VixoMlHaHVMLU+E3kRZzzvKayPv8obv87jd4URas1gtSZZQxBay6MHd1LReieJpaG2MokUoSo9EKmjTnF5eoecmkmqgGgXmbXHBFZhJTh7btJFNKi4yaQ6VhqYNqI1L2lhCHh+haT6OsKbZeyTHH/NEHxOfx1zTUiRRuTkcsdUiyqwlX4DU5B1MRWzxBTxRAG58UU0o25SFRCPIvYZMKeitKihlw8XTM7JlQ3En5XOGiq5ayLaJlRY0bU0u2iPyArWy6LmCX1HTOjJpEVAVpSgqANvFqWXQhfrWdj/kpJ6ot4zIgk/aI0aaw6cmt/n0bs3qlsLTMOKDJyoni5R+9TFSbtB4QyQ1RcpaiiJnkSadnalWNFrVpInsDibUCHCnrnD2bMavXi7R+gUqUw5v9PjMVEBQVHblMfuKwpM84SLfcLkpMF1hnSqZ7Jn4wtEyVkhi6Oka9bYh2qlRU51+KvMkbVkHGa68xRR3MRsyUScZeEhWy+imBWHG2fGGs0DFs3u444qoztimFpqvoBkNnrGDLetIsolvnqDVojpGZ7OKqU3wbJPdIZwZfYxECCLnmJMpkr5GjSTMT6qer+Zq/j/OH7TD9VUU4mqu5mr+oEwfnYOTFzgePuXp2/s8p18wMG1aL6b2I661PaJK5jKoOZBy5nZB0Qw67lXip7hyxa1YPCtPWStbtuo580zlsjYYGSml2dA7tzBFFbos4sFRdz645sg4mkRq6RyIA91iwofBx5xsS777nRPcvZDL5Q2k/gL3lkn9jZfRyx9Q3tCRnh2xGJsoeUn8GA5H2471Fr+j8pE6wX35CUZ7hCzprFli4oi2eIJyQ1NU3eff5Ase3Dvn7e+vKM9BKSqygxLntk62DRkVJpeiutHapcljqtjAqE/or3e5fDEgerxBHmhUBxX5CRg7A6pqyZO/YfOvr3+FxTefUB/XJP/i61j7gknmIjcSU8H9WslEiot0KvHBRzr3bh7yF//CIT/36pDfKbb8xn/2Xd75P37Ak8uP0ccN6TCBgdsxx84f5ih2jX8QQnVIvKyx/Rrr9X3yNGZfUrCTPsuTEveXLnm2/zX+D+kN6oMZf1ufcXLziB+Yff6dvsTEHRJioo59/treEdr/6g3+3a+dszZCKm3JR++N+AdbhZ//7Bsc3Izpc4vz9X3avMCVdjhydZz+gmcPzvjt+RNWn7rF7TcO8EcWZe3zOExBMOwMlRaVXImJ5ZrTVdqd9dTJIZb9GB7Y7LwImmgAPJkxqzxMJeP2c2uePA6xP1ZQ744Ybldge3z/vY857L9IaJ9SrBTW45xeEHD+9DmuHUiMdIWsEMh3wWir6VFjZbvUTc6wNkilU0olJ1F6lLJoJtmQtjVGvIOlCvbGJx+vSAK0L0D8omzdwMksUiJsx2MdDPinXurxT20V/k+nW4rrFl8uM164raM8lSn2twzNLf/gnYhraKyUiDy6wVS/5P77BWVk8+XP1Fj6DQaPBdtDofDvE65q4pOPyIcVvrxLoas0foayKTF0i2tTjcmgIEzF3wvaVsdU7Y7vkWo2N452UcVZCw3Fchhee42fuPsxJWMGhkt8kCInBdGvr0hnZ/A6PxwxIWgrxrXw3JRkuejeFD2bLZKmkyYx96KGgRRjDh2cV3f4zKcP2J9atHVLJqrpapWLbMO9TUiQtqhq3fEGVNnGUA9pRY2KmtJWFnoV0jY6SROSCVUw10hJ0FuTYU/lxqBmsZIx3pzi6SrjfZ/aKlhWGk8ziTC0kMuH1M4ISQdTramVW1RlhhJUpPIzStmkVXWaKsOUh519XbywRqNzGs9JVhtGSh91ZIMsbPQKsuxjmBZtKeB0bWeTz9KadCNgKy2+UnLN7KEPHC4chSJeE6BjxzFupncVMdEkY73+ABH6UJuJ6KjE2do0gh+pGkh10cUCGsXHyiUuzxukaoefPDQ59iW+UWy4PNuy2KTdRWxafVQlolyktKqPaTe0wp2R2LRWjT2UsMZ+J1yIG6ZaBYh+hM7a1V9jDdyuNrM820PrhZTtltYa0noLjLTCUQNWasgwdRgdjDsuwersHdaqSW/Ux9ACDF2hHxckvZz4okcZZchui2v3kJQVreajFGPaRkFS19T1BqmSQXOpRWthWBBkC75LzioNePP6Pndu3KLVdSqpwmqFzUyhFBe2KdPTVNRaQ/aG5FlCJQ67UU5ut2iyiaEqYNcopdIJAopmIOcaoWhCuFBReiZ96xW8Ucw1+4K3E5kni9uE6xhjUfHkHYWnH1TUiY0wOfltRplsyUodGo+iaMhEFWjWoFyOO3VVqNmCV/DUzFkv3+f64og3Dieo/ZxrcoO71ZhPTTaKSpJIvFrqLI0nlOWE2iuIklMcfafLk4VlAcGKSjHRNZOmXbNjekTLmFBktwwFW9B7C5d1uEbOFI78hv7ExNIF9KfqRDjRS6pXBoaxAU9DjVw0WVxoFrkWogs1NS8InJZoK+NINU+yPqqeoDcug1SmNK8xVq+cCVdzNf9tc+VWuJqruZof98ndC8K+T/SWymbyj1glr2L1FbRVjr/2cXyJYWWwTCpio0GNGsSSf+SpSLbBfFGxzbdY/YCh4iDXDpKc4gpn6UJC9jV0QyWrUlJqhkOdp0pJcwm7loPq7vKRNMO71Fi2Gov+mjd2rvFB9BD9oEb6Xo/wjsy15TsEn/kiUvQut7Qtp2XCKga9Z+F7hyjThNGpzHsnEtgj3nzOIRvOcNsebuNyIX9IFCcU24a4iPl4pvDB4xVJnqLYQ1B70Ksodi+R5ISzuYZ+X+rEi2YrmF5rensDluuE6jzFs6+h7MzJjyusjYasLzGuT8SxAvnkmK9IE37wlS1/7X7LP99r8UcJu70jLtRzFh9qjIOEXx1eEP/Z1/h3fuoad6cS//lHCX/nN7/Bw198C2+7ZvSSy0ZyyBUdNS1pthlt4+FrDm6VUzcxomW8bTLy1MO6oaGfXWPVbHDvysThmEE5Q9lKVCfv8a/+L7/B0ccNgWTyH/3RmDf/7BF/Mf3DvPTSdf6tT9t8FoWf8RLU4/f4G78Toenwx//QbUwRw4132Uo5SrZLlVUs84uuPrG5XnCt75OUOduzS+4tNgyf3+Hg+gG9aYutSryTNtxbNQx3JAqlhipkNVvjO49JWwtTWROZYwx1ycezFEPWef1Wzf11j6BW6QlIYqVi9Tyirc3tV3dxzDmL+0Pa7QJzIuFqDTvOkjNLRm0dzgKf26M+e/6Cttx2gENF0SjEGY09Wlq8uqFuFWj3cKkplX/M/ZAEB8SkyDPyukLVVGFm6IQFS/e6P/f59pLTicSLR33+YjvhlmmTNwpfu1jROwi4dt3l7L2f4MPv/jZvKj5Psgr5sxdcXFScX2wZHVZ8aneAGg/xVLNzQcj5Szy9d8amOcTVjO4sK6shehaQpgYv3O7xqZdbFNNEz2QG9hC58qlyid2+TVm7jL2QHJuqEgvyLQ83Sx5chDy/rxIkG0zBoPBt1D+hoUedTeOHIyYMHJ+z8hIjbFhGMWVZYrguyWbLSSPTk2K++MIBZ25DuauQhiablYTbC3AbgzZXWC4jtss1TVmgN6Pu4CO4AbJik6dPkVMZ9g0cs4cSx3hOgmRAsJaY3JnQv3WIsdMSiFoXw2RvUuJLCq/vjVk6Fe8lK5q6JDl1sZZDSt1C3j4msnYwnFOaqKAx/M5VYJkjMlWllUOKZoFeC3iKJt5tFEHDZdiQyzW9foLcX6HoDno6JM2kLhKhsgChkeQRqWJRFAJ+0ZCZS7x+Rm+oYdt7WFLOiVJjTRx6RYQ+c7tt8SZvScstfd1BTWG13OKaPUrRoVmlmIWOutolbLecb59y47k3uKsfdOpipqW0w5hQPsEoN9TiAGkMqdZr0hA0z8UdphiWjn3dwrMk0iDsOAkeOkbVoxLAP2+KbJiY7XkH9OtZDpE8IZ6f0EhT6vyYVXsdK2gxDqXuRjQMr5ENZrTFijaTwF1gDnfYYcrldkvihijjmE/UkQbZ6aHWMhUlTSXYFDqKNERxpK4Ksmi6jhDURKF4GvP4IqLaapSax9ENH8MQAkuDL1mkY42tnLLJUhrVw9+IyIeE4qlomk6QZcTNGqUw0XON2ivR0QgFrDLPOyeHAGdq65pcCJeOg2/c4nO9BdeVc97bMZk/hQSNUp2TLVeouYjcmChKQCGYHnWBYipYsUG0yUmkFKdnESoSPWuLtSh5yiX3jxPeW8CL+znPT3bpORp2oXHQi8lkG4IKTbcxWxk/t1m1LeswZ0f8MKZgnTTgpJR1n1ryqGuZ80gljAtuNQq1rbGYb7v6nNqQsV2Z0i6QpIpWtdC3EeU6pbp+hKYK3kZNqqgYfsF+onQQGsncpdEb9CYA22YdPgE5RPHvksXiulXpiRpYLfm9PodczdX8vuMl/F5+nz9oLo2ruZqr+fGe0/tH+J+J8fWM6Btf5HEeMnhthbJjY17qxNqKL3hTbqmCWZaQSSqxYIYfVuymOtapz1l7Tqrsoxx69O0to6XOPN8y02LGjQmPd9lECqOJOESW2KVOpOjkZU6oOehiaaNaHDhrQk9mViwJ//oAe/KIvWbKab5k/vnPkj36gMH4Bu8PG3TXQN9q9KKQ4MUli9NdxrcbtOOYrz9c0DNLXlWOOof0orykSDS2S7Wr8a5SCX11gl/MyXpjEiMhuozZHV3nj/3MLaStyS999wOUDy9I309gfYDxRYWNANUvB9iDlrQVjWRjHD8CK2bj3kXbRujTORNllw/GE6zju2T6GQ/WI27fGhKml3iiDl3e8Iu+xC/8mZ/mf/TaNZoi5y+fnfLr/9G3efoPFp88x0/3aKuewIghtydIkYU52EUexaiYtK6OvCzILkWGI8Mdjjo2xYVxjG2Z9MuAhaMwrPe66kfv4CXM4ATjyynDt3f42hzKv/ES/7tf8PgzB8fIxXUeb59yEWv82t9e8Z/8zQX/9r+h4r10Qn1xk7Io+W35HpvTOTfpYykqlup2rQfVoBLHAhbLih98HLFXZLTSmkNZ7dwHZdXgsEGTG0rRgLYZdItfVd2yLhZcP5ji7nuEb8mszmJ+4TMF/eFN3uM+Lxoqz4YWrw0iXj0a8jtRxhuDMYvTmt5Y4cG1jEHi8lqusZbucPOjM+p+zo4Z4mj7EB8hNWJpjMi6dOw8RBNgLSFge8ItIloahDO57iohdRF4oK4bFKGmCJFBuNClkFEz7WokRd2Ap+soz7acKFueHpzx0VZn9K7K9LnvMLj9E9woH/N/fn+Blcrdx7z2R27wb//FLb+8SfjffC3hZ9/06dsOi+USpZ5Q1g224zJ7Btk9B3tfov+8Rhn7rOdKBzI96Bn0rBuUkoJi5Vj0OmahILAbUca1kYqrqEjxjLjuE5QJyrMEv3wC0i0UsbTMRcuiiiWbmP7hD09MMCyLh+cB7iZG0iSGjtXV9allw2X2hEflqtvKI3glRUIaJixdFaQh+rAmU05ZZpc0snAfJOSxcB+oqEZKvx9im6K9wOh6OGXNJQhbwtMNlahyPLQZX9MxBicU0ZQgnnFyPKNOhGNB463mjM+98AJ3RP9om5KXH5IbDo4rOAsqStnr8uztNqQeSEhNnyiNUWwNvTa7io/aEn+WDEHWqNeiJzRlYyWUaY+BY6DqGo2eIEs5cqrTCHik2lLYNrosMiy9T6zvakoSZmRZjKnYuDu7vOm6nDUJq7RBSSwqbc2UhtLrsyhFg0OKmghqv0kjb9DbIXl5iTS6oKr7zO7LpHcXVM4OD+cb5otz+oMFXt8h3hpsFhGUObrvdtWBRZbj9l203RDdzCmxkBSbJt0SNhKFaaBMRaZHbO8DmoMMiYg07WF5ojJTwcpstsY+G1XB3swItT6yOyXz3sWejSl2LbSooAj2sXSZmfghIUldHaLLDsvzDWUaYeiH3c2lzEtaEYuQFZomRc51oSUgtxWy5qAKq1Aj3AMRD568i+oGDIYv4ihDHq5iwrLhzR2P/cYht2ISpO6NmpY19kKm8Rp8f8x2KyGaXtvphjqXcIsMy5KpLKHRiPpRq2MOIFUkcUKbS1TlgL6u8KfdCez2uHhlyVcfvMc/+jvvs30nwDqLqHybxvHpjWO8Q9huh7TvhGSzhDYtadMaxRxThCmqZOALNfzeN/jqBzqnn5f46bGN6Wj0syNmxUfUiocUWLRayGq9RRuNwalJc2GZkmhNn56Xo6THBIx4ug2IFI163bAwVmjxiijLMAUTRfFRlQxLbqkaC0QNqW9Q5iH1eUkqABVqTOO2oO9Q2RW+oeMZGaY0Jqbh8rTBjKeogwitSdlpasqBR5CuQFv/Xp9DrubHfK4Oz//VuXIrXM3VXM2P01xmpxg/2CHcO8VYNhxLT0hObvImJSv9Bnp9wmYRk+oS57sZ5kJhp3RpFypzOWAx3XL2KMY7f49p74h0LGPflNgtxjy6GHD6UCJpnqH0LqlDj1a9wb5bENYpy0qivZhTVyHHVsZ4esje+xO++27Mc5+NWZ8kpNPnscMVzflDJtKYTS/EePiAQvkS470Z58EUs75HVe5xnJ2zf7RLfr/i72wX1E3J8/s7GJLP5nxOcnFB7dQ0msva2uXS9snOREtWzqdeHfDcCyMme0PGss75czf5ngDIn9+DHYPyiQHGGYGd0X5nQv2pJUqpUTMnS3yUKaTff8xg97PEr3+IHRyQbT9Gfilh9/iA4sWGgAV//dsDzsYT/uN/9jW+/GKPj7Zbfv3X3ub9e485+Y2AMlhhTsQSqaENhNP7klbd0Og+3tTCEYur7ZzoTEexDaRbBpacU6klj88FO85ClU/RBJxw/yZ1sqH/2org0RS59JDHJRc7GoGn86/+8yNe/pLJPXnK/+2jGPPsjPEC/sNfWVGtF7z17IDPvipjtjVBuOQ8WPOs3vC4bvA0gxerkEGu4doDsjpnTti1llVSy3qW8WBdYe5s8bYFaVrRXBSkgcy7m2NywTNY9WlP+sQ3VapHCo+3M17AZuO3/Orod7jx5Cskr5zwQrPlIHU4z7YdmPzjEyFeTRmMFV5U+pTejIPpDdLiCdrA70D7Q9Mgs2CbxhiNii+q11WTPMtJ6gRD05ELuWtzaNWK1AzIiGkTvTugG4XVcc0kYUpoY1BXdAfhpkURIHNZplJyLq0P8d+ZkHwr7wSH5w4PO73iQXKM7o3YsyY8MHb5y3c/z0S/xl84gr9m/s+5Lhb5iU5dSRhlRtbW3ZnqU/01T25Vncv4y2WPtazyK5HCGInXpx493e8WuJolnMUtddVgtTWxsqWonvEbFyVfzH6Cwb4QG+ady960ZaqywtVtmrYhzVNMVSfMox+emNBuEnaLjMuejVOENEWCZGocZylqtuQVUY7YS1E1l5M8wxma7DgeubFltVa5/zTg/ScLKgGxK01ivcXXbQZDA2+o0P7jtgIlrpktVqhpjlJWrCKXXk8QIhSU6z3GnoTSKxi5NzCTgqqA3JRYPV7xMD/h6fcj5MLDNnxkVUcRdRnltmsJ0J4foZ8VFIqDUUNbXdBIA4zaR8qjzo5fpjUyG0Qyo0j1DsZoCjiLrlOqAYaw0XgSaZbQJj6mO6Z2TBLTolcHKHWD9ExnpQZsqhV6cA9NPeD1I50jY58zSaIpCuJnMNbW3Lim8/TBOefeFiW9xK1d1Nb9xCITH1NkCbN8Q1jexEkrXrCvM32+x9lpyOP5kkYPaPWaItqiZWuMRkBFbJplTtIqOKaJ09tDLxrqKCNsK9osQPUnXRNF2MZ4j3RSW6M2z8mqvAMBlpqFM5iQzELy/udQnQ9ptuck0QSt32Coe1julmKVkJ4VXM4r1GGGPhhjt21nq4orj7LakhcqYRKh1SW22Ufr7SMJ5bGMUITFzaxR91yURqbeqORpzkcfRvSMJdd3G755PCc8C/n+sOEnb+9y++i5rm9YGg2ptUvSleAYCNDKBmtvg5XfoKoE9LMm1VXKbYUiKiStoWj3JIhjaqvGVx2aqEUNWqqezaps2J9qHVfhxf4uN/en/L2vnxF8+xhtcUFfjTk61Lj5KQ9dlljcSfjB04bL+zH5vIfWBCgjnVy4SvQKSzdwXB0pWvFOFdDfXzG83LI4rNifZZ2IVBUVUm+fpGkwi5BVoCHtRNiuzsjcoz6seXYck2xVzGBLUhSUWw99p8Aeq+g9Bzs2yCONzbZANyPGjiaMWdSVQ90sOzBjXrl4+xr9aYHVVijaBLNvoQYCotSi7sY0FxXrwOwiMNVOysCqGTQ2DzPn9/occjVX8wd2roSFq7maq/n9Pjd6Q8qLY14bP8/hm49ZaocEm5hcNrhmPiBNd+j5CSc7BgeRzoUWEDcJi1WCbdi84vaZ3h2x8eboakH4yOZEtJDJqy7yLD2Xsy9WwB/u893jnJ07JfU0QY8VrnsNH+YbeNDnsrUJ3j/FvqeT1Q3HTIj2HrJ7sKJ8FDPx4UyWUL95hn3NIzB+i/ryBpZU0N/eJSg0rNxEOx+h9QPmq4Bv/YOa9gsg9U86hoAuVd0ScVUEPHvWcHEsYSYNo4GP9xUPa6rw6KnJR1qNNwnYf+zzweLT2H5F+ppM74mG8mxDfmDRS32qvXM2H+tMnBzpeyHO6y9StCYlCe7ld4h6X2Gc/F1ufmVJ/Njgr97P+Yt/2OfP/anblBOVd7+/4Gt/9Tf5lfiEe99Yoa4KWjOjzm4gSynN3gnSyiAPRx3Dzj7fdGw7dTTE6MuoaQ2Jx8YwGCpr+knFReWSJwec3oixlJrld010e0Dc/wAnNHj67BrDz9zmn/4zMbvGlLc2c34t/ZAvfS/ldx/GfOujj5EeD3EO3+fvflfUwhsMn/sdTp4FRJqHO4TJOiOQK56kFqg6VbEidc+oez5GOSZv15xfJJzVKurC45Zho2Q5WaVw/4nMSv3EAS/PCrIkwS76BOcritEFu3ef7+CMf/bkp/jq/gUTf8CXi5f4y7/0Fj1rwU/eeJ6hbHMi3MX6ijt9neTiDWpzjeWIZ+2UiWvR67+EVlhEScC2Eo19BhISdVlT2C2tIpoMdGRF8PDm6MKxXtyk0HKKpqTWii7Oryu2gMbRdJ2BIEsttu5QNSmW5LG7eQW1Z5BaIT3vBYJ43cUp4uMvoA81/vy/9IDvfmvLd2d/n/9Z9TnSrz5FWWXohyXD+NNdbWljNrhUBHmCc9TjMDlnq1v8qlKzeJBgX5Tc+ZzG6BWza5sIcoHlrzrndlamqLKC5lrs9VzGqyXHD3+Ls/V10sEap5zi6vt4hk/VVJR1JQBvrOI5puH88MSEbx+f4sslqtWwO9jhrK05mPQYrjIeXmhswy13RlNeGtrkWdh9jOJV9B2PcL7tiJTtGgyR6bF1tIHJtsk7kGMPkQEP0SuFyGpRopQgaQmcPmq/xBs0OKKCb99HlXKK0sap+py3KU+SR1RnCfllxOrePvFGRy3nZG6Oaux1B3C0KS0PKRcqihGh4dDWc6rURB9rqHpMGpdkpagd1JBkyC0LTaBdl1sWSUB/pNAf7dCoA5o4oVl5FLLGrQOVV2/pbC5zPrgsydc6xahCTgykQqW60CmMiK8qohak5eWhiFKEPBmMCCqJtB4wuLWPHzyhdnzi7TnL2QI9m6Mpve71PluHrNcf4V57jbuve1SXCl8vax6vN7ShhhPrGK1N2vTJydDdOZpYn6sy6eoSS1bpWT3KWmW9LIlVH2MjFLUQbSzTuiZupBJsZ+SyjFo5lJpKsX4PT3Tv2jG1dNRFKoyyJR2raNuH1L1Jp3IGxSXy0MToHXS1mHkbUNi7tEpBmSwoYlFlmUFZoA4s+oZFk66J1IbS2cPrDzgY2shlwZm04KIMaKuW996e8cFHl10di3AtBPGQXzp7wERfce2FHj/1mQOmwx7lUOdyUUGvJF68wchboKVLTGenawApyKlkj1DUvBQ1huh/FdkwPUOxdCRNVO4o6JLEYj0jDHVsZ8jP7L/JT/3pT/E7XzjhH73/FvnyKbqx5fKiAsXF9Rw+9yUDXpZ49+2Y5alMepEjE2LYMI/7qJNl9+ZN1JL5do+B8oRRNCQ1WpzGILYsquohpvISy/gDmvwA48KjFnWTeYik9vGzJbq+pb4lIWU9ajWhoyIuLeJQWOdktLzHsIwwrIqiLdk0AbopY4jXPTXx+jn93paSfcpCwZV1nDoE16RKffq5xKkloWg5ShFSeh7UPQpJiIWf3Byv5mr+m+bKlfDffa5iEFdzNVfz+3E+vTflwtIp0pprN7/ATT1hthaV2C0bJUc6EttyMBsdpdboR2CrFjdck/nuhrjU8EuZYd4n75lEUcPxW0tmmwueu2Xz4uEuraQRey7T0Rot+T7n90e0xj7heM443GN8q8UuhSP1FoH2CG1lds9lXvx5tuExk7OCi76H3EDzvEu2OGKvnaNUZ1TuC/SHFrn5IfbliEZ+Sh4UnaPzHeFO+GrASy8Y+EcqhTwl1RTU8CFStMEsGhBMrCf77P9A5s7nE0baU8ahTrze4/7sAnVnSdUEpO/pyLt93JeVru7S/GDFqs6QNZO0LzbuPaQ0Z5ptYJZSTKaoD8+55U/5+m95/CCp+F//Kz/Hl35ywIlV8vX3PuC9v/aYr/7qr7Kd3aTHHv7LEaGas143aBsBci+RzTFy46Dll6hRgjQaY9Ue6rKmkGtKs8bYqLSTKY2edS0V+jZmcGxzOpxhuwlZdY3e9hWM9WOMn5vy7/7JOyRZzN/c+z5/avkyf+xkh3/9r77FrYPvc7F8nmo3xrGvsb38mF/8KynPHV2g/9SIm70BNwuLyWCXi2griHfM44xjEVlevoq8yhjvPcHbk2kWLsoDnXSusLkzQ3Zagm3Daprg3VRx3lU4DZ+yqnRGqoI3UvkT1l329o84Xj3lonzGUeGg5lt+ab9AK1NS1WMmlnXCoh+UxNNj5vl/D9w5086VvMv1ay7TyQhdtwnjFUkZIvs6pVwQBWXX2tA3B6iNTEaKrMj4xV530BZcD7F4rasSy3BptQ7hiAiSO7VDLZcoit7VSdLqFHVFqZad812VVeIk7sCHwjHgGH1ueVsG9ad4+GDBF1/Z418zTog+nfHsf3GdM9/u4OmGYna1lE2j0jcV6ts2f+LOPr43YBFGzM01npWgP19hOQ6bbEmaR7hGj7SOKdu8Y0SowkUBWIMdam+M0iioc5OsSRnuTLp8R1u2mJZFlsaYkoWjuj88MWG5iWhFNeLAxGgjhppNX9KY3h7xRyuVXysfETQzlCAmjFoky+4ggy4OiN4AAQAASURBVAKAdxnN2CZbJF2mFltPNkROgyeZjITVxnfQtIQqXZIuJNSVjWUIpmTL6NMDpvs7FPou28UJZ8k5jy52iddPMfIYWbcwJYVEGlCVMWoqMt8qjhKAsSWs+sjBfRx5l60ZIJUWaAJOZ6KoI1gqNIMCv9fH390jnQXEl5AWUMoSki4hq7vEsY4sb3H7EqqjCbM8QRkxX7a8W2SkSkMcC3ptiR9DnigYukptJN1NyNm4aJbGsR5SbnzIxIbYYkdRCP2nxOoubRix4x9Be0qsmCSrNfVpSuBmVLGPrmuUFZxtK56FBtEiRq6brn6xclRkQ6cnaWiWjjWucJ2GMHLZJAq2kiIZDYpV44pohQqFliDH17o3hubVVOoutrpLHT2mqVRk3UYzZYLQwlq8TTV8g2GTsE0ylmmBlaWkW4dqtMdQLTErhW2edQrdqK+jaSPWvYpLTPRVTlPNKfWYxNDwd/r4kkSV6thCrRPXRt3Q6ClyG4peSRTFpYgFGHMMVk5cPUGph8zna1armpXU4wuHMUf9PfYsB1HOc+E8ZVVk6PqQJhdCktLFExS5QstzclH9WTfojo8mPqe4RtOssw0ZA6ureinilDQ+RXcafG/EHz68y6f7Dt9eGrx7/hHpowhtLTH3PPpKwXgq8dJndS6fwvG9lvn5kuaBgZo9xtcOWJ2E2JaErp6gOiaB9BSzsLA9IVbtUimgVg+QFR/PKTp1tJDoXCSLCxlJcpjeaklrCd3yaOOa1TxgG8dE64idvgC+iN4MULMSEUpIqHHzilYboO/Y6HlM8tjCGOTM0hW2XKNVJqXXwtDFqyxuKzqheYxTFfREZKhecPm0JVld5b+v5sd3fli8hP9fP+eVGHM1V3M1P+rzHXfDzXLE7OaC+MET7ihjbg4PeXt3hrGp2I/3WHsbpoGC32rsDvZ52FugbDWGiymllNPI8FQPmCXPUNK97rnTqS0W62u8m6fs7adMjuD1uuS4uIF0S6P37DHW5S1axSFyI+Ih3DgO+DD0kS4WmON9mt4M870dIrsmfuX77H708xxvYobKQ2L1OpVsoI1bnl38NtnqOtH4OlLzmOIdmeSgxi4r7p1EhPkun93d0r54QX2mMw/32dZTiEVtuogR3OetRynr6zd44yVPIBD4+x+8w/vvPsIYyPQbA99fkM3ew17eJnmtD9qHSM1P4oQFkv4x/m5JsLyPfuMG69PnsKM+s2DBr+cv8Zd6O/xb/6ZL//khfz+pKP+Lr/Odt3J+55e/zyK5g95r2bshsf8vPM/yfkn21kOqj1JoNQrjDFXZQb+xi+x8sigTFeDlSESbPcw0xx4GVM8yQvU62jWJJjYJQhEFHmLccNCfaTxzH/PGz7zEv/DlCXmW8VuPn/D6aMV281f5N/7TCRff/zaDcAfrc/MuKrz/swOy0xtklyFPe3vszKbMrmeMGgEN12glnVrJcHWpi2MU4TEXUYu38TlwdRrBNb+R4pk++4evEdYx+QcX7M515DNx3mj47Mtv8sy0+fmjgsUaKj3lYnPOP/xmSr7v8OcPDQaDY05Sl89/ZsiTRGFmnDO81BlMerQHn+J2WFPLLWEpIJk2c2lJDxtbsnCtXlck4OQOrdSQ1WV3mK6MJVWtINdika1QlHVXGdqIZ/Gu2lKnbWokSUZr1S7+IGLERiLOIxmapHWNdOK/O4pLWRWUBihpg6TIbKM1zc1n+JcvU6s5P/OTNl5xHbX+FNM9gycv/Ofkc1hv1yLUgWN6FKqI0Lu4pt+JEYER4Zkm/lf2yD8foRk6C2tFZqRMyiFZkSLLKjIqSZ2jKQq6oolDA7ImdechWsGQs5mVZ6iNzq57QJLEKIaOLEoGBCn/hyUmHPYVVIHzKFT60idkx00WszlbcRFtOFQVZlWPZ/mW+ZnK0/IMUzQfOCGnszlh3kKr4jc6I7+PY4uKxJKiLYjkklUas10VzBewEvUqpU5PMaiF+iOtsDOV91eiOULm0E0YHfjkmoXqiIcyg+TsmLcfRizLHSRvQ10NUNUAXUmo6xG5tMQVOZd2Sr7JqaoUa+R1B2DJHuFJNi/d6WG/8BwPHz7l4WxGXKqoSY6RFUhmSRKIDbuCM227qkHBpYvnOe0MtGGCkrlYBh2oL+WStsxolX30LMGRhB1GJytq8uaCemmQpPucKDC97rGn+WxbqKcR+8kukgNbR2etlYSFztOg4SjNebzK+e3ffcjZk2Nx/8AcDGnknIYEY1UgZSr9nQE9taRqU+zUIZM8Fpk4PKbIsd6JG5KUo0tHIC8wfY8irzHNPlKzAiUm8iSm1SHb9hQzWJJZffRNxCU5uibjjK530YrKzNEaH9tKsOUNoaIQ52vCi5q9w5vcMK9zsLvkWIPTy12y7SW65fPFT/8kkxsuv3t/zXazpGpXbFZz0k2FaY9AqcnllLJMKMXXFEvkjdrVbVYTmXqR8vTj77I5c+g7Z/zc63fZfUFntx3A1qKtJOJWVONUWLkAZpr4hklUGEiyRGLWZHVFG5adqmu5Dk0mkZYFlSAyCJpN5rIpNiyDELtV+Lz3Koemzz3nI05mIWUQEJ5m5E8K3P4uO6MI9bMtR5sdFs82LJ/soyoGbbZhvvHQlA3BZEBx2jK91rDLHnFzyrC+TWmEmIZBUaYkWgYhbBSXyDtmzEHX3CH+yssFcWXQtipV2VCnziegGKMgkQy2UkujtviWRarqRFmBuw3IpJhc85ADUWkqkWsNs6hg4tjIbSruJRTyhjzTqEUnc52xDBS2ZYOrCMjE1VzN//tcHYR/73PlVriaq7maH/V5MehxZsy5vb7Gulzx25OIz24t7l76FJnOxfaEgalyctdn07zP3fAuz6V7PPHPSKoGNw/RjSHrcIIdi4PuJwscOy6Jju+RH7o0ygGnxymJgJVP4JolMxw/z7M4o5IuiRODWmlYphn339LQ5hGVnCE9TSnMBex+meG6peq/z0SQ7zd7eHrBdt3QK09ZPUqo9vYh/w5KbJHXKvLcQtIukQ9lLqQnvPthj684Nxm5JQ/yMzarGXl0RitbyMaE9GzL8dd/gJ3v8OiJxv0PZ9jSFKNYUZUasT5BHj5HrZVUZ3PqO/sY5wHbdozj3ETKHzDWXuH0GOw25+zkm6TOn+Lf+UuH/OznDzAtuLhX8F/8x3+f4KMlz0631GL/aXiMP9XnZ75wE2/PIJef8A+fOjxQDbTGxVbWSE6MYrro1pCh0tAmJQEVJgWCIpitfRIlx8ln7Es7bPfyDrpoxjucHLtMfn7L/9i7xd0X+rwTbkidkC8d7PG3frnh7Q+fcP5bv4m2M+KjS5PDRuPwcMTzt2wW7SkffZASJgLqV1PfWvKcbzBoFpR1jqM6xDKkUUOUbLvtvCO7PE0znjyV6LHPm6/sougVuoAPuCZnqzWeEaJPE770EzrrdMTbcczZI1ipBe1iTRNlDKwJae9j3PxLvJrMeNh+TDJ6jv5v3uLgVsjeSyPcfMA2nmEZA9Z1QT/dMtQHbBZLMiPAc0aMhrtdxbqcBTh6geoYSHm/qwgt65JWEavHlkYsAtqKuq3RFZOqaTq+gqrJKEoBUoSiuaQCClfLWLJGUVUdc0GRZFzZ4IJjxsoulu7gR58jk3NkSWOVnXBRPOFf+XiXwyzki8cb9ukz0G0UIQgoKmbboy5qkirqfq1schRdxnEcUMyOmTcM+ijqmEatxUNa94whS0oXa59VWw7Y6yIWQuiQJblzPFR5Q18adceJJI1Jm1RsJbuvUQBVf3jOhFTBtRxas6I2XGpN4969Z2jahkZu2LHHjMQ2VBDz7QXnonoiN1DKmm1UkgUhSayh9kxsVUUWVZC6TCHs9HFCulEJMhdbyrBzm+NyySa1Wb3VMs9bru0FDOp9TFOi125ZdlC5AfNZwsDSaJo7SM7b9MKKZtViDHWKrYKiZhT6DN33aDKdRgvRbBOqAd6OuJG1zKpFp8xJ7j5TT8LTp0z3PU5iieXFmmIGVVlSSRFJXFGfK/TE5r2nUeUFVWRQBS2SHCBJKq0kY2gDqrigckuazCayhqhlQLWNydsdQs4xeIRQEyzlgN4rEruiQUC7w8V1mdXiGZJh0L/jUSwSttESqdlBryMsX8cz9zo6P9ISRWmQlR61G1HpGoFskM8MzFZFclMGXoykFpxna6pxDz1vqU9UwnVAYep4BQyGEnG+IClMmmGFEvhkRo3VHnYXaqZIoGeksyUj9ZCBVLOwbKRSWH5O2MQOWc/Ca2wscTR1ZOJiTmX0qfWMvqNhDmyS7DalZqBWZ4y0axwduOhyw+yJRLMqaBKR66lQDK0Dr2Ti3y1hIzLRw6zrny0qBVdAHLcSqypke7bLrwRL/pjls3MU0DrXadIWURiRR6VAS6I0Dapqormi30HgWhOEcUFkoxRV9NqWVLTIRdn9mhATskaITgJH3LKqVXTLYM+7xZ53xMo75v3iPu9fVFyehlxmWwZ5j+mgpT9S2Vy7yeb1jOBRxjaWiU5lpGSDns6xnJfwCp/l+ce0ssyKdzB7O/SrhsaGsbpDrNHV3OilyixrEZJ+uS7Ihy2eqDgSFTdKxpnmE6giDjFHbn2KFMauxc1en3m7YZOvqRUHV5lQFp9AVIa9AaYv4Td1V4HEZUs5asjzBCm2ke2MeSahlTmWU7Gs49/bU8jVXM2PuCDyT8Kd8F+fK7fC1VzN1fyojoPET1hHzLKA3Z7LZB5xsS9aGyLGkYddqxiibyHaYoRTykZiNtlQND7nQdst5ipCHi5m6InEwOqT2TLWqIdnWBh9iZ7eMitNDFdimDg8fqSSKGuKquW03dBeqlTHOrNqgBWtYeKQ1S7W9Bx1chOOv041VTAm17n27Yx3f/o92u9eQ9rdYX5fx3pzQPZhhiw3tCK7fn1Eo2us57fQtYRyHfH2xxXq3iV3BIz7RO3aGJShj70y0RWLVGtInhZ8Z5UhzeaYXkbvlkG2qJkd7WHvFEzCgCxu8HsTyscXoPro/XP2pQMel2doSoh2esZ6LGrYv8y/969N+ZM/PeJ93eDX3rnPxS99i81syeY8Ro8nxHseB280/Is/c4ebwxGzTUwj7fO51xXK6IzL72yQMqN7si03GwKtRNp3MHYb0GvSZY0q3OEjFz2dYsoJz+YfkmVDjFHB+YXCtU+r/MuvvYGnj/iVOmTixhh1zr//ix/w8KsfEQwtzHKKf1ciOd2yWJjcHATk7PDgiYZkyIynGxo1J/9WCy9BNaowUo25mzCvaiRHJcslklYlokVTSkpZZrH4iHvxuzw+H+Ct7W6T31d8JEljT73G957IPI63TMuWMq64pvv0PzXiri9hWx5Ns8M8rfi+UbFbHLJzccHRaw5bU+N5f9QJAiYmklqyjQMsRydUNyzDHe76fSS54uTiglKILkI0wmCqaB1jLSvEQV/u2teUtu2Wj7Uu/s8EMoWyLoibkF7bR299lLJPWhe0moypaOR5SaXUmJJJXbWkWYpW2ZwnPmOnIApjdE1B7Oj79pBWL/mfzCrMZ1PyQYvv9KlrwaGru8O/qVnUStUVIJTyM8xGcCZsCjmlruuulVAw5JIkRVgAFEXpWu9KwYOoFUaVqKxMuor4RoDW26pzTCBYd4pYRjbda2WpNq3SdhEOV/Z+eGJCU+cMFAVZHYhrkyfzcy7ey/nUSx76NEOtFRAHTlPHX7psZIUy37BdBDx4UrCJGxRRqRGVwnkO8qbLTNWJgy3zCfBEq0k0hbmIPBQF6o5Nf8diMpTpOXuk7Yq68JktZsRBQRku2Gxb/KMSKZWJNgdI6mPKoVBxauRKodEMlGxE24oLYkCZ6MhNTj1Q+PTRkEiuqK1d3tzZ5U4PtnXJRtzIhj32NIXTlc7pxzGbkyWLvCLOLii3BXI9wD0aEzcSSRGjShKKrtE3J9T2M+oqIXMmqE1Na1c4bkgdG2xMGyuZcOQVzMSFdLkg2bhsHi3Z6h6WLlwgKddUmzAcsY5WFLpMuDDZnNncmvpktxS+vnhCnNS0qoscBtRyLNr/MDBwdZGJr2kDk1UpUxkqI9nmQBMKsglGxGaQU2lL4tLtXgMj3OsEorrdoOU3GUkp9Y5C1bRklzMcyUNw+MYHUzZFTrpYUhYGulSiO3ZnBQoWokhgydRTujfVsq5Q8oom14m0hvEthQOl7Zwnv/69jK++FeCNhuh1S7q6ILADpJHd2e9VpyGZbSlbiUwOsZoMx71NIgUYeUrjFmxOjM4y1gSXPM0V/tava/zUV/Z5aVBQaTWYClqudO4TQV2t5JYizclkuriIJzJNfkqrWFTbjEIqUXWRaRKHC/F3Q100lEVBnafkUUBeWFiOi66OeVPr8eb1lvnuE95erXgS1Cxp2QoYpKrw/HM2xUHL8cca70cnBPMhgSHjbJc8Gsu44vNtZNZ9HbO+pHSfR1MDevIGS/cpLRM53AWROZNaDFNDl9WuBSVpWwoBBdXFdS2x5w1RdIMobLCVmqjYdqLdDalPUguabwOdEl/gITP01C4rJqCcZVoiSzq+aZHGZ8TzMVErY1UBejYlFt/Yq7ma/9pcuRL+/zdXwsLVXM3V/CjNRqo43Ym5c2Hxbr3ADmu0hxHKnRKjmfBsd0ukTvAFE0qJ+GhUMUw0xiFcjNdsxGJwrpDKBmpfHFIG9L2a9iDGvDSIWrHw0tixdPJrKVtty87HLkVWcbpJSO9PmD3+AOf2iCIp6RkgGxn57tv013ukUorpf5rx3gVUNY/64GzvsqfASfwMtTcgrEXU9IjtyRTncEtpVEgrFWUyR1vqhNsemi/wWzoPnsocP1uiXCjUoynxzRmtqNqrfRxmKHpOPB7TaDPWcYG0P6Fff4B+fkAUX8cYnhKsv4Mmf47SX6CVCy4Fh41DND3m7A2Tl53b/MlXXV7+7C1+s2z4e+99lejxfU4e1uRzh2R/Sba0+PLP3+aLr3rsOhbPNitWOR3Q/M6gx/q6xPLeM6JkiT31aVWD+jJCOReHS5+2r1CnS1pTJZpX2MqG2JSQqz71051uafjn3hgx/JMh5yuF37hY8dlhhNwfsXmUsTi/ZD010AyFnetrUn2CW/iYHhztDXh2f0NwmdP3dAytR+mq5E+e8muzE15zplT9ElKNfKuxVmeEjY9hVlwfK7zgXOPO3YLjQcx8oTE72+LIS3anfW5OSx6sYr774Bnjsx4Hr08ZuDWLL4U8PzV5rX6OWI15Fl+SnW+66+qzmk5ZSdyvdZ4pe+y5G3qWz7PlM7jYQt9hvN3tKje94Q7u+Ax52PKdcIbW+tw0B6wvG2IRl+lFFEpBU9ddRX1ZCF6feFaW0FQTuVE7x0Jdlqi11DmCRa9kW4OChFcJaKH0iZMhb0kIKPrneOEtFNvDMSLaWupEBOEeSNIIXdJJtIaJ7MJeiyl1dW2I6jvLdMkUseCs0NA6Z0Fb7BNXKTQRuqyjqmKx3nTOj0ZrqdsGU8RM6qqDLwo7eyMa+iwHSVYwxRmoLdBMjbasaUU3pSRTVAWGsNkjk5dRt9j+oYkJqWmjSQIYCFGb8+D+mofBipeqQ/bl6yyNhEbp4QcStycW314G3PvgjNWqZDaLaIpPohHOKKe2PZKVwSrekEcFvmWiexWW1VCsK3Qq/OkBB3cG7AwV3H2ddayzXkk0yZra8LhmmGxNwWYIqTcyW8FaWCY0nk9PkCiFxqTlqLKNgGzWtkyd2ZgiTa42GDd09q/fwt8p+dnxDmPT4uEyZHsyR83F997oDpIOFjeO1M5aP18azE5jNrOM1VKoRKJ6UUe2TNRCwVJrRGqmakVTo7DsBBDtYfUqpCwHJeTWjSNqr0/4rIb336KnNiRlSTOHrJeTBY9YT/totoqnbZAslSQsePfRllR6xmdeEfWJom1hAPUcSbiXDAtTlrGiEltNcfSKXGlJzUL0nRCdFoRmH893MQYXlGGC0dvDE2COeEWx2hC7Kdqmh2Gr3ZtR3++hxjInadpZqDJ9zPV2ReLWqBuVWO/RhAWl6naqmlpJNFqK5FVEmk2dZmSpyM5JDEqZXNTAIAkWILpmsRds2c6POZ9PyRsd00z5uddf5JWDfb5/OeOtpxuYp901ty953PD3ODZb+lqvgz5m8S6yJVwvQC/H3GqcPTjjl+OAixc9fvruCGlSd40jUVVgVQqGrFBJBW1Vd9agWG6QWgmrVtBsg7ptyfScIq2oCwVVFSKXjCzeaKbUWZXysu2cIrLgTJha14jgGkf89PVD3mjXHG/n3E9CikTuIhq1DuNX11ybPs95/23mcUv0pCH+To27FzGUJIzpXcqoZh6+g54fUY2Fi+YCp/axpSH+qKaYpei2A3rJMrygLNPudTcnBkbjU7QVttMwVPvEm4Sn8yWS6dK3DHRlS6OYeKbRNVdsNwG61KB7t2lU8eercCuLRtyAkFk0Oe38ER+eqIwHc/zp3u/tKeRqruZHfH5U3An/TXMVg7iaq7maf9JzcnvDTyevchE9ZFxW3A8LrlkKO6cDouSSKoO9kcl2vGEcO9wvFJ64ETdqnduhxcXzl8hjDyMfMPRqZLvowHSZcG56IIlt1WVI4ga4xjXqJuKj08eUJxau77HmFE2VqLcZumlTSXOUxqJX2lSCbbaN0Owlq4sUZguayiI7H7C8HtOcr2kzh/jYxuqFyLZKOq/R3ZjNNkUTkdBkiaRavPn6Hp/93A3OQ51g+Yhn5VMiaYm/Vbrqw8RbdjZzNBW9L9FEbhcdrp5sqFoLZ29ONchYziWkfIoseGZtRfi0x9hdUKo9tumILzwH/4OfukOVJfybs1/mzm957H/rnN8q5mzCafec6gxf4itv6HzuZY+hrfJeCZsLjZ6ypdXFM6jPm8+7LDaHvJXJfOkLJn9o/w5f+8aGr37jA5qg6g74blWSC7C3s6H0L2jrIzYPZXrGJT/9lTu88eaLfK3N2Fc+5vruDnvs8evfeow0XfNP/5k+//5/eEE9mrGJhoRhidNIxO884/ENCVkpsAdb6uKADItyLtwoDqvTCNnsY+4ZqMMYp56SvGWQhSmHd3soocxbzVM0XWKya+HKKdUDBc3ap9ULVpcN/cWYdSOA+CGjuMWdePxx/w6Xm2O+7T9Ff5zw1nGMud6wtff5wn7Eu4MNq/Uuu1+XyP543v38fGbOONjfpV2UrGvoSTKWptO3X+3q4W/G4mtV6HkWYSlhKGUnClSNACnKpGLrL9zQZYcpwGjN7p+CRyBaMwzVQJYlBPlT8AUEEkDYRMQSUxdOAXFMUw3UZL+LKmiyQlRv0HWzcwyUQqQwNBpx9tAzaCwUyyQ0junXh1CYgGgalDB14x87FaouGuFqaidYNE3bORPEZxUj2uQEBLIWm1MgL8Tv23TXuhBBhANbNMrpmnC0SJ2g0cjiGajtGi2yNKBsZCzDhO73/SGJCbtai6NaNIrEyeNLPpidkaxXnIUKfVkoNTJ+bVN6NToO+mbJh+dLMpG1UBvRmAGljtR4lEVGnmQkVYXcOgRhjaWm9A2F1pNohwM8wVRwFRTfJYxhtV0RxzaaLOHoOSEKwz0dI3eYXS5YvpeSybX4VMjNgLbcYNkWWVhh9DPYioaFgiYLYNSy795EKQtG9BkZOkHWcPk0Yr6OMUwRVdhSrIuuf1bY2zEdegdqZxHf7sasgpi88ci0CD0uaBudTI2RRb2lIKj2la6zViWklgvi2KTVMw40jUnzjHuNUPp6pBcSlgnrUqEsDaJ4hvHEwkThiXeJYe9hNToHQw1DDVhvbWot4+C6wmjSI96GrNKKdJ0grljF9TpISLIQR3cdpydhRSarjc52laJeKjSuysgqUOQY3/FoigZdKUmHCQNjStnG2JZPKgd4VYGjmZSSiz9NWSxtjo4aqgQeSzl5Lg7iJbri4NQKXmFQNDJRrSObKau6YJ21+N31XLNMGkzROqAqSAdDdvUKooo40lipGpcjiX4mcW2ikWVTnhUxml7Q9DQ0XUeyZPT6EIucviRRimYIuSbQlxQLieJ+ybfmp9zWCu4ObpC0NVajUEgxmWLgmiZSVOCoGrUkwCJVB+4UbxVD2JpyGRQBsVSR6pasexeCqcpYlouWFzSUNKrgG7RdBadpmp0YMRz0Ma0eU2vNWX9LIuoxk5J4s0evbdn5ySPyfMajGzvMf23JZt1QRg56dYlRR+DqTNpVx5QQanywEWpkgKZlSNgoQxPJbLGVnE3ikqvCjKV0Na2XSc243MEXjoUCDHNIZYheXBdb3MzUEqmS2QYZ4aVFtZHoTwLM0QqtagjnKvMoIW23BHlLcykcGiKnZvOmK8xzV3M1P76uhB9VIeG/PFeiwtVczdX8kxo/G/NIf4d96wZ5e8b1UqXSYBHk7Dou96Ql58EKaSxxGUYkoYSyrAkcg2oao1cDXtJtLpSadVGgOWLp5yAbJboeUmcKFzdrzmMN4zshiZ9xed+jiWdsLhw0wyTYzxmFU9LlhrKvoQU9TFG/Nk4x+1OkOiCfK1RxhbSrYiUXVNGYMj/AcWLk5xZoly/S+CfE7xrk/hpL71MsNHqjKTdf3GPy3JSPFZsqlxgPDomea5FWTzvBYNuqlAlokUKartF2n2G5HsnMRp4OOlt4uDlGfjLEPjCQPQ31aUmiqZgjg+bGANe9g7s85b//z7zINPT4n/7WPf7CdyZ8OP4G/7DYYfXUwqkqJM1F0jQW8Zh5pVCEa2J5hOE1OLI4s/Q4j1Okusf1F3S+tH+d554foPUSftouSaVDvvtRgFqsKCwVbU/mQLUJZgNWm4b+qzt88U8ofKbc4eH8PV6zPTStz1rP+PW33uNX/ua7jF+8waff2PDKFwze/uAatbXEdQKK532KWrTXRThPW2T/LsbyQefU7kcD6v0E7b1rBEGBUazZEbldY01QR4wHGgNP2P5hPq95liScAwNvyJG/ZZ2ERHOJsRzTOjpaa/Ck1mlflun7OR/lF8TnMd7FhkyyuBlU/PY3S7be7yLdvMPB3phKsM33HuMtnud9+x43nAnNiceid4Y3lTgcjej7PTI1Z7tc8CjoceBoFE2ObdvYtk6crZBqGcfwEXhzTZMpyqxjrimyS1mKSsiqW0hKAs5YZDSNjq5qqKpwA9QUVfkJHF1WKESzQ6mhmCpNUyDLGk3ddjEE4XYQPD5xvvZEv6Gidb9Pv7wm8AwgXNJ1jakaXZ184IUYpYFe62y9ALMxMGOrc1OLZbZwJxRlhVJ/8lxTCPagXZHLEVahUFlrlOw5ilow8MTvKb4eFUXVqOqCqshRJBVVOMnNY0bZ0Q9PTIiLnJnUoggQnp5zfSCzVFzWkclyVjDqexRGRmk69IcmN/ZMPnisUYQKDkMKqSA3Ipp2TVaolHiQ+UhlCXLOclGwacD3TW7fVLuMx1mxIewOjQ47Wonht+SVgiJN8LQczxniqVvOo5psO8cubdo+HVyvqlukWGT/dQrdRmrnHdBPGvbwJzrDvs1pvWVxGTNazynFN35WoRQVeax09Xp1LXIswr4i3CsNiiZh9tQOVDjcMwiyFcuFuBBGLKwNuiBiNnJnP1eVjWhC7KpJmtZEE2pRPOLig7BTuZYXK4LtOaZQnYKYILVwFNgd7dD3VMZehTt6Adn0sVWNw55LLEvYVcOsEUpqhblb8uyZSfzslFjwAHwVWVZohGijCDU07ez54sISh11DiKk15NUQSVeQ9QY3KCmGU3S1xHFrgo2Mr4sbRUFfcCR6Me0iIctD1hsTdSPhegaZlqH3b2AIQJ90idRomFRsvYi6UtCLhqKWaasMSZNZZTJSvkFS2k5sMC2tU0xF44KgmEpmyvzjH7Ba93FEXqlp2Vo1smFRmDsknoGredSk1JJLu1NgRBJy3RIUOuP9AX644PyZRvBowe8+Mxi/+JS+vY+MjiqAKJuSxFKEaoAhy5i1wDJq1EZF1mRU4v9s1C4jpOoqirg026aLRKRtQ5smnZonlD3BAmmUglpqiVKJumqQCxmztLAdl4E6JnYy1uolp1yyKiYsFg32aModVcP4EpydWGzeXVHke4RRQ1vGaEIlFOqm3BItn2HWPbxdDc+IcfMdGsthproUQuxKWygcRtgMLQchmzYIyFFLJaizQd3lAYXbqhY3vkpBUxuGNpQjGW+UkMQFl4lMG7Qks5iqFoLFmjSCWMnx+nuYgjR6NVfzYza/HwSEH3cR52qu5mp+f8zwWQPGiNPxAjt3qHs5UZ6gZyof9rZw0uOMORNjSjh3OY8/6KK6rwrbd6uzaRq28qw7UAn7tZs1TFWdCzUhtWr0YcNkq2HLDafenGRuUAYPqMMS3a1JZzn6zpj1RkXxPfy7lyiPEpalyd7DmO1rJTc/VLlUa4bP71KvVpTGEOkCmlfXZA8nuMEhyvYcLZog+QF1NaHR+uh2gG3n9M0cqylIn+VYdcPRvkoYebQnNrWXkikJ0sxHt46Q3EdUa4UmHSDbc5qZSmnU6LaHZJQk2xxrd0bdPN9Vzx+Nd3nzp7yOzj88UPn+I5n/4Dd/l/zdr7H52Vf4zlsjTsMtB67gRBSoyw3aZstTOWX3ou6qNt2DAMsqKHKJQDExLwqiXs3Rqwo/MfBQUoNIK7h1Z4dfqA3a5Qnv3zuFiWjjK0ljlcQa8fzLEj/xypR8bnOsxdi6SrIvEdxbcPYg4+tfe4/l0xXhzCK0p3z+1Yj75wuSBQyMPby3DTZHQ+LUJlRFVOSSYNggss4b1yIvPdyDiFxuKEKX9TWZuB9TDp3u0JsXEpdlRnI2IB+3tNM5UqmgjWQOdI16nXOR2yzzlKmt8YWBhW8pRIuGy+BY2LhZk+AJ5uDODqOblzTDCa6dcSrbzLc6thszCxPc2ZrkJ4bsxBtqEcHJtyT1liTz+aiJaIMZzYWHdjhh3crM44cc4DE0e8RZwjpbY2Gj11YnLhRmztZcogtGhRAKpJaySjFspzsXmYhoAh3jQO9EhQZhWpDE84YiFnNN54LWZJNaOKXrtms5EaIDak2uPkStb1MUbXeuaGlRNb1jJAjGgRCsvNLrog45OV7m/b+cEEIYkPKSjZl0zwpm0iEjsXSTVnAQRDWkWNpXg45HIRsihtF0jAohWAhXgnguysjwZZ9WtBNm467S8ocmJiRpzqyVOk7BRWvxh1+9xuOnSz5MSk6XG0zDxDVSLLWPKfgJekNVZUSieFY28QcGpsjkZw3JWhBZxck7QzZaiGuqQLQAVB3Uoq1M7GHLbs/qnAhqrbLBxiwk+kpNEMY82MZMZsKOHZKcxmj4yM4umBukTprJoGxpLWG/sdHFC15lVJ7CjaM9bu36NCiski3ZWscSNRm6sIYIYEbWqZC1YXbbfbn4JE+PrFGpTUfoR1QwmgY3HQ0/y/nomcJi5YnvJmab0bbiGyEuMp1glVNZCa2ZkgYaTtqnTGM4vI6x47Belrw62eFzhzvorsOkZ6BYMo2jErbgZS2eYRKutniacD0YlO0cI1ahDijEVlsRvyYgkAV628cxdVoppFhCUtiowlYmxBS96rbzAoSTNR5qG4MjXgkZZVEzGApQYAXNEEVs7UOHoZHh2moXrwithNPARfczRv0tSimRZZ7oeOjeJ4prkC0rdFlmossEsc42g9ZqGQvbTd0S1jp5bZKmMVmZ0woFTMBFyozyMkc1VGJxl1ALJCUkryq2ocWOX1OPVFy3R9KUmK5G1szQa5UXRvsscKhSj0F9xvWDXUxln8o2sDQh7clYgqWotbRC5ChKakXULorvsI6M3FmF2qbp6KxNKRw2RidqoYi+WomyVTrLkLA7aSImoOmdS0FqxM2hIo9y8lpGzVQMy6QXe7hDn8OD61xsN/ygKWjzC2orQj084Mht0DkmVWPKM4UicVicQHJZU5kLFKFi9griyuqqPOVtjlc3uELSdQZg+xyaFj3VRqtFS0hOKOlstjlJXFLpCZmyoWf3UaSa4hSa0kTtx/R2eySSTbQIYFGgZgmhoBZXOrKmkGc6ZRST3wx493z7e3sKuZofq/lxOND+KAkJ/8/X80fpa7qaq7maq/kvz0ftMxxdUPz79C2LTZpx4sak78D23ObayxeoKQRRymJt4pZj6mZL2NZMdAOrCilamV3XwZQlTA3WERSRwUHPRR3knLgpVWxwo90nXac00Rh95JDkNc1ggTTrs3sz4bXP3eVLn/b5nW81/NI3zihTCf14n7k+wxv4JPfBv+uTn22QxwbS4/iTGm6zoBptScJ99uWCeTTubPpGapCw5N7HG6Z6zgvXeiSWzINjuHgmmGQiXiGeE0GdirPACokKXV+jjy3qcIjd81kvz2nLEn1XQUodlKdL2oMtftXnU6/aqAcuxijHuKfwd/+9YzbON3nF+Sx//cm75A+O6E+H0H+GLO9TrSqaZoV6ZvEDo2JHWnHoaRwYTlcNPgs3mJ7N9edkbkxb0m1EtN7Q1kLQ6DHsD9i9tuT9U5PsTCNXIjg0eP5WnzdennKKSv1BxuFrJZtrKg/jJzx6r+T82ydkawuuBxSznNk73+bemYs5+DTB4gessxxjZ0Nr6BjHDq4fsno5ZxAOiROfRDxPr2dUA7GkOmSjVoxK0M9MkrAlbjOOTyVyK2Y4KbhuuVR1D0m0k2USC19GWVoUaU1Fn2Sc8Oj2jDqxeS3pM4p0trWB53nI6ZZVrtL7gs8X9APifMZHqzVSk/PiyuZEsOSiMS8Vu4TGCTtyyfGmR98aoKkWRyUkhkM1zHE9hSCSMCsZQ9Q8FjGL+BLfHuEYbgcoTJuaOhICUkqRxeiGg6LpyK2E3CrYrdFFG5RG7TgFHfxQVyjyHIQLQTiiadgoIaO2j9zqZCJqIBud4JAXFY56C7HBFmBHWREIRa2LJ4jmBqQKRe6ICdTUqMLV0AjAokIpVR3cUcAinUqsrxt0XUQYZFIlpNQK/GxEXZRds2IXF2glKrkmVEQMxaSnuR33wZGbTqAQ56E6LmnMH2LM4cDUSVSDD46fcBbk/Pz+awyfdxg+OMGlYb6Iu/yGlMaspGOeHYcki5J8W6PrCtrYwHBaoiIjSkJkhAJpUeg1RW0gZcJIsqF2VBpVZ+jpTHoaqWSRRC2yEoItCPs6uCU3W4lolvPkSc72qbCImDTlMwxGYF7CZp9SFVUdIIkLW9+hqSs8W2E0FBfGFEVNcaVP4hEhFUWto9cyZS0h6xKGrFHnGpVcYChipd+SCl9Xk1EUFa7n0rcVoibpogcyLnkZEmQSsRpSuxqO3MM+bBmMLEb+AMYj9LXMxaVL9lKP/+Ebb/ChoIumKVPNoc0rSl2oRApSLWotVcq25my95qNlinm95ZY/RJJttsWGLF2Spx6mAY6fIkoia0EH7U72Hq3v4FNB2VApIypPxVIzpNokyVX08hMQoChPlFzBrehj6SWuqrAoQpJ1japbjA5q0lXEuFejmIe4esi2NCiUCt3OMcscUUVaJZ9AC3ORgxA9t1bRtScoaFSS2Vn5HXHxhznrMCYNhDij0IjteatAJpHnKefyBlP26SvTLqIQLe9TrnaYxB72/oTBDZdal5mfuuzrChOt5dmJib1XYu+MuHWnh7c/ZVnWXcuGkemY7idigHhtC0EpFZBFqSZXamSRf6tED624ZsSPiZyiSbsKRgE1MdqWqm0ohNVJABkbqPMWybA7QqwsbiDi5ixJHb8gS7JOJNEkAzWr8TyHu64KyvOsyhS5yThX10yeP0KuT1hNVLbHl8Qf6KRtha4IlkLN2K3pTwOi2CeaFV28xNuzGQ0M6ibvKmm2coLWE7WjGuGyJi1KDNEzrDSUrUmYJTR1TBiUlM2QgWzgSg3rxqIWLJIn50RVySYTTo2MLEuJakG0FT9kLzmx7Kunqqu5mn/CosyPg4hzNVdzNb8/5yVrD6nSCM6XfOtawJ3coy8Ofb0tLzsqk3rChztb9Ms+B744p2Q4lcfUchgpMK99VNWgp0ls+wvyxGGdqBy3Z1wKe3wAZST4W/tsVisifcPuS3cZ+Bc8fKARNi9wdE3nT/xxh1svgTv5PJ8yT7m/9jj93ttMxMKzgv5lRjstCJYhmr7P2jhhbB0Shue0/RrmPn4/JVn2yMqI2gyQLsYUWs1aHBgfixrxlKCSOXlcU4gmtVosmybUygytXiFlDZXq4bQOlaGgeSrNeU5TqhjDouOWia12Jb+C5uW02wEnUcBnTiTCMuV7z1SS9Qmjox22yQo9vY40EivTAa1W0D4Uz9AG5U5Fb5Ww+eCU7SDAmg67w6Pgx+0MMl59eYhzzcCtxRnoFFnPCU407n3wBHH4sdWSnUHN/dBC0T1ev+Xx6ZsGYZhShylPFinhRznVwuL4acjpb70Dpw6lt4tc+/T3t+Ttizz86JT2+jdgFeP90UPcsz5plpHEAZJwyDZxdzCWBy3aokacKMpwglQpZMuQNUOySmU7m5NJBeaezvXRmOvNAClXKA3x8aKBwGFbhwxzjUMj4cZ01PEGTp+1yMJlbiU0lk6dRuRNS1H7PFkp3L5ZsVirnNwbEO49ZnDtJsv8gLPHIXZxjFE/T6raeKK97rbMoO+BtcEONVR9yN6dGYZwA8cpQ8/HNOzuDDOwRrhmT3S+dSKBJNdItWCnleRlgqeq9AybSrQiiLaELs5QoegNhVmg10YnJGiKSl7ltE0OWUvP8MjLvGuK08SSvalIigzP8lnzfcz6JrQixKx0v69wJ0D5yf8rairFwlNqugWE+NhKgCAbsegU5ymVthTig1iQC3ZbiS7c8bVBKZa3YrUqohnin7LaubTb+pPlaNXxGzJy4dQWsQ1bRRHiigDI/bDEhEulIN76nC0i6mJOkY8Z9HqMHY8BEq2qkpUp8yagWiy5PE86mIMubPd1TCIs1rlCXWgktYkigiB1SBEVpBsFUUIqqSlDt8dkTyFV4eE6R5OENT9Ba1PUdUFq9Gj6Ht7QhKdz0oVGnq5x2z61ZZFGMwxT7uCEjeR1DRO6KZOTUfdddnYG+D2dJIsJ1QIbh1Hf7HLn21AcLhuwajJNHA9rRNWmLDwoqklV6dBmXSxD5OR7UktdZmzCXHyfP4kZoDIc9XjZazkYH9CIw7US43kmvu90SqK/b3G2vyI6MLh2/To3VINH548wVwl5ITbjoo8kR1xCjiFTpaIRoeDz+2P2dh0cUYVZ11w6CpmpoNtD0SBLm8dk4oLKU1CFHV/FEAdaXSFrmw7KqNShSL+BlDBQU3Z9ETlRiGsDU2BFrRZDt7Clmsmpy6P0IZq6jyn1mboGy6Jh6qg4Ta87QK+rkioTkRVBOs2Q9AbHtMmKlqoWOTZBXizJ5iW1oO+Oq44mmqslpaJRCjVOZHsEDVfg/woNrJwihFpvMYwQpVawCp2aU+YX+12t5u292/yRvQn/l+Wyy7Ddn22IgpLDSQ+l8HjnIsPtn9OaFkkdo5WCdPqJICdcCpou7Emi67ghl2rqquwsReK/ifySjtkpd+LPVAjnhCpTNgJPqGBrOrUwhWRCQMmRNIUqLZA1o4tQdM6OWiETF0/ZkOY5y5UonlQxbJ2bTh9j9B6eqfKxWlCtfXbcmuFwn0vVYnm5olyukcpbbM5zCrslEVUuQYS+nXbfS11Ud2QJRVBjTZwOspgmJXXoYQk109UpGreLeChtSRk0hElI3a4xigFWEECRUUUlQW2QZhGN0yOsI6RZ2okf1Z6HPc+pXO33+BhyNT8u8+NwoL1yAFzN1VzN1fx/Nz1J57vNJTtzg7RvERclptQyvOsyzCXyzGJnHmM1EpJrUkk+Vj9jgkYihZiZhJxZzNQLVkmCdeZhFCUv9C0iXeH8ssE4k4n9hzy73FKGLpK/JBWxiGSLoxnceN3j5YMX+PjpKbfiFa/cUtA/+xL/27dP2Nx8hv7+DvVzKYohUx6LWICGNnPJXBnXH5LHBU0Z0yQtG9FYpfTJkpx8usEa7GOECfn5gneSEXLnJI27XHxWKgKlBa1HsG3x5Jy+pXVZ9CIu0GJPWCww9JYym7K4iLHEhvj6GZJwlpY5x4sWvhWQbcacHX+I1PrYusL6MscRi0tdVLXXVFuFQttQGwp+PBTkcgpbpjnX+KC+ILgl89m7h7zyoo48XVGnNqtQQaks6rzi3R+s+daHS+pezbVpH3tnyG1d41MHLjefG3J6vuLew4iPswviewvkjwvkkUT7ruBB5FjmlPLnFgx+yyR0TMyJAPHllA/C7tnXMz3kF5QuYiGbBtnXLyiaXXzh5l6saXYrfE2j2SaoRoqRS2zXEWkok28ijJ0pzktuBzE8jwTPK2Q3VzAsj1rEd8Uzs+PTVhF9ATdMW6aqy8VK5ZEboDrCvV2StwpmmmPqFmYY8M7jE87KFdoHHi8/p7Jrw/tFw7X+iGW0oW1STMvDsWXOrPvsyvvkoqGhqRgptzhfC75byMRzKOuMPM0xNAtN0Tv7f5yLNjfhIhC+ANAUEdcRUgcYutEd+isaJHEyEvBM4WYQR/e2pRRtCoJH0ApBwOjOHZlW0MPrnPCSAOhrVnc9WdIRquATIrHOl7ia/4moQEEj3NHChVznXdxa8BvE5xDwR1kxUWshO9QoioogkgjBw5DNjskomtzyRqGVRVV8+kncoi5QhQdbMgTSjloSrQ8qqvgzthKFaLKwxNfS/hDbHAKd8+MLmibF9RzSVMHNRQWFYAk4GHZDLRs0uca9xys2W3EUttA0ASQUZH/9kxekEAqfUK62sJZpS0GWFGpJg6nbtKXM6ryh1RpQKrxhxrbU0bcGRmGjjHPGwwF1KXO2ronmK6SyQvUWyKKawx4Rb1foZYSumbSKSq1OyYuI6aHJred26Y17BPMUuUiRVKfrsXU1k97IoGoKKIUboCUsJDK9RhXeplawGloUQcwUeRdHRnXVzl5VNy66U9KfDHlZHZMOtS5LI/ctztcLwlmLtt6CsqWWfPatjEYykTKNR73H7ExkHs8vOktRe5og+waHrkqldiEL6jRkQ8FrBwOGfYc0F1TPJV6rMNJzNlpEljXEkeAUKDSVyM5nXVxAM2ycVuAcxV9rqjwhM1rRNILXm6JYMWVTYG4V7ImCJRwecsasbLBSkzZWWaoK/oWMc2DhiHZYJSIyHOo86xokoiIiakzKRsGMS9p42X0fBDCnp5VkQ6O7sEVdim0YtGpFm9VkUkmu1kiq+48FhghDvDHE15sZNGlB2G9QhIugafE0k5yUJHvE8ZnCh0pMsclRkoaVIXUC064DUaKyvcjYHJVMpBa9boiFeFEIWIrasS/EG0a8AatcvPEkTNUib0qqsqQS4kLZorVK19kqACutLMSuunvd5OaTX1MtwdYQQoSIUYhKlppGLdGsFrMVMBSpi/yEjagAlQlSm7qIsPuXVDsSrn6bPfM9zuwBmnKKzRHyi1t27siE8z7rC7hY5fSOdeoqo14omNcS8k2LtE2pGhPX1Bm1BlokkSRZ57bRRSds5WN28Y4AEcjSFAezVxEEKVEhI0UGZbMiiIS6K1wsIU3WoJQGsiVzeGh3tsPVRcZ0ev3quetqfizmR0lIEF/Lf1dx5sdBxLmaq7ma379TVjmDokexumC80DibxFi5gptqnEhz+q1OcNwj2y0YayUT0aQmGZiVhjhrN1VLUOZIGIzZI1RUEjNE6vepiw3K5YxV0mMdh2zerXAUifZWzWq1Rtsf4c0uWYQtv/i9j8nmKZdOwHO2jtaoWKMh4SWMzYh15NGTA8h3yK0TKtH8lT+gMO5A0XRQRGMDulVgChO5YlE7EcVqhZ5kVKFJogQoiU6V6ci6ClHQ5eFfOJqgjE3ev1SpIxlVMmkuG8p+2zHIVM+mXpyiazKNKVNufQqxFLVTgo8mnJlrNtmCNlJoJYNkFYJZIp/cpXo+x1C3VJc2befUlpF3TJxNQcq2c02LZ/Gf3JnwxhsT9JHGJk6p5zmlFlBELe++lfHtH5yzjGp8w8S0LfrTXcZ3NrS9gN98tODBBxckxhmrdxKYmag+VMcassiomA75cAQf36Pd0SnyCe3Fx6jNEA4nFPoae60wcFIencrsHOSc2yZypbJMAioc1NoktFb0+oCtkBViW99jWCa0ox38aw7DRiXIY+wyYaia1HaB12tx9AHPggVyLFGWO2S+ysJ5SmJL+LJML1WJtpuOpeaYPdS+wzAb4JdLfvbA529JBiNLx79ewjzBt21ee/k5FqMVY7G0Bjy7z6mSEUctpmpiGS5ZpiLHJZr4WhOtSwDUcoMjzlCa1jUdiE2/2PxXEoSxRZzr3DwwkBThHii6Q76s6F37g1j7iyVoKVzfAnBY5eRlhmaarLQlfuxjKXa3sBYVjU1TUpogZxKa0heAhY63YDduJ1oIMUIWy16pQRHMNlVDkz+pphRRCIE86CCNctMJB+JpQZP17kwiRtGEA6FFbSRK4T5uUizBbGhb8jqhaaRP2iZUnUaqsBq7W+4KF4ZoiRCCyA9NTJDjhvX6lDoxufuqw2jgdxZplJyIGFXpfUKal1MUp8EoLLQwppJUJN/HFvGFNqZpC8x/bMEXN4FcHMybCsM12L3rYR2anK5ifKPm1aMJ48EOizznNF7QNhbXJ1MyX+Hs6QWbxw1lruGIJgK1RJVaqs0GrdapLPHNgjotqHKBOLDYnfqMd+wOUBGIFXWjUOUlWWVQiBpAxI1O7HKlznEgRU2X7RKHz0JkVISakzZImofptZ2NPQkTwnCLp4+4MbFQfWHvSYm2JUp1QbJpqEJY5JfEsUG+mfE0zrobjZLrfPDdXfrXKjaXAWld0G48Bs/3GV7v0/QN1LomyQt2fKFO1aRlQBY3hOuIs/mabVCQhk0X4ZBkEShQURTxcZ8oTULJElRPXddwLZOkspGNJY5h0HM1SqVlW4kDpIlXCmdDS75do1YOubdhYiis9ZgwU4kjsARspKipopwsbZBtl6JIkNsWX+SHQr2LgNQu9A0LX3WxKgl5krNNUsIiwMVgKOxAZsU2M6kypavOsVSH1isoUxE1aUXSByWVaBWLVtIJNQclvsSMJwzmjzi2W+xwjaLu89zhXfIbCm2W4xg19VmLLb7xaYVjCGVYgEaEO6CibZUuOiLnNWrddGATSZW6CpRKVimoSNuSTGrQuvgDKI2Mripdc4ToeRUds0IV1FpR/aJTi0iBqPjMxZtTdMc0GLXeuRkK3aKnxcTihmXUFKWCdeaj90YcyruYnsJGH6BVAZpT02wKGmXKoLfm5Lxge1JQxRmKJpNtNxi5jCRsbZbE4FDceKAQNiZdxVQrLEUiJSWrU6qwokLBsSRsRWYVqxSrNdvaJffLDuio7UG5dLqPbVpxfZm0w4hKamlvm/THog/nav6gz9WB9sdb3Liaq7maq/lvmzytGcoWs4nAw8cMA4czP8N65nORlRRGy6ioOnt0poqGMJ9GyzqLdi/rdxXoa3PFxHKpzZq1F6CsVVZNxGpWEDyV2dRr1FjDjSIybcs22uHg9oCbRY+Ptj0aacytfspHYcPvXhR87z+9xFFmjG6Y1PdhU+XomWg+aMjHc/KnCS2LDsZe9Df4izWldo3EarDLmJwzWs2nXFvIVoM6GqJLDpoHhrGmPC7JI4eytDCfl/j8H+/zxesH/I1fb/kH//d7aFGAZMQIEqB9s4cknrmWKoXroRkaaSxTrxoUW0Zxqu4ZrVIEIF3Bf86FeIaiW0jGQ5xnBtFYLDN1KGvkAw8pnZO2Gqlw5o4U/tmfeZ4vfFbtrPhlYqJUDarZkh0rPLo34+13zzldxkx2d3nzpX1ef37AOoePFjn3HpU8fP+SfP4Ab7iHa45o9i8xbvhE75bUVo2ZuuCvaGObQOTmyxDJ2yMXVeS+hKXOya8NOXtmsF166HsX6GIJJ9WU4xIpaJAS5xOwuVtjXmgkkxIpPWZbWMh9j+FwhRyNSJMRqneO3W8w2pvkkUmqb/h/sPenMbrm53kn9nv2/V1rO1VnP713s5tkNymKFEVRIi1Zlhd503isTCaYIIADJMjnCYIgH4J8SOABkgAzyCAxkhjIZCaGHWTGC2BLtlZK4t5Ndvfp7tNnqb3q3Z99+wf3v1qYwcCIPRYzJsd1N/pDn6o+VfW+z/vWc1//6/pdienjbtdkXU5gOXh1TLtscEaNXsozXAK5hw4MPjKfcV50uu3v556f8NWbFqfpHtmTI86Wc8bDfaIk4GLRY7fSuuYiNRJ72Yi6XFHnJfFgW/PSpCPQCxp8tyYXd7fV0qmOTbvBk6izE9D7sqlb+H5DY+aaVVfaBYVfEa8Cfcgo/AKJHOhaSAl52yJiXB1CuxIrEJe07Axtq/lseo+wJWguK1vP0i+ISpu+VlpQavuWzKnxewezM7AtUx++y98vB8GO7dF3Pa00M0gjnfZNyPd5dQAhAH45kJU9QeDurnzICfTnqU4c4SaeuCVkO2pr7YBQDfgCfTQtyjYn8kQZ+hGJCe/ba2Z+ySt727x1/w6hDxeLmqEVslYrLGXiGmsuc+14JzAq3WtfVwGeMBOUsPId3FDReJL3EFuIgRgU3D5A2YqNa9JJBt9vGEwHbIKGTbrAyA3yzYLA61hZDmOnpWsrNucL8f/gTjtqQxIIAhkUZUVUUJOqlKV3A2ZMvD/hwd4WthmwWqxppQKwlqYFsb43WnCozZrEkxe6onEkamHqmg276HBUhuH0SDDCNlxIG606lWmDXboaEjOwTGrDRKUGNCYqM3BLkzBpsP0tdoRI6w+4OLtkWa/xLnLmz85JHu6DmmtVUN7kXrUsEleEFotsYeLFPq/euU2YuJTi4pA333nBw0drjs9t8k6Oy2vt4RfdyXZ6PN+5gnNKfkccG0aKmVu4TkwQ7LI18jWAUFwAbrVCaAt16+hu22o1RIlNadCxe0sgHRGDJmP1Qcl6mlO5A9xWYTU+oSfXgDyUBpa4OlxFMPX1f3d9zawLcdxMvC3UG6XFo942iRxXq3ShPKdZqm1gjlxDjoHlBTr+0PUTDT00apPWKfDznKY0MFxF3tQk6w0jbGZtyco3+fWX71L0Hk8mH/PUL3E8U0cRNqaczHtaGZd2DgHUqEqaGARS2eEJ60BKIOVF2ltSLotlCgdB/rFo7B5LRINW3AwSg+DqGlOtfvHbtoXT2fr7L+VNyTEoVYfdKvJ6g2H4qNAgkF9ebgOrPVzPJM+OsMwxt/2egz5hE27IuzWnbkRtd4y3VuwPb7MaGSzPH1PIL6nLEsF3RG6EbXZUZc7psyX9xGE0SvQbnrh6rD6lKRWbXKAwNmFiIgKrH9YUCwHBXGKIoOL3OHHFbpxAHLCpzuBoSNYutVVtd+c2yp9d32Fdz0/8/KQu7tcizvVcz/X8655ZnaIME7twOVZw0wpo1jlVvgCBgDeK2HWJbJfltoLCRMny3FWMeo+VxFWVgy9878IjUh2XZcbpYcP5Rw3lmUkXJUxQWOMhKoj4zIHH86/f4u3vLnEnCb/8xhY3opatoOPvpgvmv/WU+vYG+4Udbn/e4clvRFRhBMWGW2uDj4yppPepV2PceEh5/xj72Tm9O6Cp5H6upcqvKuUpoKxbzP0CZ2lr94AxjGkT8Cc3+dWv3eDrX3WJt2/y18TBXip+87e/Td8U2KsQnp5pK7k1jFFWrUHwNhlsiSs4gLsF7XqL3vgB7uYF1PKYCo9xN2b+Mx8S/MNdmJpYIxPKgvqoYGhtuOQ241emfP2Lu/ziWwNk/djMWgyjIDID0nbN997Pee89k8t+wouv7fLF13eJpwlPZw2q7okDk5NVi7GeYLQx6aELL46wrKcYgTze0DQG9XiMMTvC8AR+eAu7XONOfNSTBZ7h4o1D7InD5TvnxAL8frrWbu3cXOCcudi7C3qJhKiEfHGGcj29cCvh0IUJysrZLBzGWz73EwM72cL3XOpccZnlhBJvnrqkOxXOsiGT6lCnZlo7pOuUzOvZdUKazmKxKcgKF3m4DquIb5xUjCYNXb6kLiyWJw2Tnz+nM+6wCExGWYXaWWNFFsHGYLHcaKf0U2PGljEmCH3qbKNZH53KWG0iHXHY8VwddZfoguwRjcDfPRgPd7W7WSILQe/SmjkqWOO2N/QuUaqSym/ZaqXd4Y+dDZ2EnfWSrpSc+sufO1i2SV3KYbak7K8iBno5Na/YBp5gAnSbg0gIrRYKZA9xbJ/GPkU6Ws02omxLLMPEMXzKbq3jCYk91o5rEUZsw0YpyTNISF12RfG+G1RtqeMXEpMRcUM+R1wY0g7omFcAyB+ZmPCV7Vs4u7fZutGwM9miXaa4kv/wO6rKZ1WeUVQNT882XK4v6LqArhfo3VKLCIblsz2JZMdmud6gagNVldiWKA9SzWLgCWii99neG3JrGpLWHU9OT6hmFqHVs7vlMy86Tuc9Tz4S+EePrZYoAVx4IpdKxV8mlQI4hXAMRB1S+oK+fRATj0Iu85q27LVAUAgnIKgw7U6OdnVEo/JtQtdgy3aJ3JLZRsQRgQouQTm4vuRJUtq2oxVrid8Q7LhsjwVXGpKWJW2XoxwBOlrUto3d9vixjdMFWL6DO8jZrUKWO4rLi2PSmfSBDnAaj51bI+5sDeiSELdtuMxm3BkHJImJ8j2sjXSMrGnsiqZXBJawCDKytsXuB5ryKXUerS2gwRDL9FDmhqrsUZLXsBs8cS5Yplah5AKL3VjbX0zJhtUFntXiRba2gU3cPRbtEYuNwanESRbS35kRlMIzsHANA8N26MMSK8+03aYW6qhZoSoTtzYIwlDXkEgloQg2RK22jgVdwLZzVWW4WF31srZNqRd625HqSh+zl8DYClVL/+k5SiXYncW6DDEOz3DiKc3yiGLo6N7dF0YPsJKQ1c0JdlqgzJKL7oy4jvEtT7dztMYGWgEmmrSmwGMajAoc16C1O61SioggPasiHggpQT5fACqiPCJKo2vp6kglkFaz0eBFga9YuIQI9ETYEC224ZB2lc5EGeKc6Uwsu2Iuz1t2iWMNicwxQbWisyaQQ+h33BildN4IN4eDuzW74z3mqc3sYkmX94QkmgHRpOiYibFxsboQ4hrPaDRAtMh6qtUKz/JZnZvYTkUorgvToGyXGKsYQ81pYp+tGy6VVzNYTtnZPmPNgM72sKwYo71uc/g3fa4X2uu5nuu5nn9zZ17XFK3PrcAi9kLtig1ri2WTYagFe1M5qHKw3A4VCXw8wE1j8nrNRduRr0zGU1kOe46OFpysctLaoTjraGYrWol9ZTGFHDQFCV/8qQk//YLLd9cDltOOP/OpCYFZ8EcXJp/bdvhzr+zxm++cc5YdYTzpGWxNefFeynfeL2nNjLkTUZcuKnpKkNyjmEdYtzxU3eFlS9oowFFjfQipuWKdRZeucMQVW9xgvRrSxBZvfM3kyz+zzcu3bvOUjvXxmi8c2Pw7f/EO2Bv+yW++h1Pa+h41LhXFno1Z9Zj+ClVU9KMD+qil32RUFz6+PSSctixXZ0ST29hxRnMSMtgxcAcm3qJlY0WYz1Iub+7iR0N+7RcnvPm5PU347y5s7MqgGz7l4rzl8XdWfPjxhuPA5rnndvmZ57awBjbfO17x0XnJC+OYN7dCLg4afjDLsC/2uLjo8c8qzGnCRuUw3CbsJ+TrArux9MLMPY/evsBa3sbO5RDQpz67CScj/MXHWANFuarprLtM+ifMhwP8+Rat9Dl4Y/pihuEZMFP0k1YfrEqMNr+s2XgFt28NSPyIebvh0D2FwGSSjlgr2DQbhlnEym5IB+e8xj1GnUHmRozDOe/mHt6lz7hImE1meM0AtUl5ZjQkTs72cMT6dIftQYlpmQSpjeV/xKT7Ir6TcVkrzNplvL2mtqeMRxLxCFincp9usT28QegZBK6JKdEA7SKQQ+yW5WalmQRxKNw4Q9YHZOE2XOeTOIBA3E3qpsJv5cBa2ARX7l7VS6zb1AKb3FNJxLpra72nab6fgDnKUi/xOgLRm6yiFC+zRGLTcEWBJOoYhTgHlCDpJE5ko0wLs5PDzStHgRzSiyAgLAdxRsjntKql6Bpc2ZGNTkcnqiqnlwj/J1wG3wzIzA2b8YbdzRTDvAI3/sjEhOFow/Pj5wmGBrnsVn1PHMnJ6JqJE3OUrzk/71k9y0jlkLyLMLsz/cTXKiQcDokmA7LSwJeFWGRAQxs1KL0Wczsk2bVwdyOiYULapnSmYn8oHa6yHMXaIuRRcTRTzN4r6XMHz0up4h6nWuNI24WAHZWL8iNMvyM4dzF9m/29IZ6yOJVYgKoJLF/WSvzgqh5QKAR1n9A0itQrSWyDRGdTepaFQZX5VFWjSf5GIHkYk+qiYJlVJBOPnVgyFS1dUdIJmLEUZ0SJ6Q5ow4SiqWmk6k9JVmuHJFZE2wt2d5/j+OmM9ZmIMksicwtzOgTPoFyYmvQa+DGSmpLj+r5t6XNZ/B3GI8nu26iZRA2uLPlKTqtzMJoGZRa6BlG6RJUZ0JkddmNSZOJUyLGNIaop8MM9DlyDOi1Y5+e0M58qdpg2Ab3jEimDyrGxxwYjUQ4lt9OYWEOf2ikIVM/IsVBuQGUE9G1HWeREqmAQO4T+DonTs0kUnZVqIGDd+KSBSxAJtLSkMpV2efSVACQlVyBNnCa9XdO5NY7apt3kiFUkr6TmJyKzS9ic4qzk8x7zW/844KOXn5CvpQrFZ6wKXacSy0l/3uLgCYWE/o+pp32N5/hXb3j6C1qa2aCUibI9lHx9cR6I3mB8Uh3ZtJqUKo4PQ55L36NrGhrtbZA3DXExyNcyME1PRxNqcdKUFqOkJuw8NobC6CricEChSi7LEN+aY6hSuz12DcWmVcxMg0DemEeujuEESceW41Ec99ge2GZItzDIiwCVC79EQBjSOlFTu9IyAn0lkYcr4U1JM62y6Y2adG3hC0Bp6NAVQh4WQWSJY96kC3uGUYjtij3kkrW0bFzP9fwEz7Ur4Xqu53qu51997HqbyjpiMBqz9HvyssCOHezSZ2wO2dseMPJDFnWNt8gpWmFgJbimT03NMDIZ7gXUVcbyrOLjp0q3oKmswHMc7LinXRmoux6f+ZmeL7ywxQ+OFcerOT9/M+bWg13Sj455ct6BmfPpFwIe/JX7PP5HJdGjjsVWw3R3xJZ7zsXbjuYzuGcZ3X2bdrvHqB5hHEprg0/XrmFxQsNtim5Fr27QGxmOk9DNQ5ZVTes5fOHLe/yVX53y0u4Ox0c980czVJPz6EWHOy/f5qv18/ze5Yz62xvCtMeII1i6+OK87gp6YVCtezp/TvOeR/xqg/ndMe2tBSqaUK5y1rZDcwTGrWPaKmGwGHMhbLlRx2v3D/jZP5Xwpc8eaHjlci7tdxm94fD4WcM733vM7B2XeTdk9OmWT73gYxYuv/9ww7PZnBvjnlHgsehj3rgrJ7kp79sdUTu74gSkIaot4c4My57CRwW9ZUDm4zXnVM1zoBZQTVGH56Q7Dd77Ce0iwrgzITAKXrs3YMMdXvdq3n/HZl4u6a05vm/Sl1I9CLYA7I2cYtniFjFnux0JKbcKWQAapkphyed6FW2xwUtNzMLAiGrcNMLqanrfY+LYZAIV7C02jaKczZj1LvZqIQZ0KnHBuz75aIXvH3CwHtMMKvzzjOD2PqF8vVnDBxcbXt9Pr0SBxsP3ZxRFw2W5xXbQMo08QnGHt4UGxEsMwbEdFvOO5Uqxu9Xr1jlXOAOWoysg+1ZcCtCKu96Qwnlf70mdMNhkWRChQXYD5TIzjpj2+3o/qXU7g7SfyOGuIABMWlJMEZQwsCuTXvYOx/3jkx3kH9k1tEjQR9pxLUgFS/6iHs220NWRzRi6Tn++xBhEKHHkSxjSkGhqkL/sOKEXa4eF/BxyFiy1kGEjLAaLolhr/uC/8P3hX/aN5O0nH2EUNi96e/SGq4ETTujgOhNCVZOqgMfZR6zyhj4NUK5L58iCPcJwZSm3NP01LYTiX+AEVxRJQwQAKr3wMvCIh7IwtizOxJpjEw18htseVQ1PqRh3DVa6pD0qdN1F5CVk7hLkRLuS5U2qMnoE8V+Zps7A3NjfIp76LFOFWwTYUaXrKo26opUXrWvgu5Y+ZjY0LdMgq1Jq5RC4Dlsh+ueT/tS6tXAthd0ULJcpdRUxuBNA1JOtFY00LyDtEbI4Bxr+17YmgbZRZfR+RW3tUhodUt0ZjSwO3BtM4zMWq56qSzlTLcPMYJGVGCNZIm16qaxsVlpQMOX7sl22tz1aNeB0nessvs69GDXIxSd9pwKWqaE2WoauQRAI1bNhU7Usqo6hX5G3Np35FC+e4Jodvutw3th6wYSYTfKErh9jWk8YVjsQFHhCqR3EGO5AW3VUXuLaIb3pE0Q+RZdRZRJZEFiIJj1QyxNoubpuU+og55c1pWFi+VKn6GooY2/VNGLrCaSftdeWKM+TDJ70uHb0zkDbeiprQynAHg30rPB6j+IkxfvWQxaFzdC5gxQQZImrK31iO0T5K/3YGkaA0dpXiaOq0dwLYQqIdczs1BVwEdhUFaq28WwTO7LofRtpdSG3aIUJoW0/EkIyMAwT17K1BUmyY2IJas0exzbxPJMRPqnfMywDarOnPTel3lVfg207xxFbE5H+BdfmHlVh0qYukTHATc5RSYYXB7hGyoXhE/qmrnDMmw4ntGh8j/XFis1sQb2KtCOnbkSAMzUrIzc7OqfSsMlAQEpmjlXbOmoxcgYIFKKe9ZiDhmkSUfY7miQrma3MmPDWjSti7fVcz0/i/KQKCddzPddzPT8uMwldXZUeOhFUK4KwJjRsaoHspTex7YhOraDsaBI5novJVcu4RFu0SQy2vW3WeUu5qthsDDy3INq4tNaIPukZvDzm3tctfnFvxNHDgA8+PuelGz1+MuS9zZq7bspLQ5cPzm0GvsfPvnKD+nzGbzlHOEdzjjKL8Qs3CD5jcfZBRjFaYNe38M2UjZHhbbZpjA2O8KesGDElWyqjdJdEc5u6til8i+0Afu6n7/K1v3zAwXbIx2clxyeHhAupH2vZfFiyjitefDXkV37lJv/pxRm8K87onm4g1eJy4DeiNSzsvkfNLfyqomgTDO+YtLNxLyMqZw7OFlaaUi+Fmr/N/HhNPTX58794h5//0oTxpyLIAvKTgq45ZeM0vP9+zzvvrEg/mrOKp7z0xpRPv+RQNBV/9Oyc+axib9Bzb7/HXFa884HDgxc8Xrm3x9Ne+GEjzMWabFHgeSPqIsXYvcAPb1GuPiL0nsd98Jjmd0OU2oA3ohtYBNGQSj1BWbdRy5yX7m/xwk+1OO3LXJ5e8l31PpayyVMfL4rwvZrerbFzl7qQA9WW0cQnGVhQlSzSkNJziLaF6xbTLS2sWhHaPZ1T09ZrRsaI3FpJjxoXVc5x4LLVVZz1IedNyPC9C1bRAYerYw62tyg3A47rQ4JQXAkG6+yCeVnjrW/iuhsu1nLImjLYXnB0PMHoGspswmy5wTd7Yl3bKIeGwhATB4ClGRdtVdF2GX5kEA9lF7lqeRAXQtdJPaNET0y92IvjW9wBsgvI6b/sM5qN2EtMWu72hxjCExQ3gXY/i9Bg0klTm+NQtbbeKequZmAk1FZ55YLQgoTElGV1l96GXv63T1gNJkpHtRWW1EqKKCRuafk+JADf1FosEEe2MBck7SAVk64l+9UVr8G+KofAkTCGuG2kn6JXmqvwIxMTjt+fU82fsb/rMJwOmHkG+SoljnvmXc2xVCSWwkWw8IaSNJCKwyFVFRP5NrEn1ZEtudh/Wgs8B9dzNLRRL4bzikBOYAeSCe901WLdiN08ZGecUHo1N8yeYtFxfNjSpAVx5CC7EE10RdKUpbIVUMVSn9j3eUYYxuxMI9arjqnTMwh7CnuE0ef0PnRiUxcr1ECyIyWC6rR6sZr0bCT/XktbothBFH4gOS8REyrWUn0Y+0y3ptzYEaWz1RWCntHqGky6gF4tdKOBCABxLG9USnfZurLstTm1ivRjawUWk719JpOORQbLoxmXkaK1bV67PWSYhLpqsK0+ydh4Ae7QYVRHVJuOYSjAj0Y7I7R1JvTo+1rDSprexJJd0A50vWFLjd10gnzAqwpMx8YKPNpUHouewNlleqvUAstp3jNuMjZ9yErl+qL0I2FcKOwwoG9mOrNfCz9CahV7n8nI0cDKYRATBgG58mnrJUVeU3Q2YWjpOsLFpqbzXEI5uZf2CaPGCgV9KXUyFZa8sRSGFpaaXF6sBU6XYYai94U0gXSs2nSbUoNjWBo8e3pOWXvc3U8oJwl5Lr8pevpZwdaWQSjihbxYpE2ik1yQQduI+GLriIcKPK3adSrl3aMZZ0uL2wOX+/sJ4UQAhRaGb5M7YlOSF2NLKSwN/TJSWK3S9ZpKXBzi3rGvqiTFqmNMhE8hgMyCOHZ156tUCmVS3WlsMBbS72pQ1jVp1mBVwlL1aDai2A5JxjDZ3ccwN7RRi105dGkJfs3+jstw6jA7rsnWa6qyRuUCe3EogxplfJJ1RHgiYmlwcawWsw5xhPCqajbzlp3ogLsjn7zf4f35OXU3Jnrrs/zam/9i+Mr1XM/1/GjnOlpyPddzPT8uc7J9hmOOOJ4paq/hIHSIeg+CNWt7rJvdfDti4S6YuLGOq6ZVQYQAtJUGbCd9zEU7IJX6uV4Wfal2dygdl+3PTfn618a8ceCy+F7EO38w56u3Dcbbt/ijY1kJ1vpw58Gk0/yrJ88aRtY5v/T681yUJh/93vvUvmJybvG5/W2+Y49596OKZBOSnpS4iU1dzjC3UvqNQT/cwvamiHdTrUrdzJZWCS+9FPDLbyX83Od22ExsvvFeyurxOR4LEm+AKQddq4qPPzjh9hsxf/7z93hyMuLtwxVtucY4sCmXloYEqkGjo7WVMOMOXKrzU+xQHs0xvtlQrmWjO9MZ9mXjwaKnbQL+zFcP+Gu/vIV7d0KzCVlfntNWBpsq5Z2PXb7328esTmp6b8iDF6d84SWPbt7wvUNpsyi4ESSMdl2yLmO27EnzBfPziDcOAl5vtvmuEtigQPjOKNadbkRrUltz3myjhK6hkRh5/kPMWy/RuzMG09vUhza9udSHe3xgY37JZme7Y7ef8u1FjhUNuJtkjIwBR86CZOJS1AZFgd4xnMDAv9mzL8BKKloB9nc2XRmQ1xIpKGhsRWEqSUPjDmK6uMVtYp3rR4D5ps0imNMFA1j3RGHJ0nFZFQWTS59gVBOcD2iCmlYD0+WQ2qFROUXZ8r1nG946GJE5I1nz8PuOuu54vILYNYhchx6LrFxpPp7EB9JmQ5rNUVbLVjLGCQPh22swei4tFaZB4iRXS75s5rLHXxEP9cGl3g9M2W/kYEMR9Il2Dugaesel75Q+yHZsW4sBtiEijpgUZLeQaLSDqSsboLJqTMvWC7/8fxJ90OKA9h/YdKrUDEDZ1yxT/AjCzpP6SNlbpL6ywxdugy2HmY0G98s3rKGQ/VUrhYykBuQ1LN9TZh/96MSEfBVpq9KHT1M+vzMisDPeXp3jnMrePOOjWcNmY+I0MQQZRi2sBMUgUIwCU0MmVN1gNy1mF5C44IViYXfoqzF+n+tT/fmpwc4wYSKk+cqmXdukmwpnZ4Db92zmKxYf1VAG2DsOjRA7VjaqCOg9gWe4qH6jeQGUESQD5llOepEzvXUDy8mx2hBbHlgvwRD1K2vpmqt+UFGyWqEuyoUi9SByoRk1yu60milW8qrumNc2XRBy+6bDdACXlx615DskW5OLT6TVmZRGSa1Igzxd1cjFElJkW9CaDaPeoSnE/jPHNPfBKvFGFuampfIUN3dC7k8meFYi/wtNKXaXHpwG13UJ+o4oRNca0vU0qtbKl3xKJ1+jsjXPwKFl3WghkPEYYs/RPAe58PfsmiAYa8jhvMtJBh5h0rNoMy4uM11LIif6ph3hj1xCsW11Vy0cRlXRSfYnFthILvhPcrPC7AoGga2BK1VhYRRSIynZHIGLVNrJMg4EqmhgiGBjdDjSbtEHtPKikpePnWgrf51L3qfDiVp9kt6Za4LNjmZdlJ6FMd8gEpZtjynzS84v9rR6+GDY6r9PKh0PZyuaOuDmOKHyKlxVYXc2tnKF2okpUQfT0fwEqy1YrBd89PElHx6WPBm4PJ0NuHOQcHdnzGgY4ovNSJ4Lafro5S3DoG6E/iqPtDA6BPgoLEqbzmmp6KiWNWXVkZcthi/P9winX5FnFnV5gt8NaKSFYZWS6deyPL41lQAnC5vRqmC3DZl6MatObGQentWQ9g1e5DLeH2IHa2kwIs8jjNaiWGVs0hSrFMHEwEgc3fBhS35rIJCZKVnb0BQ1tYA+92LuekM2nsdZfc48GPDXX3rAy/fv/SveflzP9fzrnWtXwvVcz/Vcz598urTGl4W87dgOYeIk+gT19nSH2VbHoI+JbJObQSydYuTqqmLc9MThGzAOJ5jxnMOn52zmA9ysojOE3RWx+0bIz/6ZEV+5MWXxfs03f3DC/tjG2t7iqLbYso85z10OS5tB6LIXKM4aeO/Jmvilbf7Sq6/xt89XPHyypF0oFvkJNz71EpcX5ywk6hCWDJXF+SQgMCt6qdSrpMVtg6mGsLLI7YhPv7HHX/2lkDc/t8VRF/PeowXZ4SXeZsMgcHRzgnLFWh7QZAWLRxb7d8f86i9ZrJ/t88HfK3AvamynpI8HdN0Gyx5ox2kxnqI+yHH2C9xNSjfMMMI9ssdndHYi/Eqm5pAv/4Ud/uKfHdLt9Vyc97RnK1012eYl755u+PAHivlZgzEJee4zU37mfsx62fDNxytac8PBMGRguxR5z9nap2oNkm1wvIyzsuXgZk9bKb5XNOyMQj5OFzh1h5nfpmvW9EFAK+0FzzzcaB+2bex8hNMtqKwBqrqN1RySFSOenVQoO2HxLOP2PMW7sc1bzwmIc8ruk4LWc3mWO2RZR7VYYYQ+njhbwpKsrPXpfNxbGEuL1m/oBBLmCUA8YdV3hEGkayb3qn3SvmVgDRmkBuuop7yUJoSe80FDkD3F2Z5wft7xYCQHbA5vHwuEvmW1iplugTG9oDx5DqOYMfQHtJuY0MxwLY/54oKyNBmOpGpROGE2RdeThMIfMJitMrK0IHQtfXpf5LJrmoQS4ekbfZ+hT/1NS3MtpGWhl0M78U9LrEBvgHIoWus/q/tOCwSu58rppRZ9NHBOuIudfMzTnAUR4TIjw9XuBodOtdiyU+rotRij5YDUou2VZjNoloJwF/oOJZ8gkftPZAb5+5VA6OXPfflvNL9B/mnaEldi4N0V8NGyXB2Xtm1pYZRdSr7/H5GYUGYK32349nvHRBMbv2uZL3qy2ZpIHXF5EVGvSm3BUBuFE6yRssXe7Vj1PaElp/VCiyhojYamC/F9mOybeF1ItSrZtOilr/VMhpGLtBuep422qDznBhRLxeWTgiotGMZDDNei7wQ8t9HdmOJDD50bVGaHuy7BdBn6Ftkw4u5ti8kw5nKVY6ucUOzyGJRyZYgbpb6iWHquUCwlKiE2f9F7XC0qaECf2dI0MF8qFkXNJPCYhmJpMbCMnqIr2WQObZnjxj6x4bFSPV4vlRvSNCEViFIz2dNHQmyV3I2CxqEsM1phDwxyAoaayHkjGmCbHn19VTWiRChoBeCx1ifrRd9QiuJpVLR9TSMXtCi+qsXoLHrlYPkK1zUpy5S67Nkzt5hGMU6b0/YxsS9RD0UVSW9uw9reMBYtpcvw8pLaswjGEyZGTd2vaeuarpEH7JLY9ggiIcLamlURDsXC47JZCCfDw1I1kanobOEpeIwtj8iRtENJ0PVUtbxwO2I7YtWWbPqOtLWRNEcnH7NzDEfqaGJsW8SKAUVR4QYOYTujH5kUfo/tBJhjUR7FguZwdlkzXa4Zb9lQ77Car/H9khs3xgjR0MzEoaFoVEVl1DhSzdKb+EqRpxkPH2ecXbR0K2kncVhlNc9OVxzdyHjuzoDdSUjoxhrY0jYORitWI0Uv7Rh//KLWip5JrWMS4jBYU5ctyxJBG2rQiW15+IhDJaMdOjilQ2c4tB6s25RAebSWdCH3WqRaP6voXI+0dQgSxWQwwOkHpGmHFZSMbnkMCp88s7HCq9jNs0c9zaWNsSowlKntUHXf4pSRfhMslzX1qsfwB4TKJDBCvO2Qlzb7nPoJ59mM8/WYm3/SO5HruZ5/Taf7P4mCwrUr4Xqu53p+nGY79zE3BnHSs+NvE/oDllXDJJgzGk6JygSj2jDwp+QqRbaurd5gIGAssZz7+iyW1XmmHcZt5+PuOLzy/G3e/GrAC1suj79T8+33L9gel9zfOuD35yVOvuazOx3+2uKdI5PTPGXXTnhh4vD+0ZD3z0/4udsTfuVnX+Y/+rvfIH+o+Ga14cHdCz53e4vfmp/DeUkR+FeQvOUWbXuIpxb0FzlFt0fr+/zUz2zza18fc/uFAc/MIT94vESdztg1a/oQetMh7yT/XrIVbjM1bObHHR+ULS++4vLn/8J9/u5Tk0fvPCTcSamKEYbydUWi2W/Rr49xtu/qE2sjKMgemTSBVFnKYwF39/f4xa+/wU//7Apjp+esabDONuRZqYH1Hz4547uPStJzE/feiOdfGnHzgcfpKXzw4ZzeL7m15eIZFmVecSYV463LvcTBGbbC9eN7m5Y9x+KVyTYfP20ozEvu3jM4WQ3h8Zm2tTtRRF8U+Ft7rMtjnPMTVHqTxexdxjv3YX8fqlNWpWL+MONJZnPx5JwHneLFewYv3HmBR63JdrnFYVdo4Lp33NHnEmnuMVxxjLsaWCn3+xvZweIVtmlrZpjsX3LYu/KkJUPy/glZekkZ2KSjkmkaUAwt8nKFOTZZ5COmgbA4Nhqiz9pj88oK+yKkSTPS2ZY+qA1dkzyeMU4l2mLQSGNGnXNW2GzOOraGDhPf0dHpLFtolpsbD7BK2dGkmcPW4PpFVpBWPfHQZ2QN8Q1pl5CdVuoiRQCodWxm3N6Rs318y72qnuxyzVmT6ITwF+TPQj8kzzIdiw5kX+7bK/iiOM0xaGtBAFxFD+S6kcdGGCS6XcEQWHxPre31aKeBiA+9snXTg+pkHxRwo7geJNJg6HYKEQckkn3VCGFp8UAO0kWokDSDCBQCZBTvgxYcJKrT/AirIYkMTHfG4cLln/xBTTIMMFOX+XLO4wuDdNXT2w2Wl9FkQox3cKV+z5ZskglhhltbVNJDKxb/qiZvHSau2NYrNpLhjyfcvRNDfKXcOAKcCyxdt+jkKfMPMs4+KulVQjT1qNwcqwlp7A2t2+LWPo3XYJQJvR8w9jwO9qdsfeoWn3tpwqj2+fvvPaE5TWmdFndrg2u6IsboR0KiEZKfEXGh6w2UEPodpa0ehuRGKoOs9FisVhiGtEuEmALT2MgFUBL7PU0ZsnFbbcMSgKRRy5UbsREIRmZiOh5W6xBnKVkrF0JK0CZE8th1HhFrnMGUg+0x0WSks/WQYVkDPOk27QuKrKbpzCt6p1RQWvKYFLQbByeocOyGqvO0ItmpBiVqoNjuy1ITdROhlOr+Up8sl+BDgR+5BKbFKlsjuARDBVRJSahC3K0eq0rgYs5iXdD3JZ7XMdgNCUIb1fgMnIDQKsgLi3Zt6eaIQDV4bkMXOoi73hf4iBmjXAuvFjiNgSfRiU/AIY7VYIc966rUEQV5bB1PrFEdRmNoqKW82bBVoErJ+9ukAqc0A1G7cN2RrhiVOsiTc4dbUUeb1yxmFtFE4XgdQ9ekr1yaXl5kHb3ER1qpKm1xqoKLoznPHqWkm0zDE4Xk2ucVs6pktU55ehmyvzfg1taQg/GYJPZwfEe4qzq71NYZs7SgrS1uJhGWACQNCHFxXYmoSN7JYjVvSXyHXVER7Vi7EmInYLDtcFE0hKaFHdr4G5vINRnueKi10m0m1czVz+UkSbgbjHmSp1RuxWDbos9jTWfFLhncChkaJqlaka9bLXLZAmqxe/raoO8z+oVFubEY7Znc3kpQUSQpCG6/8CKfu3GLM7fjv3j0Np995fN/sjuR67mef82L+U+iqHA913M91/PjMFujkCbrGEfSLjbVcWY/TfCMnr70MXqLojGwrQ7bdAktG3/gYzuK3nN19dz6rGJ5ZlOUiv3tAa/+/IBPf26X26OA4w8XvP3BGaPI4rXb+/pwcWjkbLKQ026L8a7JrZnDeTHTMPa9UcZe4rCel3wY97y8s81f+vpr/GeLU9q5xcmHc8avRjz3mTEXv5dy1FYkhwJwADGS2uaKZtFT3I35yucc/vqvbvPi3g3ePc34wdMlxuycRKK1vq8Pf2QpM5WQ7QVwXeO4crhXc356yc5kxE/dH9P/FYP/62rO8iIlKnw204q8KDGFxZbN8B/sUn24g9l8hDufshmeE9gBbz0X8At/6g1e/oyDX7ucXIiDudELtvDSvvW9p3z/h7W2+MeDkLc+c4OdqcXRs5zHH0s+v+blqUniDPgoa1jOawIFO/swck1O0pzzS0+7Zs0oYLIT8Znbe/yBumAgAMjQ4ujhIU0U4bYuXbEgZ4u+zulTl9I7I6zukTdzbjUvsXJq4sGAMNrSDLB5X/LKrY5fOrBgGbM4n+F0EnOpsXKHKHLw76AP6Hp/hhocEKUBtdtReEItbGkqE8ezKVRBIMt7bRD2HqktFv4Kx/AomiUTN6BxBlzcS1GHcmg71fGFtqzwJzVuk+gDtZe25bG3dez34lHFzcJktbciMK7Aim2Z8mxecLHoGBs9k0FM4gy5WJ2S1Rt2dmpCd81m4+M4wjKICLyAbCXNfyVMOwozxeskri7b+1WcwJWKRcPVsQI5XJcmCPm4/BTiAhAOQuBGZGXKiXGJ15oYnaHZDOJq0JYDS+lFXyIM8jhKk4SulpS9T4mLXkDxn7wwxaFgS4OERBw6lJx4y+GmKWw3cS7YOoYvCoPsk4YjsoSJ6nrtrpYRB7pEIKTmXgQLgTbK4XRFRmDEVz/Lj0pMcKdX35hU3Z0cwullTmI2bOZrTlYmkVnoJdZyM/JNAat9DHuDHfi6DcDpOoqqIlun1LWLLXkWYeBrA0BP34R4W75+gRZZx3lR445MdqKG3nJZzHuOf7gmP6lw1EBb5Gvp0VM+lhTBSl2f2mjLuFXeRA1j7u9a2Dd2+fT2mH1nwqzJ6Iqadu0yayoSw8LzeylOwJR8uuvLgTKt6mgqcRGY2H6N5VtXtpdFqZ0Nkt0Zhw5J6GjgStH2eLZNKEyRSKw3Urm30YR/NxW2QqnZDK4QScVZL5mawsJXEATy9Wxt83cqk7yOOdjb4lMv3YfIpFoWqDplI0JAu6GvG7JlR9VX2n7T5j1F42tGQtdU2m0hVYWZJEEa2Sl7At8hjH2K2mK9LKjshhEO8bijySTWUxHWFaVQbrOWVZsROB5JEEPn4/QpdSNRipBOoH8duN4uhgAfWYFXIs9mXvmk+ZpS2YycCkcuViPQNhzTFP5EcfVCEQdAWbCpFUFnY1gmRhMxFqZFVHFhWlxKrQ5TDXXsnUtsV7JEBoEom35H68ovqQlB/IQ6a2jSNU28Re82GEFDO9/hYtcgXS5ZbWwGR1DfTYm2R1oxd/o/rn90yZ2O3uxYr1Ienl1wsa5Rtdit/Kt+3K5EGdJHrDiuOi4vF3zsOxwMd3nu7pCDm0PCSOIPFmdVzx89XZPPUh5MYkyrZCa/AEpbMxsm00jXqYYDh73Qo9s4ZKYQdRWm3xJ1BqXAMo2Q1lYk/pDWzjBFXXY6druGwLeYZxUXuTxePQOkKjMi0QBJi7nqSQuXyQC2dxXtRcCqr1G6laHHrqXHpMSsLTJ5A7M89iZD7j4/ZW8v0TlHJ0n4/Gde01DS3z67/Fe/A7me67me67me67men+jxXRgHCZN4qvlWfbJgqCbQDrW7UsbxIzw3uLrPk+Mas6U3S8zWwzFivnd0zNO5yd54n69+YcQrXzbwIjj6qOGDDwu2pya78Zi3T8XyXfHK3pAfXvR8tDJ5LVJ85qbFd88dLtYmvrfmhe2ER2cdbz+DrFzzCy8+4PxnN/zBb7asT1reVRkv3IoJPzvm9A9r6nyD7aY4+ZaO0O49Z/Hin7nNX/3CNvenMU/erzk/meMvDWIsfGE/SHq5V9q17AtoTWoZvVq70kOrpiPn7FTcClM+86bH5fFN/vZ/stZANl07L6fCRUbrP0+bzmhXFvaR5Ojn2MktDu44/Ht/7ibBKwZVkbE+lPNMU+9b81XJ2+/n/ODtDScnBq983uaNV7cYTwZ8+Cjl/GKF67UciGjTOiwLYc1ZeKpjP+6JYzjNK55lHSO75mDLYeoZHJUVo5HBp8q7fO/jBds3lsy3tmnSBe2ioZ9OqU6eYVTb9IOefnzGOH6ZZ8cLBpfPWL23QG3HbI8jDvoh5S0Ls23J5HtezjmfnVCubY2i92NFEcrJts0wMYUWQVk1GmDouRa11VM1AZ20swUr6SCgqVqCpGck0Wd7TuX6OuY+2ngcGj32bMgkUuReo1sU5DkYxQPSzmPuHTE4vcNkWrCsR5y0aw3n3xUX8NE2w/2a1H9Gv3E4XYYaPnlwYGiIfVYuOFyuCaTaNJJoScH5qsSxLZLRVbuCt4JR4xMJi86H2qop7JJRM8DohJlgEXd79KYulddwRok0OMqhEUC+nDpqDcBglS6ZqiGunGB/8qd6Oqh6g05a93qptDcoqXRsQYzKwlrQI4KCIWDGq6+j/wbT0GKeiBHCX9DMRh11EK1DOA3afqDFBPm4RPtFZJDPqPqGqi9JzPgKKKk3hk7D7n9kYkLTrHHbA+Iko1NCyS9Z5yl5tcEQ649UwBilzkpZfowpao2R0tpitzepi5ayblFS22iIDaPXXzwXor5UyyQBkQ+ztKfpL7TCU5QJjBImns9qseZsnmpeQThZYxo+alXQWjaR7dGaBrVZoi4Vpb9hO95mPK04rxtm5xWrzSGP1znd+RrMhHWzILuIsFVJ7FnYgxHOWE6He60EiRtKwIBiUxEYpt0qiqJmnRZ4vmJ77OCFNpk84G2ne0YzR2kVzBabifAApP8zUSwoMBsXqy/wXEUuXIBILO6KNuyxC7HIt9SdzdrweH1nwvb2hHlZolppFbBYZguWmyVRZ1O0G9ZdS5/1nF0umEuLhLQykNK0EX0JdS2wEFHGbOpUOk3FiSAKWKmVNbHrBJGorqJCurR1wyZ1WStD9+7u2RucYkrrVlgFLC4zAmtM6OWEQhoNHW3pN/oYzxZKa0oub2SqwN9xGKieSmIZjoMq13RCDDVEPqroKhFJOq1O965AeyytOg5NS4sqkRcy8AxtgUrlemocQULQDwPUuqfPazqpLPEqXSckNhy3D0mlpUBsAJFLli754CKCjVjEOmazls1qQjKWtg1ZpgscJZUwAV4kNY8N57OK001L2lQ6F2f4BWYFZmtLb4tWAx2j0u0V50uLy1nB0cpn/3CXm3cn+o368DLn0bMStciZH880Z6SRKE7bk1gJu7dcdgc+kxc8tvxtLnv5ZWoRiAZYWFQzg9htCBWsLYUXdRRGz2a1QVkugQgNY0dXTM4vWz5aSsPHms7u6Mwpk0FPLMqrcghtaQPpmW2H2KMUSvfKqYILK4VZtpT2Cmd7i8neXUY7A25sjcnykE0G318fchDFfO3B6/9N7zuu53r+tc5/1YXwX486/LhHH64jDtdzPdfz4zahlbAVS635mN4ViLX5iW0ahuYWRZPiOiGBG+pFJWOhGV+GZLENgzZbaRfzwd5tvvjFmLuvmhApnn4Aj99ZEdsVz09GPFspvv/hhkkID7YiXtw2+M5xqh2Z7kTxMlN+7yPFSRmyE5u8cCNi9gje+7hmb3DOn/mpO3zYHfL4nRTv+wGHmWL7ywHbNyLO1BE8C1CZz9ZP3+DP/dWItz63w4RtPn6Ycvj4GD/o8YQx0Bk6zir39G0dYnvCfetQZq2XMLkptTE0ZF3A1+VTmLw85GtfP+DRsud3vvER6pmFPzCw/RYmW/hnPXm3pDFvUtlnfPlTN/m5ryzZeuMWl1lOd2ZTVyVl2/LoNOXjh2ve/2jFIq24/arHl17fIdqe8PbpOR8eGuwmLTd3S93+9fHKog5bdmOYJL2OsR7ObM5LxdgOefmgxws6DtcFh2c9tyKDT93c4XBpkNmKWw9M3v+BTb84xrthoi5cWmlAqy28PqItHmPmU06NJ/T5GKeXdoCGorN4cbfh8J09HHNJE9WcpinL9xV3bw548Nmch++vMY8Vwwc+fjDBXEmxXEsncejMoHdqVNLhWhZlI/evBjfExdsbbK2nFFIrGfck2Q6LvKHNOgpbDtZ6Li4bQiegtlYUhx3n/oa6rVlsgVt39E2BMw1wpeWuaggcl7rPMTrFOo90mF2i0nKkvJyvWc5N7GlGa4xZXfasLzdsTaY6Gr1MpRpUdqcYt4/w2oDKruk/WeRlJa+aEk+Ab1IVKUu2bn3otUNB9kIpjWybVjfHTYuBFgYEqCgxA4EqCsdAnAQ6bS7XmJyT6zP3q4pHLR580q+g3QpCRZDWQMFG2lc1leJeEAFAOxG0wCDR9Kt7Hr3J9NLd0F5FGbTIcPWxq5Y6MCwbs++xe5+8Sgnd5EcnJtR5jGsqmqbCcVtMv8HWy6EibEyofZ1LwZsw9KVtwaDMQp33X5kdVpnjWBaBP9CUTlEdpcZRCLCi+rkhxAkoz8R2Hb3wZGbMxAsJLZOzqqJWBluTIf5uQ7XucD+p1vAOSpoNpGcOlROiwpL7tz2qIJTSPz48PmVZb+gyX1+c4rK4dd/jpHSYPypZz3OsymJQLujCmCh0CQIDGovGCHA6UTRz0rSmK3sG44T9rQTPUyzzWudpKsvS7RP0nq7baPoAtw8w4gJfhVhWhN+t9Um8oCOc2MDqiqsKGcfC16RNRRB1jKlZVZeU80Zb9ru2IXZt7DChTkuUNBnULatlw1nWkhUlSl7YIk80ns5ftZaBJXWKrsdGeLWzhsC1cE0Tu7awhg6qqTAdB7FmbIqSYq6wt6XiUKIlHRsB9QLLvKLOLeKpuDg67IFDNDGIQovI2KY2cvJ0jlU2jAcW/k5CmLuoNmfZmrSloes0nUCqKzuquqYsBfxn4Er7hIAMHYGYVBidy8DxCdUORdNTUND5HlltsIpd5irHWdVYgYNScww/pDdGOF5FzEq/NIzCYxNfslmIxcrDCywKy2DWt+z28ohL24VgDa6opa5W/nrytqPNwJIoTqxoDWm7MHHskQaTdMLlsAxM08G0JdtVcHJ2zvlZz8cna/Zu+WxEOElFsGw1Q0SUPkuiJI3LpbVillccDbfZEzfMzYDIcHWNpQAhS2Wx7gxcyT95PV6ltIgZiiiTh5SWdDuDa0kprYWdd8zKkrJKsTyXcWwyNkOsRhGqiq0mpA23qMYZ3d6KddZQK2FuiHhVUhcmRmGxdcdlum1jFD3zTDGwpFa04wdPHwngAZWZ3D/Y/29883E91/PjMP91IeEnQVC4nuu5nuv5cZqd4W0tFHSe0Oh9DOEuNYW2V+uarN7Si5EsRa0vruFW17f3whTDZp3O2B8H/Oxn7nL/hYZZP+PkUc/he7IGSbuayZO5LCUd9+Q0O635wYXJK9sDnh87pHnB03OL0WSL3emGp5nNs7Ml92/GvHXP4puPar55seJLe/v8xa+8yn+yfsLiZM3yOGXzyGH7jsDyEtYfbuPeVfzyX7/DL3zBYL2xOD064+R4hu+1DMaKSk53uxCjl9pvj0kkMQ4xJaTU+oTJoWkrHCsg9Aas+pZynXL5nsH09j6//hduMhs1fOdvPcI4aQifl1XrAn8ZsnF66jDgrc/v8m//OYNwb8xhZjC92GLRX1K1GX/4/ooPP7jg+LjWMebXPnOPn//sPr7n89uPT1lkF+ztjngQ+XhWz9ublvm652BoM45kgXY4WTksLuVwDp67bTBITD5adjxa1RiNxzj0CAODz7+8y99/32XvXstkvcO5dYYxa2hEzSkLVFHj1FPmq1yD/aynI/znLd1ekDoN67omkkPczOKnXrMo44Q//E2f1WlFv9Nwx7nNsWqwvQV+Eug2NIlnW3Wp98dOIvESh7YdHWU2u4qgH+FLZMaWldggdYR5oYg3DuO2pgx7UqfHS3yCuCOdu/g3O7b6DrJbkmHhsq44WBc0bqv5fKsjlyxQnJz1uKlD7grUf0USKeJhgCXWG8PW99KGVTGvGtLcoVlLx1yHnCzO5kq7wm+NZSWPtGjRlrVucusjhWPauBKN7sUBIK5rC8sRV7UwChoNMpSYQdOURF5Eb/RUYlv/BJIozAOJQjhugNXV+GqsxYOqK/DktSQXoU5PXDkUNPdA/sAWQcC6Eg1UT9f2GNZVjaR8H+IOL+xMN8zFzVWk4cqhYGohRGCLriHASBtPmAxSGCBtgE2tX89yrf/IxATPt6nF4m+bxKGts1Oy0AViQ29dDXuwBYgYCSm/Q2U9fSCdlwXdusP0DaRqtpeFzxphBzFeVGqgX+HV1OFQjNdXvZ59gme6xJoKm9PnLfmy0MA/e+Dr9FLhp5jGiMboaH1QlzXtStQ4lxvBDvtThyP22B9GXKandHMDBKQxjLn9YMpbnxrx/hLes45YvrciX3bM1zXrsGIw6RgmAjIcENohbZ1zdDbj/FKhOpuRZzMJAhZ9qZ8IaVAopFu3bLGkXsOpdL+s59RSfqIJt71zVS2p+0QlimDIot7rJgtZZGupKnQbbsaRhh2u1uf0qcQIhBLqMPYsiAbM7aWuYSzrGWmdsWks+kaAD7L4GvS1uADEfXH1WLZiP1u1eJ2owCGdJXkdsbz7WEGnVS/PNViXGZ7j4ofDK0qoJ5EVIWJanJ1UjCOBXWZ48QTTr3UXqx9l0BeUaUWaNniWg20HdL0N8vzWC+rCoW6HiP5nCkeCDV1dkTcNVdMT2TZO4Oo3541VsE4zTLPGUgE0Lb7d0IQBURzgtRVZtKSrBzoTVGfSBlHh9Ab+UNH3Cb291qpfEg0Yth2VWP4bcUkMOJ/33NsztJrpKFc7KyoBY8pLOeu5mIvAIb2wuuAUahucVsuCVdXpx87ohzpSgmPgNAmdWoKZs7ww2NQ9vSrx5GfrDG2/kkqKVhb/3qPtlzRnDfOqZ7XMucw+4DP+vgZ5qtDCMUu8gViWpAJI3BAKz5NyVJM2MGnSns7MaLxaHi7CkU03ryk2DaVhk9Ut67aj01DSjqSaktTy/R7SBiWNk+Papa4oZSeDmUV4c4/XX9piK8hZrV3S/Cm3hglrE25U8nqtODt/BG996U92J3I91/Pf0vzLigQ/joLCtSvheq7nen4cx/dDbZ2WI5jGmaPKWIPcHPcKrm4FcrvkaOhd3i/xGenmL1vYXrIgRSO+9LpPtG1TmzXNhUH+uGDLb4m3Pd45UVwcV3xuL+QzDxTvPm05yjxGcc/rkyFP+pYfHNVMw4ZP3VKoo4AnhzVFXPHy2OPmXY8Pz32+8f4ZX//sff7SZ6f8LeMd2m8fsvq9DdFnIsZBRHpjh5//dcXXXtrjyYczFh9fMgotzbAypIrPkTrLCMcYaKu3ZNnF/ZoVK30Q6DmxrooXd4JlC+1fluEBVr2iPU0562e88GrCX/ulCSfzOaf/9xJvJm7XS9ZOiZrc5o03Uv7qFwP2p3scNSFcXDm+T5cZ7x0f8Yd/5NAu1nhxwvOf2uKXP3sP1Yz5/tE5s7MFOwOPW2NbLOM8S20yHAa24kDJIZHNwyyg6WDqmoxHFdUw4+3TMaeNw8DrmNgOYdDz9nlLFPg8CHLOOhhMHHJvQP47Ff0rM2z3PuX5Ejtq6aaiGTV46wHmC5eYm1vM5w85uvB5euhyfPgBv/YLI7xwl1H0Q2qjZ+FlFNI2oCJUUoFf4VUVuSssr1aD5rthj2sGOnZSNplmhxmRHDYbhLXBxixZt61mLFxUFZZRMDBsnjf3eHpjw9YqYpHNuRGH3Ho1ZnNqs7seXLE1TIehJRXuimdmi5JaybONrC3kBz27ScmD3V38xGSZCXuvwB7bjM0RquopVUVjwCpfIzfFXWmRKZOztKNZr3X1pKFcYm9D29UMoy3CINbsgk5a6hxx4gsPzqX3Otqy0b/jxT3QtQJQlOpQuefvNTy/+YSTIcB9aRIUGONVtaShYzUSvZcdsuOKoSAiRf/HTRIi5AmoX5r2PuE1yBgSjZCxDTpb2BLyOXJIKuyIUjMV9M4jjoZOruvuv3QoGCaeE1IJI+JHJSYIhMRcFFSdQCIKsirHKOXB8LXq2JOiypa6TEkzWZ5s7CAlaHqU7WFEVzTIrp9R+BXhlrQECDjvSjgY3oxwQolEQNFbNKbJLVexg8s6q9hhBAeKR48KqpMW0wrorAoVhCwXKca5PAAmVtVwb2eA7IKhLKp2QS1/LjV9VksQ9gztCLO6wUtxQbO35gfHQvVM6WqTdrZhnkYsvYLAzRj7I3K1IutqJtMhoe0Rhx3LvqWQVoPS052rVdOgzAqvtyil31MuBkPqNVzc7EqpbWQD9C2srsLe2BDZ2oqUMKS0lroL9YUbU0I/QBVSUwmNAEwEjiHkfUuEM4NA2ApLg8szsTctUZ3EACSqkFKS0UlEwQrp1Ig2W2OmC2pHzsrRwk0hz7p0qm65bJk9dWXhRTHGnoeXhOSeTWzXqLZhZiuajUs9VvRlRTLYp+rOqLo5febSman+5SHBMtM1KLII1TfY/gLLKAkEnmJ5OIlD765pUnFp+ARuRduZeJHPaOpqiSWtfKpsRbmqyMW0I1BCEa/oiZwOoy+4EyT0uxPyruTiUvpwO1S1xtuv6asJXT+ntBIiQ5HsmIR2i/HxGUXd0lUhVmhgRAblRYff+hTijjHEdVJxOquphXTqC7zExm0iTepRtih+hnQjYbgCUrXoC3m+PTorEDMRuA1mW+lWkEYqPxsbs3ZQUct0MMHrSo7xaRYd3lwARQHP3nlKO3B53gm488aQMLQwPZO2lr7jksbwiAROaSmUnZK3Sjs45A3FiW0Np3Qbk7ZwmYvAVjWaD9E3UkapmOXCG7mkWEo0JMIxe8LApfVTVtIYkhYkBw477pRq41AYG1yrwTEc5o1UDA2J8wGL5l+sSl7P9fy4zz9vUf9xFBSu53qu53p+3MaTe8q2Jux9UusIywz1sqRJ8NJQVWW887hkWp4R73h0ofRQW7hyuuy7TIY3cByb0thQrVYUs7V4ZnGDAa4dcStasLYVT9cGL0xhb08OXVoeHbVMDf/KMTwUd3TBetPx5oHJ7ywtHp15OMUlz++NqE3Fe7nFP/3okF96bo9fTvb4uxcrindzzt8v8HdXBLddXv7CiLVT87t/0LFbPWP6wg0wY2qVY1RDnXvvpBXO9jUET8B4umnPcXAMgYY7uLYc4kldvIvt9TrTXq8sLi9TBk8SXrk54Ne+ss1/9rs5s28/odsOCD59kz/98sv87NdTbsUW6UwiFhaXzYL3Ls74ne+d8+iyIl/2+PGQt16/w+deiznPSr7zg2dYvsmNyUhoYpzPbS6rglxZ7ExDprs1eZNzPIdctRxMfG5MPFLT5oenkJ/U7O4ZPLBDrFXH21bJSeayN8z59AOX335/wGwTcHfvNu/tvot55EPY0oVD7PoU48YCz3yZsk1x5iE1T0nPhvz27Iwv7k95dlLwzx7ZjDhjeyfmzedzwl2HTXjJsjVww57E9ggLi7wtKaXe3DawDYWXhnRpCX6DJxFqUxriLC7tAiqLsHOJc1+DyrtY0TU9U18g/BvCMMaPZrjFhGDfxHcstp8tMDc2eWWxF45Zyz11fEFWbZM1FR8884m7Gbdfkv/H0bD3o7NC72Y3hia3hx6LjWI9b3ASxVic5LbL2BVXTq9Zc0fZJbUGLo64tW1g9hs20gkfKLxejooF8N5hS4uaJeePlhYYSkp9mFm3lW5tEKFKHA2arWCZ+gA57S/wzCFN1+JaDkpiB1JJb1nklQD3e10UoHsnReH65B6mVY0WaCxDdkIh6ctRqcQteoLWx5ED0k9EAhEpOg2+1z0VmscgLqOqLvXH5XsS0GmthG8hlRI/IjGh7fbwBh/p/IVbnZJiU16EKKcgSAzyuqGrPCI3wLjoUK6h3Qzyg/Vei6Vy6GIMZ4ATKbzYvOIGRAGxbWPFcjJvEPUCPvHJrJKqXnK2MjBTn7d2Dyif29A5x3znmydYM0srPabb4I4U9k5HsRwyNEu2hzYzNWRP+mCDnKGY5e0RlrfRLRHvvPuEi/OOaZBzdLFhtVzozL/gMkRQoAFfsuyJiTlp2YqGvJIcsBsP8A2D0yzlosyxCou6tBCXl2OITcVENS1eO8S3U4rexsqFmqlowghXFbipQbsUt0WIYXqEbkHVJ5obcHM4YGsrRjWOBv6JhUVUz7bsuSiWNK6t+2BXqznPZkuWmZiECmyBeoig07g4rYEdarcObSphGEdQnVJQok+8RWYzCh8jFJUtpndrss7Gt28RTwtKa4Vjh3jmhK44oe0qwmSHVvoajTWqbvSLexlWBMomqBzSuaIUvbqvKNsGtw6pS5fEDa9qKU2DvCmxbWkE8XVXqzJdVFZpXsB4N8YzDNLznkre/Jw1i0aEn4iBZeP1nQb8iIZ3wx0wNULmYcOgG/PRKtaQFDOXus2WfrUnRaao2KRyO8q8pyoNaqfi3kvbvPzaXcwanqUX1F2g4ZPdpuLR2YyL1Ub/MhFlUCx6yuxRjUXbicVJ7EeddnqYbSi0H2pRT20b1RaaC6Iqg1bUQ2mRyEoMtUcUWdx89YBP3dvhtM75/sP3Of4NhS0iWn3E4WCNI3Wquy3TaUIcubi2w3TUsLFirE7iFzXKKLRCLrUwibRC+CJ8OLTCmIhC0rwnXTWkRo1h5dSFx0XtUDQVp43FpmlxDJMtK2C6H/KIDReVtGtUfHR8jGv40rzJcHTAVtsylq8rp7zpUrMbrud6fhLm/5cw8Mcf+6+KCtdCwvVcz/Vcz794TEto8ppWTtTcozNrbFMWnRXlWcNR9own5zscpWs+1fS4dzyCeEQQ+7ruvbFW9EKtX1k0l8IQ85l78MFZxa2V4u7U4u4dl/fPG+qTDa/tu7yhOr79ccP7ZxWv7HS8sR1wmec8PLV42W54857Jb/+w5GgRYtUpu691HL1zwFn2iO8+M/nZvX0+fGvJDw8vydKWTbXAHBgcKY+98YbPPhhweDlkPs+I4hLDl/isd0W3l5p4xJpu6hNim4RSeGpej+v52JJPl6UXGyVV3za4aQLVhg8+fMbkcJufeiXkvV/0+QfvHDNuhvz8r+/x66O7VH5Bdd5y4XzMTr3Pe17Kt//ZUz58XFOsXYa3FG9+9h5fvLnDUZXxe08u2Ww6nh9usTV2afKc4/MOw1c6rnDbFA5Yw6PURtU9zw1b9uKCuu2ZnbjUmcWDQcneQOGmHk9bl7NLh31vzsEgZhIMePOuw9FiSWQPOPiZPU7+SU/fBtjDUoBlNBc1Yb4gDXvMxzu0d9f4qxg3T7lx9w537014+7yhLb/LlrPNWz8VYuQe54c5l0fiOxdWm4uVOTiRheUq4q6m6joyU2EZAXg5nqGIM4fcajC8As8Z03oZC6XYUkPWwuogYJXNGLUm3U7BpNlmEFYkS4V9tMtF9Q5ROyV1DSYJ1Gl95X4WzkEmDnSLdh4RCJTcLzg9qqlrn+1gwI3xFllj8P3DE+ap4uY4JN6KSOIRfV6wyZa0spPEPpuNxHk2WGpCnIx0lX3RpbS1HBha4h+gdTpC06Rqa73Wa4dA0elWN9vwtMtA+Al1c+U2EKeBSA4d4oCRFV3pyklJODgaGm9haEZCqxsDXTmklnsadcVjuPo7rgofP7nh0R/T/y0ahCWH9hJ/MPFtH0sEmk6aSq4+R3gLTVvq9pUrIYIrBsSPSkwwygWNVWCpEAfJuivyviEKcgZbI8pVgFEb+N2G3FcUjYkjYD9Xqk0KrKbU9nM5vR6EFqEgFiQ7YqeknU1UD9gKDFLJpPctoSf9qz0XT022DBi8knDz5hizCUhXJR8+vkSVDZbfsH9jC0KX6qjjYDSgtXwq38WX3EzTENU1netTlUP6POMim3H20QprIlCYkmJjag7AjZ0BrjFg7CTsDm12b8bE2zGu6+jc1FWtR0kulvbTks7pEbtA2Rg4tsQ8TPq+ovcKQSdom0qwMujcBq/OMKTr1Ax4etFwdrnhthnw3F2pmikJQ4e9QYwlkQ27om/kxeVjSoynhzqTnI/SKtIir0lX6dVpuTXQ0QbDazR7wRYLvlys7VX2yLakniLRqlNnCsnf0ReRt1szkGXZaFCui1GV+FsBVX0JQoXNhb5b4rd7THZKuqzBllPtVjJyPl2zpnQrTHUFS2nLQP8/m24J8zOSyQ6NwDH6iKJIsaqcbTdhGCm9cHeOiS91mcJLdGKSwKMSgM8gYO/WlNaoCWzJF0hxKMzzFBYLXeEoPbBbQcKNic1lvyavFUI9MLs5Ji9iD99muD/mYHVFw32y9qhfCHnzMy/z2p3PahjK1DnmPKuYLU44vUg5WxU0pbSVJBiNPFfiBuiprYqmrHTzg2EGqMqhVT7KyBF0gWmIiGIJ6YXWGWFWCUZ9jDwNJgVeMKF7Y8zXfulrTJqS//y9IX/frEi+7+kKotp/yrNTj9NvZOwfNNy87TEdRExHIb0rjokWz7GYBgOqytQASwEBOdIc1FtshLthNXgdFGVDITAZyyNrPK16er3P9lgEwIrZyqCuIGy22PVc6oHFtLNZZClNVnFjE2BlAnzwKQcll8uNrkba8uLre63r+e/M/PNEhR+H+XH7fq7neq7nev54xDrtuBJpbqkDYXTJjWnP8mjG2SODwYOQf+/zD/j97yZ88I8fElolwUHLmaoYrWyc4RKhhF1uHI5OM0LXxnVjKHMOFxVuZHH/QO4nC86eVTycxbw4DXj19gmz1mTWRjwXuVix2N47/uhowed3p3z6xYrvPvF5epyz+bTFK3bHSbDke0dbWGbKz/30hOHHIf/0wzN4ZpNmLsaq4cujfaKfv81/+GTA6T98zJ1Vib1jYEzkHtlm7q+wO4txfrWM9b2Lkiozv9T39gLHcxsh4F+JKlV2JUpML2Fduqyimu1fTvj0X5jwrf9HxRdftvmzz5f0l/A4/4hpvcWJd8jJocN/cbHBeNTgNyne7vN88bNb7L5q8+7bK76VpQyDhm1xa/gm88sOL6lJogDTD9kOLVZnLcfikg7gwY5inNjMig3Hly3VpuH+bssL2y5ZrfjBeUHl9ewKB8MfEaieR+uCkT/k029WfOe3Mp6/cwPrc5ccn1UYT07o/RvYXUJttLjxNl3wjNVRyDDcEJsBs5shX72rmBRTflAuefgQPqZkq6t5dtiwXndMtjzyLUUnTXSe3LN3hDW4pc1FLUBFg7Bz6IUVpiqSzscqlT4ILJyQ1inZ6318x9T8u7P0iHE75fL+KTcXd9iSv/tRy4yGnSphXvjEe4f07Q4XA4tRtUtIQXZyQhPf1mBGRCg62+Z4lbE76Ygtk6qpOTqfsV4t2U18JnGA4Xk4oUffttTLVrtUoiii7jNU39I6hdj3ceTQtupY5ZckwQDL9WgkGtK6lKrEaeXg1qczmqsaSbkPl59XMxWUBi9KxCA0d3XjgkDT5FoThlkl8WTtkr6KLGjQf9vpPVCqISVaodsX+h4lO5khyQFpIAm0gHA1Sv+Z5hSKvNP3dHJobV/VR4qIILdHnTAVTJemlx1PUZtXfLkfTcyhTDEim8iqKPsRTb8kmvRYA5/hjs1gJJbxjFQghGYOK1HDar1gu06CKXWO5Qara+kym40tfZrgxWKFkry7UPlrvThJfMBoDbwCbnoJ2+MxVmDTZQ4jY4tb+x5PNgpXQIbDfcq8JMtgejDmhjAVlg7DVcvKV8xmlibyiyMhr3vs1GC04zNzC4LxlNG2jWfsMtmKef3WhGko9ZQOnh+Ab2v1x6habWepejGPK8IgYHcYU2YZRtOwEN6B4WKYHb3fo4T+L1ky1UCiaHCxqw4am/M+5+K85/SxWIA2vG7cxhs6DJOI4SDEaj0aM8PqxV6gMG0L02rZiYeU0sSwaVgWNl0lvIANvbLpxdIimX6zwRp0GI6P6i0MAWUqW1db9kjva6IvROmokKaKtrugz23yumZdbuiHW6h6SGaXWPWaivCqjtFTpJcV/t4u5crGc3N6a4TfBhClDA2Lcg6XTQ2ZR16LEHTGZWVRs8AlpO8iukJEhJZAIDdiHWPEulSkeYZpN9S+wb1kl71xQm8o6rxjna91G0rsKm7GLpbEDlBaPd0dxXwxgdW0xYv3aPKU7bs32HFrzs2N5l18PEXX/Hzq/gHbnk+6EVtdwO7t+0z7kpNVwKUqyGJLiwdeZ1FHhfAN6QuFsnJdykIdYAgURcCKRkZruriSPZLqIEP+ndMWG61Ut0WB127huz6G47I3SLjhhDhezJdf+QL3bxkU317z934THu/6nL2zoH1ocPy01Pat4cs+81XGe5c5zqZg6/4OY0fcEqV+47Bch84SHkytaz9rBsKKpco78qJl6jh49hWoRZTWYdTzsGy0kyUr4XjVYawrrGaM57QM7JCzesPqac/F+pIwBDNNOSlWvJIkjO9Pru+orue/c3PtSrie67me6/mXG2k0F/i0uEzLMGPcbHH6/oyH308YfC7k535uij28yb91c8T/+t2W4+MFsbvipNhm8/GKvQMHOxhRrDe8/ajCNzpevBdyf9fng7MNJwvFQezxwtBhMx/w7MLGtjNuWnKMZ/F0JZnzlFvjhhcnu7x9ecF3nrX89IOIV4cuP2g2nD6b8vkbBX59wMrq+P0nJT+ttvnVP2ey+t2Od5cHqEdLvvuthPxzNgcTg0/Fe/yDZwu6f2ryoFUQdlQUGJ6wEiTCrWjbBj9Cu6qbzsArA6oup6pSmtKmjToWi4ZHHxlYac341j3e/JUDPr/bc1BafO/VOX/21z3s9YxegIWLRsMDz3+wzTf/8G3K34vYvOnzmTbk3ps7HNyO+b3HSz4+XTJODF7b9fTh1UWx4dlZwcgtmEymdOL6XRac9gYqUTw/7BgOLE42Ju+cxXhmzmdvN0y3fJZFz5OVyYXpccdt2J92lOsJP3jccNiveX7g8yuvv8jF/rd4uoCvvPYi39w75b20pnmcMXhODoljAmdKyiGms6Lfuc10CMm+ywu3FsTVi2TvF3z7nSWHq3PMwKYPIiZBy9ZNk36roihDrNJCFS1K+GqJiRpm2jHtNgJLrxmZIfaw4EyaM55J7HofooXmMMzcjBtFSBxOwdkmXlbsmzZ10FIVI7g155a/jRq0LM8rzgObm4nDhZVh7RpkJzFUK4bmlMusYn52RlE6XLY9p6tzXM9GmQk7ocXuSNoVwMjk4FNhduJEF49Fo5f+olE0cqjs1NjzCwzXxRqEelEXiKIcwNrNVZzAV66OJciirl3ntoPqOr0zlHWFKY4CudpEWLDcq+iD7Btmh9OJM0CuRCHHd5rDIKwF8WiIE0FPL9dmo00Ilin7jAgHsltLPelVFEIAjfI5V+4HU+8TUt+qW0oEg1qnOBJD9wYUYgDoKuomx3OjH52YEAmEwZKu1Jq+Nuhdl9s3fVzLIElCwtDGnow5PSu5yBaUTkOzlrWvwTKFPl/SWzVNb3C5Ebp/jVV2ZPOQeKiopzPmlc9YeAaBg5971ClMfItkcNXv2WYmvV/iTh2GgwB7U9HYLenZmmXbsZVM9MlrIfJc23L+eK1t/fnNIbvehmkTUucRd98IeXXX50G8jwD9nd4iCXzceEAnR76mPNCKvNxQpTl9aWKILcTvdGwjkcaIBJ1tjwalfpOt+56yNPGkszPz6L2aQd+RCkCjErDGlaq0Xi/J1IrpXZe9gzFdXbNxQ3YMBze6yrdQy0Wn9BNJIxeYwCZMaqtlVs6Y5xWpfmfPdd1IY0a0lYdhtPjJlU1LbD19myOKi9hXjN6/uhRloy9CLQqcx5K5F2FBgH0udVHg9y1eXeB5FV29xby90GyBSmi9WYXVSfVJRmCMsPtGMxhcP6aON9gLk0HoEw5rHQ/INi6dMcfxWjyzYz7bMJubTAKH3dilE1iParlcC4HUI05cBkEgPzKZdMPi4IYepZycK8VNf0y8e1O/oQS1wWA34M3YRJVbXPQh87TklckeW6MRwyyjUg3NrVPuxnO+uD+hWJ/xUPgO/oAbB3cYD01ujMcMJxPGo4BmLBGUTnMRLKVoRHUUddCRqIN0Yjja3SG9w6qxqcMK2/VRXYbZRHR5SjNKtSBk1YrpfkI1SXiQjPnB6RF2NOW18ZiXRwGX421e++wux9bz/Eff+BaT9zK++51jTouMlxYZLODkWU9RbDhqYGBLtKFh4AWMY5dhMqI1GgyrpZHrK6hpj9fklcPU9hmEQom1sEyBeBpk7Yqs6PEl3ZjPpZQV8TE0VoCS6qMmp3IbHKbMz5esPs7IhzBzoKgkL3M91/PjPT/J4sC1K+F6rud6fpxHDnhkcXH9kOjc5dsXJxx/lLP9+oRf+fJIdhwenp9wdxzw139tn7/3Gw77jsf23oRvv18yO265eT9iMkmxfYsnj2A6tHn5vqnv57/zpOcbHxd84YHBizsellmz5aZEtosfe5wdtnxQSp6+44U9i317yMqseXJ5zv3hFksVMqtzPjwv2b4z5fWDC/7gUcBv/LBlf+jyb30l5j84jbGOj3j7/1nyG19x2PtCwJ+O9pj//A3+0ccR0dkJYSlxap9JKg1aFb3Z6epBCT2QSb26i+UKYF2iECW2AOnLnurUJDtuSX5qiy/+2V1eem5Xs86MvuTFV+R+vYXLPYrwgr59wjc/tvj/fGNB8vQhavA57o0zfuHNu/S+wz97fMLJex7P7Zjc3JGeeouH65YL2VtNk4mw0/yes43DRZtij3pe3DUZ2fD43OTRMwNTBdy71ZMM4SIP+eh4wUYp7gwd7gxdarPlqFvRnNtMHB9ranOYrfjS8xP+499ec3m85m989af5D2895O3/7e/TbjIadQPjZI7jdpjhLsG05GZr8eh7Z3CZs+se0jiKW/sl6yykEAWksxjteRgTHz+LsTcSe7dojYA06LXTA9sn2IzojEtqV2o/hd9V4l4MUXaDZ5dyFkvSh6znJZfaQR1ijFLqD7bwk4rhJuI8LnmhDVH7PuHZmh/2t3DXNsmo5OG0xHYUB9aYw6Cm27M5Xc5o+11u+EtOjlz6omQSJRzcdhgIeFM5NHXHMr8UTD47yZAkSDSbwDFC1sYcWTrDy5ZGCaPPZBE03OuHGiYp4ltsxPrw9qo2MmMYyeGf9hDQ9VewxD8GIMrib1gmOWtCJY5gi9pusRuDxmix+o7IivR+oo2MnkQU2k/+vfoavSUu9A6nd3B6V8cYRFyQz+l7+bfXUW65X2r6hsqo8DpXMx5MzbAQToKALi2CYMyFcP38K+bhj6Ya0q7xrRWmuU1fGgRtw3BqEUbSVHBlh0hbg8KsCFxTL96lFUGS4IgtqlP4tqPfGNTAgxgNS9lIPaFSDIMQzx9SmwGx2LaLlnZtYO34qECW6ojaaohil0/fGHM8a3i8WJLNa5q8wo98BvWI3C6wwoDOr/UP9/z2mOG9LZ7brTXdvnAtdkYDTKm/MyyqesM6K/QS5/Yt4yjUAMTLMuPw8RnLZxdsWot46PLcjZh4tI1pSfVewVw/SQ67lsWmyFlHFknZcuqWeukWcmhZXsUURN1yIoP4xCa+PeTzbx7wxniXi03NpdExCiM8O6ZiDbVDZ1RQ2dQiumBf5WtMH9N3cJoSt/UouhirylBKeAYejjPQtYD0mc4eSS2nWoo7wET5srCn2BL5wCWtW5IqwE18PEeza2nbCwrpPRU7j1fQFA1uJ7EEgRT6GGku1Q9U+ZS2zWmjCqMZURey9DpaGfPCDcPEYL4IacXr3zrkSKNDSU2B1TpcrlyWXoolCpnlkEQe47FBGHg0qmFVpmSlvGgEoGijfEhqHzsQQKFF6PnQNnTCM/DArKeYntJ2oovyGUaWaD5HbS4wtk3e3B8z8j3KzRwjr6gy4SPMMYcdESUffbwmzBJu3QhZDjZk604rzngVqg3pzSGGuaa3c93NKrkLZfX6+tFvim2O3Vh0bkVf5niWh789ZO/OAeYLCS85AZdPj1jfjPjprTGVEgimzQt3thkXHQWnvHKn4fU3nuP3LlZ89NET6refUj1pkWaY1ZOM1Gqw3RXZ4CZDu+SGWKwGLYtG+CQWg8Ripw15ctmSF5BY4vQxNexlYBl4YsXqAuquZ7nYYPoRYV8RDQeY7gXnfcDIESeG1FuWrAqD2/uR7ic+r9Z/0vuQ67me6/nniAc/yQLI9VzP9fwbNBbUTUWZZvzwyYLv1w2f/7fv88u78HRmoy433PDmbMw77OyMuP0GuEOHT+1EnL61x9P3j0hWOcM9k0+9NaCtaj6+qDETl71km91kxePLGR9ejrmdGDy3L6emU47Tmj3b5dWdOd+Z2fxwvsNedMmbt1q+v0o4m4tbNuX5PZdx5vK7K8X0sctXX5zw+m349mnNNw9P+PRBz0//zD6/9U6F8cG7/B//zpRkZ8hffjDh3xnvMf9TEY/+YYl3esae3WBZBZlR6QMlX45hupaqLVCtNJuZWKGJqwb6zy6WFR+XA+zP7PBzf+GAu/dCfVjTC2tsaXLbk3rMkvV6wdK64OHTMb/72yeEywbrxh2eeyPiq29tkzYxf/hoxabsuDdZ8ub9iIvC493DgrSv8IdTXpomBH3B4aphsel03v5O0DA2PZ7O4b2jnmHT8JnbFfYk5ztLm9l5wE5j8+nnxSddslwPeFqFlL3Fwa21dmiky5rf/mHBK7dsHtxf8Yd/5PLlz8f8L76yzf/4u7eZ/9YZbr7B3PGx4oTixKKL1vzu6ZJ5Bd8LA25O3+Olr3uMPrfFKHUxZnM5rcUb5PjmiE0ref4lN82E2PKYuykdHsligit7UuDBOqQ2DIJaAIVgNjFJUnExTslOFEnb89iG2C+YNgOO8mM+VnuMLItRnFEMJ5olJwBG5/YZPH6Jw+yIW31IZ8/gRqc5fGqRaaZBPO7oXMWqSNkZD7nRDYkNB3PLIbIEYp/S50tcO0MZNptSHPgbLGk6m1fksvcYPfdcj3gnYCv39LIu14iTufowUjBsvWYm9DiOz1ptNKzfxtUQflncBbYv0QYR7EorxetDLGUy6oX6l7FxcqIuoBOGmzgbDIkpyLG3yFzqE9ii7Gs1rSUOeYUpjhVHdjNDN0WIm8ER14KS/cXQnxP2gebDSVw7MGMtGqZFSmwnFOKA6SYcLdY/OjFB+a4m1GednDJbDP2WdZHQt5bu3SyKGrPOOF1kpOUStx7iuj1DQxEFBnIwvxHARtCiQjnRTxgPbfbNmsTMiRIPZQmsrxQwPm2uNPnTE6qJI7wC6eoUy4d04k0ZjVKi/QxjWdLUAZNgh+nUJBhNeWF6wHSck3sRN6IxxiAk9iO6VtoTSlQnRv+Opi6o8xS36VhLXKFttRAioYDvH33MH337kM2HKxLf5ub9Ae4AHgyHjH35fnyGpcN80+H7Lm4Q4beinikGViPGAlZljKUynKDTNpZ+lTC4FfGprSlf+tQtkjZmuXmf+0bEaDCgbWtqr8UlkFcQpufq7ItcPH3dUxgpi3lLsVFUnU3dCLEzoq839G5P24a4YnmxbPpcYRQmuAG9WWGHBbZysZRLU26waxfb6AjiCNMuCcqeo7yB9ZKBm2CWA+r1AmvSYTcRnmfTRM/wuudxrSVz+xKDbQZGT1FvKCqRKK7qEnvpLHUtYrcks6UWxoSqxLJ9DbJpjZ6m6MjzWiJ3hE7O3naLO3I1SVS5HbvBhJEnVrJKQga4nsIMxdQDofQWC9wTyfhPdZPCVmGw42XMl1OyptR1l6Nwi8BVJFsJdWGRrVtCtyZPC775u894d35GbhZY2YSxN2Vr22R37NMkFvO1wdw3yc6lCaHEVpZ2zEiCpckDHX0xyWichraW76tDOZIpm2MvSq2em37OveGYp7NTDhcd93avaiglqDG2r174fyT9xr/xAX9493n+N3/6p/jLA4v/w9Mn/OF/+lvkHx3hd4fYvo/RuHRpzmlzQmZI7KYnGDmkfY4uXpJWCVthdAVpZuJJ24PsK06LFQRsuzHPOCavIZbXkFXpjJzYrlx7gDvM6c7kjb/UkRNnKALaAMdM6DabP+ltyPVcz//f5ydxQb92JFzP9VzPT8J0dcv5+YL3v3fOw70x//5fucs0EQq+yzcfr/jafYUf38XqIpa14ou3RkyHHT0WX3o+YrMZ88GjBfcxeXMSk79R8s13G559vGZwJ+al/ZCMgmcXinpp8eanRhrO97Ds+Dhz+OztmOeNjm+ct3z4xOb+fZN7TsbvLIao5FLfT9+euDw8mPP0g5xn4YKbBz6XKJ6dOjx8d8iXdgKWv/gx6cZm9reO+V8Oeg7++pA/df82//0XQ/4vqub4/7Vm8n5N8rJLFF3FO+QuVBoddK69gLpuiRKHIldUFxGd5bP9yyO+8tKUu1tjGnrK5pTsMuPoUc7gvoFpjXhy8ZjDdw1+9/sXuIcQbu3xytfk+7rD6WLBb373gspQvPZgh7F3wroOePw0Y94UDIYdb90sySuTDz92OGsyJnHFqzseZqF4+2HFUeoyGbW8+joMPI+HxwMuLnMmyYIXRwMGicnDy4bj457GyJkMIg72DbKi4Jszh8Gi4pudx19+6SX+QZ7zN//OR/zHb5X8u3/jy/zt+d9n/Vsf0mZT2mKKtfMBZ4+G4IzAWRIUgWbrba1eot0taANphBtw65Y0JDi0oxqVm6ICUEjTQGHj5hGVwNNZEnoORt3TRS0qUASzAQth5zUBXuZwzxuzthqWGuzvEVQF58EMWev9xZrt6U2sfkF6w2H6qCCfWuz7Z3zjeMQb9RL/5h7xYpd/VD1jkLaodMATb8B2ecYoF/fKgP1tU/MnPGKU35DXK1xlYvUB67XwxWo25QV1ueHRsxXvfbChXPtkow0vTmre6FLu3tplZ+TQd0qzESopgquk9UPhuiF5XepIhlf7mnOg4wfGfwlIFNFu3NzQzQ6245KyEfIiUzXSNfUSubniJIibQBoeHGwlvnNxniuiPkSkK/nkzEspjZykizRIUfYv+dhV/aNAIh3tcJDKV6mpLLpS6HB46sqFfRicYD8O+Yfffsz/7H/4IxITrLYia1xdw7g9NXF3hGyZcb42aZwNk50dpo7P5ryjTGNaK9HLtVo1qGHE0HfxwpaVPACmRy/U/FbhmT45Y/pawBS55qLKKW/Vmoz3poy3EhwVU1kFm5Oe2m9Y+Atq22L7Vki941GullhtRObVhE6EcQP64AE7LtrG4dQtCzk9FqNK26AKWTZlQetZVo2GGg6SkEHTYGQF31ye8p13HrF5eonXO4RSf9MarBcl68GCwXgX2/FIvITLVDFPM8ZhRCB01ygidFs2pqJZ2IyilryTE3xZ6k2c0NaE1t1gwNPzNUuluB16NFWFSlr8OsZ2LIS10asWo+3YpCudh/8wXfD+kyOWTUEjnaJVD3YHlUdV17SDOXYoi7tHW3ugZNG0sCwXW/4ux0ANXL3om4bPwrDYRRE7HYu+Jtg4lFZLVl7Sd1sahim1lWMBniQu63iLfnaMYW5hFxP94h+3il7cJn5GVybkXU5RbsAc4kx81EbcEB5BaNCQU9XS5dtj+zZdHWNWJmfzjPrRE0pb8VqyRTRw8T15YbVkRaohOJ7tIOKZvECszqIrwUoqrNDRkRapZFTVDsMIIv+WtshZewHZysUfuFhOJboK9SblcHPKk8cp7UmPZ1k4YUkeZxwWHeFEEYehBnF6zRVQNDU35NKGIPEcsSO50mgq0BQLo24wmprO8sC41K0I5lbIoj7nDz8weFgV7Pk2aaF4GN7ki/sj4thn7PmUas3/7p98BH+QYb0ZYMcxiefxP38u4v/9l+B/9Z1/RvO4xHJSVCPNEWMc1VMctnz32Sn+JMbd6giGJokvRgqD0FGsO4OlCAq2xEoMdkKPwTBiNHYw+hWD6Zg8Ej5EQ1Y0eGpK0jSUbkxTnWMWPvufljcuxUlxoYm513M9PynzJ617/G+j7UF3QV8DF6/neq7nJ2ROZ0s+fnfFs2SLf/+XJsSBz+8/C9iaP+W/97rNST3kd79V8fJLcgIb0jUe9HLXDUPH4ssvD/k7lx3vnqd8xl7x4m3Fk8zn8XdavGcV99qWu67FoS+N3DXfPy95Y8ti1w35drrgh7nF5+IpLy5mzOYJ2cWKV6YJL91seBop/uDjnp970eQL+wmHJzY/PDYx4yVvRmMWfcj3nhRMzBVf+3pAdnSbH35rzfz/fMg/Tie89D8Zce9ewr/7ym1+53MLHv/TJzjHHaPnBNlXUxUpruPj+DGlJT1X0mwQ8NEHPZs24Ff+6oQXnt/BNOXsuaUt55ycVDz7ZsnxDx/ifmbEs80HfOt3HvOdp1v6FL57weKXDva4/cIFv/P9FR/MO7brgr37cM/bcLTp+YPzCm9ZcPN5g1eSiEXZ8fDcZFVnDHy4ue9imx3vLgIOlxmDvuaWE8iZEN9buXw4hwNb8crAInIKnhU2x8IdVAU3k1i3hmW1zXdzgzxo2asNkvEEP0n41Tdz/ub7x/zN/1vG/+l/5OH/jc/zHzxqqMNz7LMpbm3RhQPMNtJtC3cHBdVrWzpKMal8Dm63PFz5KGdEaVS6rrK1l0RKrg2bE2qmls/IMkiVfNzSDm7TL7DMDruN2HWhCpes7JSqLQnbm2zZu6zzHBoP4/KCHWtC5lyyH8+4aMY8f5ZgDyLqrGK3eBX/4gTj01Mutzdcftdhs/a47ShWZUbXWuRnvebM7d508dySxe6Ao+GCgyUUZyXLtEaODg0xRLsJWwMHc+nw8bdWPP3whFaiN9s17++OefIs4PW3Wv7sG3tMkpvCT2SlLpnaexRVjh/Iz96QKGmSUzSqx3U8zUlwZXWrar3kt61Ea0LqpmaRrInzgMCQqE179WKUz5UKR50aENC9wu2F22fSWq0G61uNhW8GeAJZlPiENDMInBFppjOopWHPcjWrQfgPWlSQP+8aIi9mUc44Oy344T8+4YNDiUb/iMSEpAjYZB310qbdneqFX06QfaenqXuCxtUwt/Ge1G/YNPmcqoG0N3UrwJ4TMB3GTEYGLTknogyeNASNovI8ElnyDfBVxyK1CJSDHwmcwqE0Mqp1x0cXFxxFNV5sYEYrLKPENcSg79B1M85rn0LlvJRPqA2Pd0qPG2bB1BxiOu0VM6AX64yFj4nnGYRGhCsKjWUwXzZ87/Ep7354Qb6qiN0JfuAQBRWWmZF1AWnbY7SV7p9NxglxlvF41WHRECURbmBi2j67XcM4rin8MaoS63vN5nxJqQacHi3xBYyxTvHkZxTCoFdrt4ShhKopFipFUeT6YlulBcdnc54sWxazmeY3GMrVtZhNk9OLk8AWe0vKJrMwKrGzKCzfwxCrvoBDCwtHgCdmBvYeXTmjuYzIJrsERoFhN/qkupUXr38JZU+gWvLLmuSBgTuPsBofpjV+fUlrzuj6KXU0YTQ1yZ+JppxTdwlWbVJsMjKVgZkwigaUlk+6EuaCC/acvhNAiEXXZpQzWJyvWa8VxgsFD9wdGMQ0+Ya0WxIzwY8ExuPQVJ+8uNsGoUmMoxGGa+AEMd06xUxasTogvQfS1ePEAXVeY3sxXrIBK6ZspxjWGnMkbgJ5YdaYXU7fyXPUsG6XV4wIEXSMlLYXbkNLYZzhexP8LsCTa04gJk0LnknZ+rilJ2ha6v7q+a6eGjy9mLHuAnZt+HDz+/zvzYz/wZfvch4GnM1PWf3nH2CcmPzaaxOGjgA/BapiM5Tu3GmEkfmoek6uTJrSxVyttEWpNmxSKyPyA5zOZi3ii+VqpbNflbRRqH/ZdJuStO6xHIXljYnjbSZJitW48kH6dUAz6OmtEs+Z4G8WlDfH7NuxfnNZCE1XrHrXcz3/BroUrmskr+d6rud64J3vVnztqzv8T9+4yd87bZl9cM6XJj7PvdCyYsAf/uCUH/7DUw6bAX/+jRsiIVC1GWEjK5DHXujw6df2+f1vXXLyrOLuTYvXb1ps5jB7tiA5s3nxhs/gIOfdk1Iv47d9m5duDNh80JC9HfH+7Zadqcc6VZymOTvVLi8+aAmWId8pLvhn856vbQ946UWHi4uIw8UGf9Xx2Vsbvv2xzXzz/2Xvz4Nsze/7POx59+3sS+/dt+9+7+wzmMEMMBiQWAmQ4CaJ1GJHVhRJlsSSUqETyYlVrqhciq2ULNsqOYriKJIVLZQoiYu4iCBBgACBwayY7c7ctW/v2+mzvfv+pn7vSFUpl5MqGZDLJPv7D6pw753p233Omff3/X0+zyNj5wY/8ePr/APlhPTXTvmZv3Wby092+SMLa2w4C3ziMxu8F3tMfnvMDTXAuGhjOO06gi5LEk3NIfI8jrZG+J5G53kDa02jQU5cxnXleXv3hG+/eUJry6O8oTM6m/HyuwkHd9YRN4XNTyo89ViDJy9f5dde9XjwHY/eRsD1yyoiMPrqjo3rzTG7GWuPm2waAvDY4V0/ICpTNpdlLrYzDg2F145LlKLgwtU2diHhnSpsn4Zk9oyLrTYrfYsidnnjtsSRUrJmKzQvyyypPmdJwf0PVHqOSWNgs9Lfq1kQ/+TtI54bRPzJ39/jr//TE371VZsf//5LvPHnA379L3+DvJCQ5WXK/AzbcAljla1SxvxNm7c+YtBRjtELi/Z6SGcg9G055pHGQFY4W/CZpqI4opNaMZZi0ihM0rnBvFtSWSH9w0Vmc5+i6dK3C7rhJU58H0cRsPWKiXVC/6DLKFsgtjPmnsze3oSwM8CYeix1VGRN43TnhERd5cQesbSXcbQwYH2qUzVckpWoVlCamwb5fkExD5ipKrpyRmdmMi1M9k8VJmMVXau4esniet/BLxLu7I7JHxQ49jJcmlJmNrO5RifrMfVSwjykpaZUgu0m9QTyniSLyZSSlibeF+Igr5KXQs8uQIhKDV/PyrQG6Tf0D1MIRZGy6PY/BC8Kw5w4c5QZaimWAOKiWK7/nPj/a84BCqEqziw5rbKNkqpIilhwlfU5GUUiz5I60SDUjyJtIwkeX5GQiUtvWSSaDeIsZms04Ssvf0ByxyRTGt+7ZcKh6mHYJT0lJpw20RclVN0gF5UBW2asxxSp8IT2aMs+sWrWzIRG4VImCX5YoPgZhaPXHSSbgnGlEIQJfe0Y9AZSZdLIfOSwzVJrmZY9oNQy0qBiehKwc3LIYfYQs9+vDRCGZaKWI6qBTXNu0dM1pmRsazk/trrG9ZOQV91JvSFtNvP6myeeMYWNM8vSOm7f0sUaNCEOPW49nPD2m3PSSYrW1pCaMrai0O50kBt57ZHt2B0sq4MgD4gf5FK7yXg2Y5Yk9eJBbOuiNEKWdHRFplHmNEW0JQet3yCOTd45nRHIMm0rYkFqYliND6mckfinVphNkaVvMC2PyTIJN0p4Z88nnmXkgUOlTeseTiGlFLFEUZ3WsXdZsuroUlGJn02LUixQ87xmPIhujujMiPpFWo6QswIlzJl7IzAslJbPTE6RUgdLapPaor4QoFYy4ZlLWEISzej0VjDUiFK6hKzOUCqNRt6ipQdEQUoazYiFRcRTKPNl5GYCDZ8yLVBKvb7tLksJ0xCwkowqS8lyA6mUONk+4RvumMSo+IhYElQSltTF0BVEu6kRKxSlhKeHqGlBq2hSJiF0PmQrFE2zrspoqkQY+7WGpdJ0ijBBbyuYZZ/byQn3qphcvBEbkMfC1dusI1e1EiXKqNKcXM5JBIRznhDN5sgKGEaTPMhr6IpWiu+ohSZAmR2PahZTlh3kzETyQmTVQVJUuqIGJE85nClUb93jZ7ePSUKN15YDjFeXsQ5C3Osqla1zlsb00AgCn19/Y492HtK4PKRtm5xWOacPVPIdmyz1yPUUtSgp5xAI5oaS01dkcslgVxBgEdvJfh2x8oRuKEtIcp9UaaAKnoISk7gWuh5SxBlV4hDlJU2jizTXKDsqzWWVoogo9Pb5s9T5/J5IKfzPlRY4TyWcz/mcz++k+VN/4gmayyl3RhWv/8KU/+OPVViLHrfmG8zePaLw9vnIosw/fytjrbfNxzaewLJsJKX88KCklLywWOE80eLOqyNmpzlPXujSuFnyihUS+BFzraJjWSw0y5qttTdTGPYNnr20wFvGKcdRQtMc8kT3lG8fmOyXAdZSi0vtKWm7Yrc55dt3Vb7whM1bcsWdwwUUXfDHmlxqF1RyzN23ZgRXenzueY1oO2fnrYy/9mv3Wbym8qVnLDacJi989hq/9PA+uw/HrNkh6rJR6yJFUlYOCw52Cva8Ho99VOP3faFbm77m/jGn7jHvHZzibuswO6qh7sJmsD095mQPAn+fpRub3PzTfR79oMtff+UUKytZ6Uh85EIXr/B5Tajnk7sMpousLpZcXXA4GM+5543wQocrQ4nH2xKHfsXeuzpTM+XpjZgNp+T+DA60kKpIuNTocHExZ1dKeeM0q6127YbOjY6Mmsu8Exk1ED4MZnQaF1gsRHH3Gg8Ei25m8u3ZhJ/6gcf51Gd8/q+/cIs/vqHz059zOPzGgHd/U6YMLGRxmXupj7J1RBYsIHUfcuat4b4D16ROraQcCLC8A3FlcFqEaCcD1EKoCxNOlZBASWgeNTkwTms+WnvkMPPBdQJaToytrOJGOa7SYKOlkksVHXWB1J6jd00a8wonKjktJRpaiVvu0PI3iaope4E491V0ggal4iNN+8QNDz3xKeV1LnUtijOPrVDUS5bIkgWKayG2AJhPzlAMh0dW9fo1jCYsDzJqqTItZPwNm/VrFsOLQ05OXc6+LbOsxXQaLZoLdl19GMyWSEXiXVFRFBWjUmt4o1gkaIqBm3k1X0EAFcUloSJLuFaCk4mlgYBIlOiqTlqk9VlbXKimuUSaxvX/L86LqjjGK9RnI/Gs0whb9SIiLoM6qaAWZm3wE4sGwRAVTIYkT+paRVxGaIUwBgr2W0qn0eUgOmN+4PGzb5wQ3wlRmwn2gfy9WyZo5hGtzpDWbsJ9zaVSFoWggSSSaLctskTHNF0UT+dUWiHVxihWiRXaxBLEWgM10kgnEr2OjNXM6dhtFocytpExbjZpWBHWtIdqLtPp6jXPYH86ZT9N8LZ9br3lMSp9Gv2Ybq9DZ8lCE4R/36OyhpDotBnhxCdk85Sp61JGEo09D3+YkzaTuo6ga1ndH/HlElNAMRSZrBCMBo2OpeC2ZORKMABS1K5CYanojslqr0FXKggSn6IQIAuZZqvFUrvBzlQsTWIkrYliOnXNIfFi9EphAYPFnv5h9EZs9GY5bUr0Ro9+oaDaVU00zZgjT3v1D5hcJksqjkKPs0mEHM3rg52i6eJYTVlGlL7oyBhk3ZIyEzGWCN1OyKN/XYGQBdNC3HMnVJJMaVj1m1gwFGTVJjVUwvmUyq4wS4kwTOipQ5JQdIJK0rlDqobkwqqgi9iRRTw7pWyqtAwNtbSIjZxTWQBM2ijJHN8rCKU5soBitmJU0yadpmBKKM0KORLRtxaZK9fpkdKSaayayKnMbHzKZGpwvKuR9ueY68Iy0ahVKAKukIjXcybRswwUS0J1TBRDaCwbNRVVwCGVSiKNzyA0KYTiUuSBWjoEJX6Rs7N1ij/2yOYulSlu311SzUdOMyrNokwNYimljEohCxZlJyRLVA1alIX4IJh9eKPvyeTqRWShEQ02kbQASYop4gSpmVEWNkVPgamoyBQUdkKUz+lv+Xzr7ymYrRMu2U30axe5+NISkuLxywdbPKZJvPrbt/iNv/+QJ67Ci9//JIuLBlIWcjxWeffhhLd2PuDoYJ/kVCHdn5KKv9vKEK2pMLQ0monNNMpwKx+7ZRAcyViOiVEmoGW0NJX5TMOvGpiiACjLVIVNWN1B0yvy5iIHhsLFvEVbMZlZglpxPufzezOl8G/7587TDOdzPufzu23sQcLPnZT4X9/ij/2gT75yk68epfBwm+LunM6FHt4XH9D/JZVf/8WA/o94PDtYrqPTMgVpXtWV4icvOJRhk9u39qiOJC6ulJSmyde+o/PND0JuLMqsri4w9WbcnY6YHqt8fkFnsa1ze1zwYDJl8aWU5zsVbx3O2DmO0Qce/Y6BEw14NSl5b2+Hawtd3JbN9tTlcjBmaXGTrcmccWQT3c155hmbl/7wED+O2fqKxz+136KvJXz0yY/wuV6P+RMbvL4lYRwcYC/E2FqPwk3Z2gp52O3wxB++wI9fatJXLY7mE964dcjOmyOKyGX95gqSukhQVTiayaULBt6axtfLVf7DP3iD+LbFz75ywhX1kMOTAU89N0MzYt56X0UpxqyoK/QeNel3hGK9w9FMmANinltTGAouxMRjb1cjiiWWljp05YzRWVnfjmu+zXI/5uJqyq6oixwbMFNY0mNuLGqY/YrjWcrswCYLO1x5rMm6VXDmBdw/OCMMHVpLCY+t9PnaWzM+cWmdo9df5W/+1T6P/5/W+Jt/8Un++OIJD/7hfaxFhSLysSqJcEElPskZmgHRBY8375l8om1TJCYHvSm5qMqjEaZTHAGrlAUHzCbIJfygQmq2uFxWrFQmE6OgFI5yU6vTIMJQsFqpjInouHBRNQkjCSVNGW/IdMJl9Ewkqgvcywln0zOGqURiDtHP4ESTedEsxbGAvIiYF+toagN5ocD32gw7NuljOU4lcdlYx1DD+ly74GS1SjEPc9ysYD9JyUOPfW/K1Euw5xJeuUlliuXGjPt5xJNGTK8f8rBwsFMfU2/gh/PaqCBMCloloavCsiaOJs2aVyAsD4okNI86i+ngQ36CwAvIBmEZIhXid0v1EkBVdbIqIitz5FKuz4RURV2xEd9TUZEQ6kjxa1ma1ksQGYNczj5MNVcBUeXSkpZIkoBMAPbVVn2R6BY+X47ucPcXHxD7K1xMHd6TJIxnre/dMmGh+pBE4msqC1rAimPhSz7CNSD64otaiWp18co5i8sZhVdS6iZlWyKtJEqb2nHfmVXi0h06Dg3DYCbpTFWLjgla5Nd/2cYgRVguPjhy2fc95pHNydaYzJ9hF60aQGIrKfFaxTiaYI0DBksrKFbIE3YbfdrnrxVbpNsTFm8a/EbrkJ88fARn3WRXqAyrFDMWmo8+miTjqRpme8DlpYTjbYMw98jKCltpYglav+jLKyYt3UIuZCZTj/FsXoMXe/0h/WGfs0jc/Mp1T0U2VZ64eJWepvLe+3cI/BlyadOQBHVWojEQysWUq4Kmby+KVzdS7mBWMkEpdI8mWTZFC1ROw4CHozlBoNSVh1zwIgoNVSBeRMxALdFEqiMskNyEIlbrDWAVgixqEqVCZZY4uo+cN4hFJ0ky6tqHMNV4JxF5Z8A89FhuCrbAGVHRBDukGRtUuiDqluhWSOpNKLQ1ymoJSxEH7CZSPKbZmqLZTdSNBUL9DDuu8LQMrapothsERkhwFKHoKZme1nRRoUHJEjA6PZau9FHCGN6tGI9Cjva2uX1J57H+It0qrfU7VSwME4KjIKMmElpLRZYKNHlAnI9QLJMiTikKgyrTayWPSA8UjRBLadcJgv2zPe7u7BNNZuSqhG5VlJmOkrSRrILMn5OKpY1oPog3rBaRVkLbolLKxzVIUqWBLC+QynPyYg/Tb9Z2iErzUduryN0cuWiRBypW4JGEwlGc0BY0V6MibaioYUIwhbvrr9HPelySO0zdlF444Ru37/Nz/3CP4vSEJ770LI8+skJmGkRxwpWBys2r6zzq9nnl/S123nPx7h6THU1IDlVOc1hcTllyFE7mJTvZDCs28SOdQCzTMg3HaWGaCpUk+LBjurpVKycj74x4LNNpNRkoDlaccByn9NWcWBaO2/M5n9/dKYV/F2mB/7FFxnkq4XzO53x+p81/9bbM5+QjnvrsIjvpIn/7nWMuzT3URJiiXPKJQjaoMFunvP0zM35Ou8jKZosLiya5sB9UGXlZIesqN6412IuH7L+W48QKV6908TZDfv3giJ3DDIYyN64ahFsa8y2P11KTj15Y4MmzPd45k1m6r5GsCkq9yXaaEx1pXG4s8uRVk/feO+WeJoxt+zxpX6y5ZpmRECpjbm6WBHOF8Tsm315Q+dHLJQ9+PGT8z2N+81/cZ1cy+D/8uVW+8NiQH/5Uj4KE9357SvNBTKIJ20ROa7PNn/++FS5eadYw+nkgEs27/IN/8CbKQ53v+/QyDdMlsnporlzr3YfKkzz2kW0WbqxwlM352d/wWG6rKItTPru2yTRKeFBfgL6L3n6JpzdDFtvw2pHGLMywTJVnHIOLbZ09f86D/YzYNHnmesaCEbL7QOG2sJ73Sy5eSuhbEvfPHG7tCLV7Qb99icFQWNET3typOJwaXOsULAleWGzyepQRyV2MxQPWvJInLqdkhcQv3LlHZKn8vh/+KH/97xzw3/ysy1/731/kP/1zOn/pgcTpV18j9RzQV3GSk7peGzsx+kkLIym5r8xhnpJqTcrFHKuRYCglDbdA8VTi0zYzxcdedPnUlce5pq8yyXZoeWNO7zm4oYe9PkOtWhRpjLVfcWIOyJtj5HZJsdvCWJ/R6l5julNwGLhc0fpMnz1h8cENxpNXaCxVuMebzIdtek+HhHe7ZMYJa6ddBqZGXk5Zs50aOq+aUx6OxniRw4WBwYIjjmcKoySlqelsdlMeKiItrxMcJ9yREpT4DZaMFcwzDX3ZZu2yhVkpLB+LSnX44TlF0Wp4pyxp5AKoL0QDilEvFQTPQFdMskrU+sXiTVxupyiqXhsbZlKILevokl7/XhGhFksDMR9CF8WSoKqNEAJ3Kv5sXuR1DUIk+E8CH6lq0TBmSJKCrYumjU8oEvSaxLF6n4vxR3GLkJdvvcHt05TIdWi2Am7lT7HcOORHviB975YJp5XKheyAY3sT3e4jyxZ6JeFYc6KgoN1uoyoKSntGkA4IRUR/KhZFJWk/o29FKC3h3ixA6BT1NoacM6/EoVShLQdEkUJaNGipNrmvcnt0jwc7U5q5TRxLeHZGelZC3ib2fS4lHo1KxZ0PoOdjdB0uKI9CV+Mvf+Ilrv6oXTtxv5mcMnnjPXYPVL5wuVMrJl8ZnfG2G3Ihs1hEwbB0ItOq+0JSKqEJ76khmvEVqVpiOBW2KdXQi8gP66iNh4ySJKzZFitth63JDDVvYzt9LthNFL3C7DSIk5jEFzaFlLLVwhTx+ULDkTUiOURJKwy9qLsylXJGNGpRWBX17sqdMfNHgsiA0dZQZzFqphLGLqFhYLc9HFx8uySVmyh5B7uoSJWohlUKCqocq7ilC6WLolpYcou0LNAE7cRRSJMjtLRDbs3wywvonFFECUpLvEBuUnKGmjXwtYxGmKHJUxI8wtKmIzdwlIRQEEDNkkdXdULfYc+VGKXHzMNTIiwCpcSINLTURtdzdKVAa9qsrHUZDB12D2WyvIUqagEi6i+bdFWzTiRkgUVil5TJKab4wGsIBaYCQs8o+j9FgSJ0PT6oVkapSpg9lXJsoAiqiVCkmCqlKiwXIu2whmmkSHlJJeI9+oSssJBUkXgQgJSKKPNJ5ay2ZBRlhBIqKLJFWXMqEgqBKDBKcqEwLWJKqSCanmDGfXRDxRIbUFElkGWssCKNRUrFJm6fQDFE6dqczmYc795ilNzCuTukn8Ohe8LkLMHuN1jZuEq/1ycR6JRKWCAy4aTk+eUr3LQcvhbs82agoyy0IZtwIMWcGTb9vMSuQmI3p1BnHAcKp6dy/dpeUHMmSZc8icizirKzDMUeuWrgmIJr0UZpzbAyDdWU2M9KHL/33T2FnM/5/B4yPvwP4Yq/k+wS53M+53M+/2PzvxkesrLW5p+5Mgt3Ap5474BoRa+fix6cnREFCQN5mWU1rPvq4V0JZnOKoVJXWbVKr6utSZTUNdxHHzU5G4+5uzPiZuxzeShxclPmnXs5d9/LCC8XXBqYvDk1eHdrjrxY8Wh7iaPSZ+c0YsmJeGKY8O5Zm3HSwknucrN6lBeeSTnMuwTJHKWd8XS/4K6r8a5vcS13eXHg8PKSz/SwZKfs8bkLEsWnU17NBtz+2WP+auc21p+V+MKFAZ/75DrT05j3f/49/Dzi2uev80d+ZBl7qHCGghtPef/1Lb78t7a4u7XLwhWdrTymmTyCthyjhV1m8Ry5UdFpbHB35wH/8tct+hdn2JXDS3qXD2SfdzyP5oMmjYXH+PTjKe7+Ar+4v0U0DnBKmccer1jqKbx8LHP/rRxrDT6zUtLT4J09h50oxLR91rU2fcNmb65w/7DAqBr0nR5L3ZDKjvnmYYPcn3PZzthc1ilki1vvZ0S5gMOfccNe4ObjKQczi6/tK3SqjPGCSb/Z5j/+szF/+W8c8Bt7AZ+/vMpP/0cr/GcfhJxFM1oDBUEQVGYK3rRDr5pwaWlAei1mFqc0t206Yx1paUByIebEzsiqHC0SaesGGxs9Ftomh2XEri7RHFsMXGFny4g6DfwqRykMkrIg2Jih7Ohkjbs0124wHDU5Hr6NsWwxejlkuNDimVGDo7xDz9aJ3et0bryHwpPED3UCL0fbU1lZGlOGXRyjzTRXSOWQQanVF48GRW24mCsZRahhqwbLvQ5KKyKYVKhpH6c3IXRn5K7MfktFWVF5bKHP+hPC3HAMXKytfD7vY1bPoIvLdVF5qPPSVa0aNTWHIJxgmg6V4K+JM6Vgw4kqdi4S5Ca9qlPrRwtxeSxLxGmMokh1yqcU7sxKmBskUJUP1ZKlWsMWy6rCUlqsNasPtZB6Gz/3iXyDGeu4vSmXUhu7cDjc9fnq2VtsbelI2z7GNMc1FhhwxP/2T1zmoPv2926Z0FlsE839urshNiDTuKTbzzCkGKt1qe6E0KkoTzrsH98nmoCaFZSNktXOkOUF68MXRCmx0rZQlJJpnJHJGYojkbgK1VmKZmfomkXWn2LbOnI6QBeH+c4xqtdE6+1QjAv8g4JXDY+bzzyJ9AJEwQlXW106Ukbv8Y/w6NIqpSLVWpeP2euoH1/h9rFHUJwylDJ+oN3lwHP5+t42p7OYTc/mbDKm0EOUnoKBAKF86AftWgbr7T4NzWYSZaSygaML4KRORzeQFRW73UH2ctLEQwvgV2/PsYs5cqaSJz6JrWPLDYqo5OHkhKu9FnI7Ipk1CMVWyTNrwIaerbCbzxmKPpN8l0gVL64eST4jTgtytUmeaGRZTtGRyEQ6IBGqjw6ybNMwTjHVkpgGXhqRSwKeJyGnDoUsE4mvR3Ru8iOaAnERtYgjB82qmLckjDJFaXYxWj6GKVFKCaXgM2QTjKlOVCmoZoQ+E5WQFr4ecOIq/1ofqNIrDaTiiEZuUkx13KxE1ktsIRxRBM01pNINqkaT5uU+/ZtDwpOA3Q+OCF0Xq9lkfX2Tq/0lIXNgVnrYagNdfNjlbVLBCRALBpHIQCWdB1SO0KQolFZOKVSGUYniyR++uj2JVEpJq5iB3qbvmEyEElK8jmWRrBDcBlGPUEi9cc1zqF/LlYRcOJAGSKmBFGuUZkUpollegKx7dRKnlE0KYVowTKqwUbMaEm1GpZkoCxWd9iY0A+J0IuAFSE4bNRXJHQ3b0pjqLrP9jPnZiG1phlSu0hT1GEnhX33lDk7XZvPSOkuNVt2NE+DKUpfY8yr244g8yVnauMAnn/wYge5z7yDi8P6YRL2HoglvbUUeibpGiuR0ODiKyAKhOLJQQpWkcUK3a9EQiszsGg+L28juJVJ1jnUk4aXH6EZ6/nR1Pr+rUwrnrITzOZ/zOZ//39MbtvnaxODsZ7bQnQj94hBN2WZgrPFg2UN7Y5Hd1CMVVjChEm8mtTJRJFGztKIqcqpUISglckVm1XK48aTDG0bC4WSHQWPA8+sD2vMRr7zqsV8ELF0z+GR3wDdzl2h/ht8ueKTo8XVpzu2TiI3OgOdXY7691agvL3/7Qc4nL60iTe8zyy22XYPlVsbVQue3ZxXfeiCjPjrlqUsZL+/Dl9+V+NLjK3zpCZvp/dcZjc84/JrEb61ZPPYHLNZXu/yBT63ztychS37Bn/jsIt2VBrNcxvJnvLV7wn/+K1uU33mDK8MmBMvcPVGQ72/xWHwNu6GzYq0SJDnfun+Hr74/oXfJ42nTor90wsvjNtH0LYqTy/CxMT807PD+qMft2VsU0QLDRpunLru15vtoJhNJCtq6ytPrDlZi8Y3DnP0qp6vpXHIcOoXMnqcSqSkbDcEzcxg6Ew7kioN7IrGbs9DpsDA4424Zo4xl9Nypwd2XN0+47DTZGsu8v+9DscRLC9BJC3757X0+daPFH3y2wz/6mRMu/rFrfObpLl/+4Wf5ys+8i+s/pJ24FCt9dMkiMpaZrhpcjTNCc418USLaKjHubhF9rEQ1emRlSG6F9CpYjgcUaJy0DjCPAxjJnBqC11XS27UZL01JejM2j22GRxa65RCmG4zDQy4tXOcx+wrfWNjiEWOJo903sC+9wJn0HsyfR+u9zc3iIu++HbK61KQ6TrlqXcQ3M+bTmDJRaQxmLJQdtKOAcdigJUtITsRDOaUhzjWZQ5RmTKcub7z9kK0DB2tpQDtuUOb7yLJG43aP1Ss6K2tJfQ4+8QNW2n1kZVhXEOJ/zTnwIp+22akNDJVSYhoOaR7VisesCGsOnSKZ9SW7WC6kJB8uCSS1Th2Yqo5rTgjiErtsEaeNegFiajFKpX64VBDIxayoKxSyopFXFXJZYeQKmZUilx7XomG9MNk/NXh1731OvpHjNRRaks1s/ZRrvTW++AWFndYOawePfe+WCSt5A9e8xNX2HlVpkhoFDXWZMywmdloD+Jxxzun4mOjUJXA72JqKIngKSoArYhfVgJ5mYKgZaaTg+2Wt3bNjmBYFfUliUevTtRyCtKIrh+itEVkREOQqSjxHMgzKVkp5uMj0YJ/eT17kT13u8c9//ZCT7YyJIdN9xq51NGklCJoyuVziKDKXF9scBTLjs33E77jQ6vIHH20zDiY8FJtV1+Lqus6zj5rkVU6AxyiMMVWTjmGiaRrDjk630AmKFDUX26GSUi3oaDpX7Bb3pjlLXoQjBaRpRqxIVIr4dQtdUYjDOTMvx1wwIDPJtD3CtIceVdiOQ6YFpOM5o0IQUNWaSZGVs5oAW2HWJgmqfQo5xpxXGEWrjrYYZVArBFUjwmj1UbBIDy20iYVS+mSSRlKaFO4xcRSi9lYoO3OSkUZmNkjjlCA3QPGxhOqk1aIhNZHKIyZZC13VCP0KdcGkPJ3Aco9Ud0lnKaYkIZcpo3LKsS2cN33SvKyhIgOxHFIlTnMNX/guMxlL02h3ejxx8wYfudLl9ck9EjdBTlK0bkbROSXIYE+y0dSclgCHKBWhJDGOPXTLpGxGOEkXSVIxTZPSj1FFnUbz6mVUEcXIpogQJTXcUABPFDOhs9JCCUPS+T5p5aDLCnIkjCEupSVu/nVyb0I2j8liE1uRqVotioWM3D9FDjW0vlWrM0m0ur6jOU0qETVKA8qWQVUVBKlLNYKz4ojlfhOpKeomEcrEJNcEAFEijy1M44iq2ID8FEdZgXabUPaIw4Tf+MqbvDPb5Qd/9Hl+7JlnuTjooRp6barYe1cifJji+hmtvsLmY4sMFy+zsXXMPzuO8LM+iiqRJS5loVEZLmXuo4UmkzhAzhKqdgytIYbSRrE8gmqMKue47m3WekJlKkCMPcxo8fwZ63x+182/y5TCv0knnKcSzud8zud3w7z8LY9j7zssbjZpWf36csUunyRMItYee4zD7H2+fsuh6U5QkwnvjtY5CVZ4VGjs9Jwky+uee1PozKuKvGzxkQWNubnAe/dd9GMf22xirTVR9iXCscVOcspa75glb5Us3OFtI+f5i2e85Nr82t0BkX7C2qDHC1emfHW8ROD7fGXPZtU2GPYG3NkT2vRjLqVLvNA6Y8/OePV+wWceW2JF9ZkHGS/fO+WLn0h4/tOP8OXyAOPBlK//X+6yqXX4iT9tsrrs8Gf/yJNCmke3J3GEymjic/TGLr/45ffJf/seg4FNuSGA42ec3lnj4Cxk2j/jSz/R4yic80u/cZ+7cRPHX+bKp0544mtDfsl/lfv+ZS4W93jkmsMLyy2+uX3K7aNt1HCF1ZsOH++OMSuDX76nMp3pvHgh5PtviARrzOs7Fft+hdWUuDzUaTc03p1XzI9zNpoZa4Oi5lVsFRoHhwaKH3LjMYXNTsDezODOex0a8Rndqxmf8JtI1hpffjvB9VPWhxbrNwIWTJuvvt9iuruPZ6f80S9c4/XXbvP6V3YY/Hsd/tM/8yQ7WsGDf3Ufb7KMqZ1RpSNSNigbObc/2eFFHbxvZRwEc2KnR2PLRTZn5HaXbqtNw8g4DPawzpZ5bLZOnHm8lt3m+DRCu9jn8MIxi/dSTlorVKFfM+ZGAkYYFmSuygNVYaFdcKNs8hubCukkrGGC862Uh+oHPOZ/hFYYczZ6BeOjBU09JY1VDosQR99GPt2k1B2CR7Xa0nd6O+ZervKIrdJLUsKyYlwWJI24vswspgmSSO6OVDRRwU4MxsqI1lMyT15X6MctDg+fYODMmMc+ZZHTtLt4YUTHkui0O9xt3uHCdJPAnNGKBuRZRiZZlO27mNnjZIJ5pwlIXEElLuWrgqJMkYQanhQn7dQgRXEq1JyIQlQnclA0lVCdkRFjl52ayyAqD6IuUWQpUR4QSSGaWjGK99ne8/jGuxHBSYXkS4TzDK2v8kM3XuD7v7hOR+5ydjbn4R0BbPweLRNSY851O+fuicPBvGI5SXCTMeNSozUpcBYrDEdYGiqM8gqpesDypSbL11SWzAuEDTBlj2U1Za7qBJnEgtalJ1uEcYER5Sw1miwsdpDMf63IsEIaWoInWUhBTmU2SYqMyFIwHB01bdDdSrnDEbujQx68Z5Je2eYnrr+D22vXSkLxLVDLklCpauJ/RzN4V6QqshQvmdFrNLnQWWG9s0K4HDIOfSZBxNl0TulrXNIKWrqBbhiI+1mhkDTtFpYgZ+YJpSTcoBWSrqIsGaT+lH1PZXloYDYadUdM8AHyIEBvGAR+RhmK/w1o2BamOsAnIdaNmqfAXK9jL1MMlExmPD1Fi02SxKudveLQngQSsWAP5G2KRMcqZNqmgmkMKWaiejGhas6pMgH2EF+0kChWZP4xWinEGVeQaKHNBe9CQjIs0nwXM1smFgBD6ZAoMVlqacRRk0LE62cqnjlHmRQMFgyKPCWOPPLQRLPaxGcqmRTUCQRbmXOix0waFW1DQvy3o5l1cNNjwtimTAzUwYikHBLNDLLTHDW1kOwPEwuLvQ2eXG2TqXPcsUVJWrMtHMWgs9BEs8SmO6H0C0pRV5ho6MMWxVhGSl0K8Zc2DUpB/mwpGImKYiu44Zyp78I4r7kRWeESJDMEEqDMhnV0SQAU5dhCtWQKQ1BUY8p8TDkXh4MBipxSZjGy1a1tGgLMImvC95pTaWkdDyq1sv4PpbB7wBGjUwt7awFrZYqknaK0l1AzhxFT5DjDTDTizhCtnSC52yiKReyk9CY649/e5188POSNLx3wF37i87xw4SJ+lHHnjTPOtg9RVxs8dvMKl5ZWiLSE+aRksjUnm06pmhGq+IQRH4AhNdtEkgM0c0hiB1RFk2JmYjRzwuMEr9zHkjroDZ2G3mR5sc08mlKowXf7HHI+5/O/2Pn/l0r4bpYB/8M/e85KOJ/zOZ/fqXM4eod2fxVDEjef0Gk6jEczdpQpm/F9Hh61CbdS7pcRL2zoHHoB3zqIuP7IlGW7g5d36qTpWSyxENn1c2milXxfr8XK4mUebh8RnY1ZX7T42AsDfuXWPttnU9q9FT6+ofPNd7s8mBbga3zp0Q5h+QHfOO3x5q2Sm9fhRcvjq/elOin8kVbKeqfDm6Nt3JnJ2E54btDgYCuAVOW3DkweXw74xMcs5qMYJgt84kKf2ac0fmmmcbYz4q+88xbx7YA/d+1R+sMFYIome8y9jG/81nvc+u/f5u6RXKsq7fUOsZQxLbqk8inWrM3KRsLWssfbvz3hO+/HbAwKfuxLJtOXL/Eb3Tnjb22wtJjz2I0nubpS8i8eTJDet5GaJU8PR1xsGtw+G7GfrjIa+ywuNlhdGxK5E945yBhLOmurKVf6GWkB740LTmclS47J8rCDmiUceRFjRaW3EHB9M6HfrjgYV9zfVuuLyeFym49vhEzilG+dzpH8Dv11Hfmgxyeeb/Lf/dZ9YU5neEOml5bc27nNn+w2+H++PuORzTnFCwn/+Z/s8JfKT3Hrn9+iddgh2NSRZye028v0bI/+cJPZakBw55CBUeENbGZNj2XLBdnmUAddK5gc7/It7xazOMaYLtMcGmy2S2ZeA99wiLundLQmIwK2VkxWHqSUyxX5wxNeNQ7IVhWeaw/Ytq+w4+6QTDqoew9RfuQBCTrKY30emSq4ymXK1oxB1sQ1L3PySY+rYZPGKOEgzlhcz3iyLDk60XhjJtVAQ9ve55n2Avr2AP/lASYG7aZGupWRdDv0GwrRccy4lAnCHcb+CofzMS+/ExA2JkTRkNQ95fd/fMgN/VFuzG/UjIS216GQitqMKGchRvg0SRnjaxF2UWDJFqpgzFUf2hQkycAoZIo8w5PcWvdo5mbdFogJSZKorrVLzAiqCXp1AU3V6uVdUqTokkFXG3Iqz/gN920++C2J8ZvHmF2d+PkB+i2Xjz5xiU9+scNJcYae6xiGzMqV0+/dMkExRBSiCVmA05XoSRYLdo5iQzddYF4c8XBaEZwtUWQFZqfLcqfJhqLgFglJ1GKhPcAWFr7MQyrOCAyHdqtkgZh8tkC7aEHpUIUmmdAWFgbBXGI6v08UjkmrTQxtgCV0frlHqxvyi9/4V3ztXxq0tS5WHDMZ93n4ps1sNOKlz/wgzUYHS8D0PuT6s+d69MKQpq0yCxL20hDHLug5NpalMNQs4QdkGsw5Ho9paiaOLqwIWn0jLIiYiXjnoqAmKZIsYSla7QmtZINFR8Jzc6JcxapyjFI4dlU0Q6EUSwrRnXdiWnaP3IwohYYvNZGXwlrnJzkFPdvm6FDnJHZJAgHZyCm7FfnJlEpVkcoOmSvqBiWKIZHaEoWfohQnJAPxdWp0S7HpmnMgujlRQS6ltTbRsFTIxyiViaxOMI0QX1QT1AhdPcRMFZLqKkNbqVMVhmMSuyVSkdAU3RwnpfJl3OSMKLdQpUAgCZjIMX0nJM8sPBUubNo4WZ/ZwR6HblJvRfVUQ04LnGaB4ua8/lt3eKP7AG/XJciEf9VgraHxeF/CUR10pYfuuLiJiCIVYIr2gYvNCkSNmoOAbIKaEkz3UHIb6V9HhixTyEcDCBRSs8AMJL7jpjzYzgjHZ5SOTTYLiDOTwqgwzTGaI9fGjEQuyMWSxfeQJ2YdUZI6sxpWggColDpVMRJeSVRtkUL8/FFr+mwWRugsUBg+wWy71pFSPCAYasTBIqlR0T4SqZ4ER/FRbvSQD46QZgZey0cvsppqWxUCpLlVfw+zB02+/ff/JX9+/ho//SMvUu1U/PJ39njv6TE//SM/wOdvXMOwRaUkJPJ9IteHxEVXgvrbU1oV2ahBKWkY1gxyv45DCabDztFDJmctGuoASTpEsT0wh+xFe8yiLXTVZkFpfjfPIOdzPr9n538ORsP5nM/5nM+/6zk83eWhO+ZoI+UL1fO4yjGd3iHLh0MejGy+8u1jTg8y1r9vwI0XQx47iXnttV0eb1zhCx+t0IViTorJvIpDT2Egxagtg6iQuDBU2Xu8wzuvxjy5nXLtuoHz2ICv3a/q9MCMbZbtkvFIY9LOefl2xfPXrpOVWzxUlnnlQcnS4CKPqrcpnTPe2DXodWI+52T8hqozmj1k6nV4ZE3iDJ+jY7jQ0ml0QnbNIe8/DHgq2ONzmyvkn/H4xtiHXx7zK3HIlT+r8rmPigNawLcCl7/xK4e8/3+/zePTlM1HukzbMtVJytSSUdYbfOyGyda+Sr+l8nzus7Z+k3duSnxm4ZTIz/nKvQD56RGNjat86vETKn/C3z1aY+NIZ8uxeGnpmP6Swi/sNxglMStTi42NHZ69oPDBkca9raxeiFzfCLi6ZKDsNfjmZMSoJaCBba63fAo14TtzBzewcMqYfldGt1VePpQ5PNNxVJlnr4UMrYr3xwvc9eGCH7CnanzqgkewMuNn7qUMxjL5YzEXBX/AmPJzr9k8fl3n8qUerx1P8Y7hE/0hf/MPfow/MUq480tfg/kK6vIAu92EvT6/orxFbBs4zy+TGSH9bsolq09azjgMj2m5AzpSk2NZAOP7OLrDTMqxq4R5NGJNG2C2NGbTKxxUYwq1xfVtk05u89B3OHn8gKVpB2k3Z3Z9m/mvmBx1RqzYMrtdgwtjFX1B5kc3LzLtuTi+CnunrCw1GFewKp6NE3gojApGiRYafJCm7E0LFgSMvjVmL1F45d0cffchlT9F/iMVD69VGH/FoWFG5OmMm1dWefGJq+yFm7hRgH/gcf9Xd4nWbTa0t3lv9wq/uDphsTulZw1J5YS+2SdJI+ZkNAuFOAvqZLUaNThr3GdQDFELA00Rz/dz/OaYxClRxyVOKOwPYnkmE8txDWU0Sr1m9Jls1qmFtMzI45SqzJA0E1Uy6kvgh1v7vPtthXw6ZbCZcJoZdPY9fvCLH6H/sVP0fIGFtMkoPUJVJcJo93u3TAgsjaExY65WGJVO3zHwy6wG70XZPUyRbh+ljAMLsz2lt6AwK8fsbpWgNBh0cvTQJ0pNcrOiUB0wWsgtk1WlQ8cwGIcnZJJH2alQggPKccxRcgYTQeh/lKw8I5ZDmu05hZGB16DMuhRnMdnlIaY2xRg4bK5tsjse8/f/0T/GHC7xmec/ynCxxUyVuXPnbVYMnVIyMBGu1JjgeI97eobSyWlpCh/MhAkgpJ1reE2dozXR3feRTgOupjYdcWCVhWowQRIkPsG+QEVWJZx2q048+Mdjbu1FHBsFj/U6PHZtgBe5BF2Tp7DoLPeo0pRJK6N6OMZoL0BjWoMZvcLmrJoym52SpgXdxglV4DBrZ2SuRGJ7WG0VSzhGDRniJUpnjCe7JK4BLQlV1ygU0WlLUeIJsiB8RhKl6aAqXWRrQmFvkHCIEgZkyhKnpzGWVHF5EDBU+pydHBCYHmYqqhQdyl6M7K4SJy08+1Wq45iW0WJe38rnIvVPGqoYljiAJzTSOaFm4+iC7ZDUasbCkLHbPs12h8VmC7nKOchM9LbG8kaHTz+2zPJqn1gpUSTQWy3KUUZcVhTJHDVrE2YRWkenDDKC6kOXqp59CK2UQmHr0JGjAtlsUjYkMDLikVDhTElOTggznWK+T+PqGo9dvI43ddm/s0/ih8i6XdsOTMaUqUPQisj8IcV4EalxhKnJ6KpFWbUotTmS6pIqAwo5RfYjip5BGWZ1OsRYaYN7CX/+FmYoflYtqvgB7tynWLqGJjUwwwS5eYPcmddJGyXIibUxTt4DrUupq8hKyMBr4P7qIf/Rr/w90mOdH/7ET/DXf/LP8syz68iSjJ/HHMx83jubMMozhHxFb+nYLRWr7RAv6UTRDvm4Ip4JHkQLY+GEnjlA1W3yyqXnNHEWGyjpGEvZJI0h10y2Z9F3+xxyPufze27+v5MI56mE8zmf8/mdPGU8ZLEn0T/uc1reo0VEtQE0TM7umUjtNn/8x3Qm4TJlIAj7IVf29/ja/81jIV/jI59eQtcayO2c79ye0t6OefoZURVt4igqqxsGv7btMN8O+Px6yFrP4bmFDr/6XsDegsIjcsZqq8s9/YydBBr7Ca14hdVqm9dOZJ5ZS9H+8ALbv3bIPuu8+soxjzzVwnngcKYofHW/4jPrLk91KwTmO1JMxmHAEga7/py3sxxVLfnxZ55gshPz9s9vM/1lm7/x6B3CmyUXzIS/+9/vcPe/PqJjTThZgqmiU/k5VRcurtzkB686+GmDS81T3o57rJ9WXH5kzn/Q2+Qr/3xO8DMy0+szno1KLm6qjGOTO5lM8+0xx90BT28cYUoDvvkAqqMTlrVFmgsmN3rrnM1C7r27z7yt8snrGkaVsfPQ5NbYpgpbrJoxG2tzXL/gvYMKP/NpWwkrg4Qyb/Dq+xKTM4mOnnD5EZUltWD/rODg7MPE8tA0efY5ia2HJg/HQ6bGFh/52CIDecRCU+bLvzDgtHXMOCr5sUeWWewPKY5z3tuXufLYm/zw799g/IrOhAnPXuhhqitU4ylLZxfplROKlW0emg7zUuU0DpH2wY4bNPoWbbnAUkpmGoy1LeKNEyz3Jt7FIfuTGc/pA9bFzf9YQw7vMtYu8cLAputvofiXaPgB+402b/o7LGzdZLx8mU7gYwwf5W7nIS9qK3WKu6tZJKVH3L9ApCk0KpMj2SbQMvqdNaykQs2m5IFXVw/clTGyYzAYrTL3Spqhxs2Pfpbnfujj/KFPqbzzh475Sz/zi8z+qoWmW4RExHHF6bTiZ76VkakzrqUD5tYV+v2S4D2d3ovbPLxUcGVrDc/3xW0xvcogL1M0zaQqSlRlzFK2Wv+aJnhwVUnX7NJOWkReWNcadEMjTkSl2a+XDZUiztU5lVwydysiK8Bup9hek1mVIlkKTpDy8r07/PxrZ2iVg5GreMUCm80mP/m/WsBWpwzCDSy7yZkU1RfxXjxl0Hr0e7dMMKNjSusGXebYlkxU+biuy/6+zGavy+KCirM0Im/YtEOTWI+5F4r4us+CPUM3U2QWSacZiRlj2ku0KodBIdFUMk6iU/aziptqE0ZwNK44GUvYqcLMUEmzXeRMQV3uYRQmhSVuqyNMsyAsU+R5QjGIaDkwS1x6Cw3MpMWD3YfcOoEvL3l832BCL79CYWmEQUGZZlDIzOcRkT/G7ragWbLoTciDgkAteaK1ybMLT6I4KvvOMQ8OdtmZCVKEwsBuCawBcZkRxBHNSmap2UYpKt4/HPHNnT3Gc5kLL5qopcpIl7iUCHKpUO2piGCK5bmcriqMJ1O6UodxGuOGR2hSTGpKFOOUWXdImoiqh7j5P0Yhp9nTKYQdQABZZLf+OppCH+KE6LpEuxD6P4lELYishug2UBFQhqckTJCNIWZ5jFIMaA4m5GOTKlGZFSGNaxbj0sMqV0nDpKaUSgcBeSjRSHYo04QsMSkqB7fUCMo5TlmRCuhgAzQiTmKFNHcJ/SYNTYVBRjrpE0U+eRRB2cQ2ZVbsPr0LJu8fedimUr+25DxHzjIiI0eX2/RVg0ArCDMbVwvRJINo6tJSbEylIvdlaIIUF5RFStpvUAUVuilRhRG23WBvcsT2jsdkUmLZMguPPsX3PfUMawsKD9wpfqBzerADok9UhKhhG1/yqDpgODFV6QmGIZkEgZ5QhRVGbXdQqYRhw1YoJRlSoXXRyBoyWliRSQeItkNVFqTBGeqwR05CVk6YuRnhRCQR7tDoy7RtA39VwwgbBLKLZoYi8oEpLREvQy8vuJ630dYVTje3eWjv8RjLmLLJUTHj5Xv3OHjvDv3Qo7I70CxIFDDyRRptm167RWjFnDg7JMUhlbFG6UsE+qROuGh6QZX3cKOCqmsx3Dik8Cqa6up3+xxyPufzO3L+p1oZzpcH53M+5/O7aU4cF6m0+c2rE5bmOk+dgu8u1qyuLbdi2EiZqhndhREn2wYTJ6dnqLwzzflHvyqhbUQ8ct1kpWnwyWckvnnP4NV78IlrCaUjsR65/KGrE37zxObeG/usP7WAqhq0tJjD0y0e9q9yY0HhUSLePlN4bdbkalNmQ5NoPWrQcmQG4zZLT+iEh4JpUOLvR3zuhSH7pyN+5a7Cm/s9rt3IeEQuOAzPOCgr2qrFU1cSPhhJvHXi0m5M+IFPLiJFGk9ZCp9/UsaZn/BLb2e8+tsTSm9CtdRGby4z9HaItIr18jo/+KjDq9+5xwe7Lf7YH1jkkZUVvjU7pV8e8dTyEu6T1/mbr7zFD/QHXFyAnckh97dbBA+arF3WWWv3aDkVSThnPOqy1njIxUubzK4c8dobi8xvn1H0LD65IeCVBre3Ne4eTYmVnMevOdxckbk7Ldk+bFNFFT2p5LLeR6XiIBDPkhHdhZiVRz2W5TVe3rY5OlJoNSKeN3Q6F0NePVKY6iccxgX6lTHdB0/BlWP+yTsu8bDLgjLgi19ocKFYJwg99t7PWL/WYLN3gx94qcUvDp/F/eBNxrnMRmfO3J7jT2Myy2cYLbI0azLJR7TliLxrEtoyZ+YRghGu7NscJBVJ1sKaWfQ3KqQthbPE4HVpwuDplMvv2ByGCWbb5U63iZ5peO4xU08hjAJkL+PB4Ajt/pzdH2/z9IlFFazx/lxBrkaYF2xsT2eppaNqMpMjA9ty2WgrjHv7pCcWWxOPpGFhDzyMkwh/pjNfnJLqTdKtizwYrrGy2WdVwBGtDj/Ykfly/+dZf2xMt33EVgT+NCEzzhhdvMDR2SHNWYwxX8fraFxfVYmkKXHcxtDsmocgNI6W2RBMRmSlIoqjOnVQZB/aGkQ6XUAyk1ycRYRiUpgPS+I8qaGOCG6dJIx4OVGSkFQzqomKFLXJmymNymEyO+OtuzN+9Zs5qqi4B7t4xjKXLpT8vk9beI8qXD6+wDg4YzL3MEIBaxRgxxba5MOaxfdkmVCOc9TsDklzA4mQRttETQf4UkzijdlPbeZJydJaSXMl4d6RzGJVULbb+HKDbtmob9MLS6WVarjxiNPCJc4V7hopjcihEZp8UNxDdmPGRyFSGdJTTBLZREoEGbZCPYmI+ha2bSP1TPR8BoMOseNjhwWB6+Dmx7XKQ04Mri0sCBMnn3Q17HwJySpJVA1dz/BDl5SMmTyu9Y9ZskeQW/hRSeXGzPyUHekd5j2Xp9avsbA4ZLk/ZOKO+cbZHj9/OOFGKrFpNdBVmcgQjlCFBd1iS9O5vNLj06s9ButdDqcjzqqQvhuwd3KIlFymkBSyFY9L+Q0Osx2CiUunqNiNGhx7U0LxA6+6+NM5uf+ApCxRGhFq36zp/GkcImc6kpVRaAqx3aeVtcBLOSKg0NV6qyXSHiI5oIrekNQmTYQlUsYwxEkzrWNkthXTVYU5Q8O3U9YUDb0b0TR6nCUPmSd9jF6J4pqEqkkRHOB0E5QyIfV0CiPE0ErkIiSwuiiKRhROiIMRmVQxXOxzqWGzdxrgFTIjL0Vzj2oNYapaGEaBXPrsnY5E0ANroY1exZSpS4mFZGTYuoOcCq9qTuj5KIsGaqQhCRFGCrployh9YlHjkBxKweIwm4T5nPfv7rK9e8rgYo8nX1rk+vJVPC3i1985ZvfWHWZ+ROUr6BFUqkOkTSkb0KCF3MwosgbluCCuPGShzYxKNAFdLFUyK6Kssrr/VcUFFfexoi6l2sTMS9S1NknSRhOMh3hOuWcTbExw3CFR95Re0mYyahBJMtayePNapJJUpzCKRkFYZWimRhFYHGouhq3QeWfGf/sXf4H/8ktfJ/10SPRgjPPLGRePNFoDlbAIyVINw1hCtnKwT9FtC6u5hNJsYilnNAuPcGpwKqlolYyS6RjVDD8b4MXbtI8HyO2EYnjy3T6HnM/5/J5aLPybXz9fKpzP+ZzP74bRWCAqPfrKAn4zQD7ZpEomdDYX+Ph1h9e+rqI+nDEd+jAOWXAMmpdzntK2+c5WzK995ypLaypNp8Jsynx0XWZ3z+PwYM7Cus6Z59DPNvj8EyO+6Uq8cWvKxoWYj9/o80vfucSen2OZFc/0LYZywdlJzki6zdWVHuu9C/zLrUOU94745FMSN1sZrz7hEJxmfG1zm487Ns9sJNw+i5gct7hYdLClEzj1ONBzhpccLg7H7EwkfvXBnJc2F/ijf2gdqbHLYVelOljg+OW7aKcRUn+NuJQw3TEN02HliUUGawY/97U533xHRtfHfPn2gD9zKeQLzVXm2xbtawqff0Tl7Y8uIp+cIvsVR28ptYFr+cIhn3pynduzfV4PfZ5t2LQulqwmV1lq5zx82yDkjExt8uJNk41GzrdvqRzEAbnSZvliyfqFgAd7Lm9/kCLbC1w1Za6YOeOVOe/sFmjTFRYuNmm3Ylqxyq2DrOYwrK7CpaiBcXXK23HF/m8d0n3mCpevn/EDjYv8Un4C+020RMcfyPzHn9qkZZ1ytnfMb08G/MjzC1x8dEDb6TPzSrLsZzHmBQ1/xt7AppW0UZwZbt6vK9TK9BDJLpm2I6xkyuLpIumCwUQ5BU1DUkrSmbgRX+TMmpBrEumxTRxoDFoVix2VJHuWd0TyRZvxrHkRL5pSZRVhWrLQtFichXwrjNFfb9K7PkFR4OvbO1z42DqbBwap6XJ8VIHlY9oqHaeNO0zRXe3DQ3wlsVhllNUSZ0VBEJ7h3wnJvYDRuGQ+b1JFXSQuIZ3+MsHdv00aPc7NmYOkd8hvyzzYzvmpL15mYbjOz30rwH39Fgdhhtz2KbWY1vYXiBAGBwldNslzAbeDokgQX3DH7BNlIYouIckVpeiS5zmS2DYIqKIoz0sKDbNZLxECzWPkiptt0CUPo4LKgqi1S+ycEJ3YfP31Bt95w8WcTMn8knD5Oi89VfLRZ27R0K9x4WiprusnwighS2QNna6xwDQ+JB+Y37tlwkbvUR6EI85GLvOmxPULOmdVyaX1Jl014t3dKduxzKDIcKwuF5oZrpIzLcS2SKNUcxLRfZ8bBLXUT6FliJtkmUZi0hPOzLSkPAnJhYM0neL6UyLxvbNM0paNLB2SxxWF3cHodlhbWOFk/5hIymhUe8itCzALmU6bZI5CX7WZaTEdodMTARRNxy9iRqMZlmRhaSpZJZEUCm3dpoxMdlOJs8BF9j0UwUUYtfDe9Xn35D2kwZDV1RXWel1+rDfk82tz3jsd8a1Tl06UcU2wHGyD3NJZv7lGv29zsd/F02SOD12KM5W3R2e8/YpEe7BN1zS5wjLS5iFKx+TAndF1Mjq2gXLSJBPaQsVH9gskTaf02igaqP6cFL3eZmmmhK5VOLECgcgEBGi5qCtoHx665RlJYUJqo0gpiiahGw1yO0SRhmThhGZmo7RFnmaCVhnoWaeOqU1Mg2bXx5oNOFbu0z7q4AtdpJ6jpDreWYIm5XXqwuk1aHZNNLNFMPVIXA9Z7yMZIxodsAYtbDmnE8bEhzmJG+NWOieiYlFoJMqAvJQ5C3JW8wIjFosTk1ROa4OBnuqUcYbWUOoPh7xtoqUysX1GMxuQ5QX6gkFQ7FDFDuInrmk6hRqRHCXcOx7XBo6nLy/z1OIV3vcjXn5lj+0Pdikz8cFmoCvizRsjBxay2kJRRI0lQ47Fv1OHfo4kUhVxSaTINYBRKdJaaSOh1WyFshPTLPvEUYqSxBRGQHQmY4YGVdtHypbQl6ZkUR+p6WEqF5hKJyiF+CAp8E8yknYbO5eppAqpMcXIB8RSJEQTKOki0+AAJb/LipLR++YBfGfO+IOUk4nD7QWLS00YVk1GkilKSCiqjWn36/SBKoHVEgrPJbxJm/lshNWVUashzQYkwQEI14mU1R9wmqpTRuF38wxyPufze3ax8G+sDudzPudzPr+Tp1LOUEIB+M65aI5Zsjr8rKfzf94IeKzzOK//q3fI0iNaxwPeWfJZX+1TZjKK3aPXP+P91w95a6PimadD/GkfXTz0LOjsBev0soS0p3HsaVxVKp54RuLX36x4eDrhscvw0jWDNz/QiNpjziYRG8ML5Mopk3iRNEkIkimSrGMezfmXcos/9NwK36ec8I+nEsq3A+5sVFwq2xxfcjF3p9wyJZ5eafJN38NPAu7v27xweZOgNSfaLnn/dkz/aYULjQ0e7o0JHt7HvXWCo02R10J2Zhb7Zw4XNxo8elxw584Zt5sK/7s/1eOFay2+eVvhH3x1yn/wyQVazWXycYm2EvFTP/E4f+HnXuHt109rI0B/OOCZa8ucxhYHbx6TNBd4bxjzA1c1Hpzl/OqthIP9hCuXEp7/ZBcpM7l1ErETxKhWm2sXXPpGlwcPdA5DH9vSWSiPWWkrzBuLHD9MkacV2qURaz2JpGrwyplCeAaLbYNHVw9wSpWvxhrxNxPUJ24wMGWeWHT4jeMYb1QiqTZPPVLw4nofp30KgrFQWPzgsy26aISziMr+ADm2ofRx6HKixFx2Axpyk8Cz62dmt3NSa0JX4z7ZPCRBPHd2KU4zJFclCira3QaWWtZVBC20WW5qNJSYvcsnTMt+DSlcXW7RLxps76a8H8940tZ40M/xnSnZ5Sbzr3bRdz5gvKCzNQx4Xm3y3M0naK28zOTVp1EbMCckzhfRojucWCGLhMyjIdPJKWezjIeKSUtroLcsTFdmtTLxHI2ZdchH33+b7T/5X7LyMYXOxy6j/q022eac6QvrZGOb0C04axpcfewqHwyb/P6lJQ5u2Lz7r7ZoLIeUxSGjTCdtPmA1u0Sepei6QZqlKKpGkRfUBwJFRpGVGp4oblinloeZ6PXZylAtJElGU1SCIiBzM3qyitLS0JVVcjKCNEaNFKZHFa9tT/jOe2+jzyQyvUVyIefFJ2J+3yM5ev8nmUculZQhVSq21ibLfYwg46DYputauO3we7dMcKUDjk/P8I9lpKDH6EQj6pWoZcQkXkOt9nlszaTfcYjDKVOlhVe6KH5JofRx8SnmEkZVIusxo7QJccqlBYnlhlxH4qdqxTiKSD2VONPwQ4WJL9GsjlhdXsBwHiezZki+iT7sEHgeZTWntXCB9mIHJ9Zxg4r3/ZAfXuiwpKyQu7tEs4QwS7C9HGTh7FSIqqCOjaiyTVOzMKyC0jLpjSdIZYZvNMkyAdYYMfXnBImJdHSMHJ+gXbuMrfSxjBZPbbZ4ZMnl/mSfXx+l3Axk1vIctdVhx0s4qGSKOOeYJmY8wrJDHlYf/v1felxGX7Y4LTJC/4Rbo4TOqcqFroGlu+SyixxWVEZBWoRUSkqhyaQLAqQnFh0TKsuhKvvohXjhiQ/GMRkWpD2SvCATakxPcAIqZN2g2TKQK7eOzYz8gI7SRLUyJCOlYyh1tWQ6GtO9lpHOS6b3OqDtogfropSBIt2n8hIk7QrzRKKVjjFWHYyGTRiHVN4usaYgdzI6QYHSaLLaaqBqKWmZYDhdCj2ogZEpBjPJpMwmpMEpitzF1QY1N6KTtesPW73okSRhXY2xqkYNwJTzBqal1mwENe2SiTeB0Bi6YlkyrGM/ApYoCYuBpfFwMmMcyailxP6ZS/bBd3j3YMbo/gSzcLh04SbLiwYn/pjDrQPi7BSjstBilbyakwoGhKpiZOL7PkCXEzpyTCYpJKFNnCRIqWjMpFgYlOoBpVGhqiqKL5PkHjRWSIqEyhHJBg1NHxOYV9HSAxylQZAVpEmFJqukqU8SGDTVBpJqiYUtim9QSAGy6DEpiyS6wr4B3cxCP9OQnQ+/Jj/z2EpUBqZWby59b0pVSShWh448oNeWeBhlxEXCQk8kdFRGcY++1cJoT1HSR5kyxlA2aegekwAWxRdwPudzPv/WkMXzRcL5nM/5/G6YLg0qUQ0e36U6XsA7ActWccOUxSWZlzZM/l9bGS96OY8MdE5vw8nGIZc7MpcmLT54GPD1L9/FKG+w1FsglQ1WHKgcgTZvsFJEmFLAKJcZrmq8oGT8s2/JLG1JPHK5j2y4/Nq7Ju7Q5lGlwVOLE979IGErVklvF3z/zRY/HzqMwyO+/ip89vkVnui4PFAKdN8l7/S5EIW8JVLU04CLTsz3LbR4dVIwSjPeOT1lM1LIU9hJPEo5xrYWWIx6HKheffg1vWUSbOzPKFz9+Cr+1wL+/jt3+eiFS/wX/94mSichcHp8dnXEr+6E/L2X3+OHnuhSFTpxI+fpCxl/8ZPP8J/c/jqfaEY8viDx2w0d/X6O1+lzrXebZ1YvceiG3HGPmB6usLQOj+odyjTklVHI4ZHEmupycxl02kz9HDSD3FhmaUVnWcvYLzPmpw5eLLGymfPJvsNES9k/FZe7BcMFgydXSrbHm4SFR3K6QqX6fHJxn9JoMBo5DPZN9roa1z+h8anGgKbtMD+NmS3nfGrRoeXkvPzzEdFnPRr08EYSRaqStTw2XAPl7SaTKwVuWqEkU6zQJrV1JmpKbkl4WUo8PYQkZzpr0iwdjHLEaehRGA0UU8afK0wll065gBebTKpj7ETBalmsrJfIuzpHmorTSHlUtlAOG/y/j4vaFPInPuMQVRp3zyJiI8LYvcCRmpHf22ZjrUM3BD/qsdSzMCaLHHol1nSInM9oqAbrps+er3KYt5BFslfOUC4OOS6Wud54lu97WPDqqyfsqS7XYpf2gzEnssm3b0n0LlygkEyaEzBkj5YdcGe1zU89lZMWS4ysh1yKFoiKEEtr1O8vVVUo8rJOhwt+gi7J5HlesxtkRUETqQPEBXITCWFUEZXqHKWUsVSbOItIqwBT0PS0Y1zOePfI4vV3Q+Z3AqrEZq7oNDsmn3tiicefiYlbAooqmGkTUnHZr1W0TYuz6HVy+1GcOCTvWMyT4+/dMuH2mzPU5jKFf4beHeNTYeYXmBfHhGFFe8nm4sKAxEu4dSwhWyF97SIeIbqcY+U2cS5jNnMWuxqWADGmgtoPGRKeOHg5TdYoGMcekqKwtmZQHo+wjB5JM0cz9rH1DcLsiPA4qg/XgWFweTmm4/SQexrtYI7aylgw27Q7DlpUUio5C06HSTypNRtqXNXxbRGFV1oltiZ4AjGHqUuuadiLLrGXk7qq8Cvg+SVZkEFDRekeUWgedtJAZcBgaGOZTdaaa/z7nYxb3inbc1jwU2xN4Xh8SiRH9Zv6Ykfj6QuPsDOcsOu5dDpdLjYvseW+QhDLhFtn+GqT/XGOF2VUUUilK+RjnTwxoatg6CFKrKBpKYq1AJGCkU5Qeiq606Pp9ZgnU2bzI+RYEsstVFlCsyTICqpJRSHFFE6O3WygKilq1cEohNZmjOo0kauC2TxEzg18Z46SLaIaYypZBmlIdylFSlO88Smu2qRVJfXhtzAFuEAm8XMakkmKitnMUC0RkRPQywK1KdFxJEbRlFzKMcsWcW6TJSlRGeDvtiiyE25u5FwcrNJotDAUDaWQUEqJxJcpuiWSF9Uci1QZUYZDqBJyPUcNnRpCEglrgmwR5FPu7ri4nkuz0WR+dkIwzyjPZAbOGpeuXeXSows02xJLRxGVa7HvxWT5GDUz0GQDI9SQJLEMySgllUpuoIotaTpCl4N6cZFXJaX4O0Yi6iRhRAZF8z5S2sNuDSnCI2Tx9xgbxGqGJmkoxxNYOCNWGhh5hyTzkWjW9Fa52CWyLJjMSZZlzHaCnFnEUYxcTojlAjtbJogcEmOM0pRY7LfppQHHsU9haCyaDUy5ZBoGBG8E2Jdhs7lEN1TxUpWkNa9rMq1ERm2nhJlgbKQo1biGP6bLfWQvJJPWv7unkPM5n98D8z+Vr3A+53M+5/O/9DkjYKFhw3HBcVByPH/I9L05/w0tXvxizouPP83N6Qnf/PkTnmorqC2boauTORnWZsGCq/DeW+IycZ/Pv9Sg5fTIco9mryKJHfyxjOOolIpE6jo8d1lncpjwnZ+dY1YVa+sJz6+G/NZRk7ky42I74+rVBd45C0i9Ccl8xpcurPPOdszrwRDjTsALV5ooRyHFbYdj1eWGPeTTlxJ+7f2C109NXrxo8bg54+ikYGsunrdMNpZ8nn0+x7joMIoUTFmrb4QVycBriyRzmy9tbvLnnl/m5w9G/J3XXZ4eSEyiklvzKV8cdli63uRHWn3+k3jM/+O/3uWPXcnQf/A624+0efQ5j+++YH3hAAEAAElEQVR75ykGH7zJzwUpw2/EfNBe4PnhiAuLK3xzkiO5Ie7JRQaLc66uJVSpzJffzplpCQNF5/plcem2zO1sTDqZsd5K2BhqTNIRR8cV01Gb2PG4uh5zcUnn/UDm4I6MX9os2iZX+jNmE4X7oY6RqbTLAx5/Tmc2XYLjknc9jfVuwZ/5WJ/hcIAlSeyfHnFxeZPLS+LSEP7uz2V8/8eOeKSzSCuLGDMls0uur1xm+ok5jkiehxbRZIzWlNCyDmZg0+6UeM0TFG9GZcV4RoEdRfTkJv28S+K0oZgQhgW7s2kNto8nc4aZj94csNsxGc9SOknKc5qJ7rpYgx6l/oCvHnWxkwdc+ewjXO9s8EbwkD1X48HpKU9+X5fu3h5Bc51D5ZQlyyZruLiiruzqnKYuza5eJ3VneYVf2Ri5RyFMCApoTRV3JrHZbfBjf/gC46TJ0rZHPnf51a8f8a27Hr39kmnc56duKjTkiguRSy5pTA8SvL1t1E/FjEcvsBkLPb1YIAhdu1ynminFYU2qLQyqLJIKCUgVmrjMk8DM7Pr3o0MSf6hrDwoPTbw+NYtjJSBKUlZLByXuc/f9iNdu7eO7CaXaIFdKFp2Szz2xwI3HF8mKAGVeMRHMNFSO/SNWjQWKaUFz8TkiKakr3/HhHmZPcP6+R8uEw4cl1rU76D2Lhtwg90QtYMKD0w0e6cH6hoNrxaRnFYXXpMy2OZFPmWYKrdYSDVNHS0PySqUKO/SFrlGTUE0D2hqDWGyTKmI9IhWH5/aUoSHjtEwaus28StkPdJTAxJF6+FVEajRpicMb4k2/QxS1MUOTS02TB6Mp3b2CMwpWeh2GrSXagY0bC+jdDLlySCoZNdOwRBxeK9BkiXnpkoYF0RziIq1/yIGg/0syhiQxO04Z7YubdB+t3MG3fOZxxBPPf57PPfUkLy11idoht/f2+ODYx0gEpEbEtQ7pmhbSNY3h0GHQ01lYXCIrM6p8mePZFqpm4ufT+t+dpy6S0aNw58RxTpRGIJUY6nLd6eEkpYp91FYLu7uEhTAa5Bh4ZFHKXNyIpxqqoaGqFXrZJDPFB/mUXPzuREJzIXVkLPsMWl3i6YBSjemYKsVkSC74EonFknlMIC1xWEm0Zqes9Ic0zBlKv8t9NyVIjjCKPs28T8OpaMgyM88iLQI6aBiORqdnkpUOhQAP9kcoSUGpGNjtAFNVCdM2aQpSFOOpEe83ztgNz1g3uvQGCyx0JFCahH5KHCYsZoJ6Cko+QDfFP1tUEoSeU6J0YvTYIjI9Hpxus3WaIYtkRiZTNlWKKKVrWKw90uLGI0OUJYVcNeljsvrYOhP3lGAiAJcOaTVFVkoMWUbSExQ9Qa0s5DImtWKUvIEiulBiQVCmBHpOlgaUpoRhbJBmc6okoJibNIwekROhmzkEDrrmk5QDzNIAv0RZlOt/llSklB1R+zlDMRNy74DAM1HbOpqVIhUOstSoFS9FOUOxbAy5jTIEx7SwQ5VI1CaUkAYBx+GMKDE4mvooW1OoIipNKExV9FJGabmo+jKVnzGOZ3X6ozibky8kNJJVwsZ5MuF8zuffZs4TCedzPufzu2ludpbomh3yuztMtZRjy6C4sMziXszP/7UtnP9Q5Q9+9Bn+u9ff4LXjXS5G77FhrdK3OpzuxdyZy3zkI2t8+pMWRpuaASYuw7LjEjout4MEedTgo5s2eqeD1kp48ZE1Zo90ecvb5bPmgJubDgf+CVlqsh9ZXOiWNP0WYz3gtanFpZM515cdJrsx7217rDdKLjQWud8NOJ2UOGrOR1sLfP+lM766V/DydsgL6wpdDeb3VLR+zGdeWObKjRaxrzCf58RxwPaJQrvZ4I++1GGramOsHPNuGHFnYHLzosH4vkyj5/OJZy5iyS3iuODqUOWnn7T4zz4q8etfPuL7n95BvroCUsBPvnSNv7I153BnDzVWeXFFyO3WeLP0OXjo4qwpDJs2V1cCJoXCu2chbpmx1nJqC8TMa3M0HjN2Z8h2AU6Oo8BhqjHKQbJzbixLXFlSmYx1Tg5TQn3OhY7BqibKrwXvncTkZUH3os0XFzN29k3e9WXaJ6e41SJL/77Blc4CVaQxmh2ztrTO+soUd7LI37/v8oXPB9zsdfDHNou9fR7XFmjgsbamMN3x2M8iOuaUgQyFsYTdqAiNXQJRWQ5citgk81aRNB+FiDNJZloJTllFY7hEkbusWwqemWAXHVwjYHV1wrPVDe4dHjH3FL7TPWPVMGjIGknrCr3dhE8/V8IjBe8FY3a8kiuN+9xsrJKLpPuVPoezfbrxKuPiHkudZbKyJCnmrFQqM8WAEC7JAVXewNKaPLmZMqtkXDUlaz3kxOvwyvsRk0rBjxv02iFxw+XNWzEJIdc/u8pit0mhSHUy+rSMeX9PwVQs2s0WnlcgdgL7rTcZnNygYbbQFAfFLCmSijITSkdRIVdrhoGgMqZ5hlxf5pZ1JkGcc6hKbMUh1MYUVcJS0SJmzu7oiDd2XLbeG2McJbQkhSPJ5Oq6yXPPOVxabJFrCZ64VC6o2wIte0AuJ/hZjtOWCfOkXqIUUokUG6T295CZUDVMjHgNXffIDJ14aNCVM5Yzg+VOxmJDxUjHHLZs1pYlvOmQyFZwOjKLtoOlqowLSyQziOWkvmFNZJkqL1nxVFK5Yip6U66EF3rMYp0sy2n1HCwjI3E11jQwF0A1usz9BlqmIGUqbhzSWF2no4wY7MqcaSXFKCc25li6Ru6lBNoUx27gtAymmsbM88XugiwpmIslhxYRjCKiMEV1+qSaizdPMIuCnpPT7LZIlJJ5mpIGBbkbkwvDwKlH4mkcrEu0b8SkUsY8Dkhnp7SnEywpYic8Y7w945XEYNrdpau0WOrJ9M8WSJdOMfQKTU9IBaXB7xDbMY3qgCxaINZE795HNsy69574U2I5wC77mFWXPHDreo1hWKiKRGk1UXIV3SspkxIlE103mSqaIWuCmusgZQqV9iENVJkJsYJOQ0sYtvscjEJSoRUU22FJoWnP6UtLhOoJlm8Slwr702OWhkMarZx2clxbJSyzQyi7hGmIkbWY5jlF4VMWLXTBFagKpLIgihURaGOxNWdaglvldDsqrawJaoZa5ih6ho1GW4qZRWOmR3OmwZAVR6tBK1qp1AmIVM4I5QIjLdFFBKPQ8AsfMOhpJZGb8/bhKZOwwLI75LoPAmSSLjMvPsAKhmRlQEtIjrIS2da5dnOIn93g1jt7JKcH2HKGZNvkQrkSS0iBRKFlCF5KmqtUZo7csGrTiFIqGEmOUSzV7IoqFQ5Yh9LMUTdyijhBrmKkXCNXPbR2VMMc0WRKW6XKdHJFQjUalOFJTWyVdBVJ6VHFMfk8QNFNysRDUiOURhvkkjwOiHIXP7LoOg2aVoFclUxcsE1RqWh9uPQMfLw4I49sgtxHbbRotXTMqkHXLDloiLSDgqQUyMwoxw5az4XY+W6fQ87nfM7nfM7nfM7nd+gk6Zivt2VseRHf7WIPttk8CjiNStYViX/0zWN+6Atjvvijy/zjn8+5f+8YR84wjl1unRoMNyVe/IRK88oC40zD9mTalQDIVeI+kRubMW9uZ9zdznjqkRl5WjBY0Xnpczn/8FtNdu+PWF0zeOnJZb7y9oytezrqes5nLvV452Cf/Rh2T2d8/PIiV3sHHEg6r5wO+eJNk0efNzl4pcvD0yM2mmdcWBiwuBNzKCuMwzn9UOHGBZ0Xn13gket9soZFOo3w92PuvDvn7btnXH9qkc984iJrlcZ7B8voBwmfslLutE1e3k45khMuijNM5lLlCVK8ykf6LX76hyT+i7dSur9Q8fE1jfeF/nv4Ln/y9w34C1+Z8aOzjPefjrj1T3ZRrq6jpSWP2goMxhxvibOUTCKZrKzBc2sKqmFy52SGp8osD2w2mhJupvNgq1Nfag0bRX15t9KJmEwyHs6hGmY8YjZQZJ37ns9JYNLpZVx2NS4EMrdmGnf3oRyWxOsD/tc3dS6qi0R+zo5Wol1b4YVmyc+9v0JRRPzEswUb6iajPZeAe/TLFt8xfbwsZ/t+SCI0iEmDviosfzkrqSYoBRSlRqPqMXYzkplMWXZRC2r2mSdlGPOMee8Uy1rAmXVwhRtuGqOpI2biku1WE9N8D19dxpiuc189QBACvqNtc+Fkk9F4l+uXOpxOXe4j0ZNHfBAPCTKNlwqZG5pCv9fCHffw1YscjxKWJBXPMrm8scSV0ufWbs5ksYWlpJRyhiU7LJQq3qGHFk3w/Yhf+7WUwBaJ7JJK6VCONeJQJbcbrH60oOjoFKWMmVUouc7RQcLKss56/4T9ZJOsFN+LnjhZE8gJRVpiaSbq4JhiPMQqNNK0qJkJYpFQ5BmKphEZ99DzAQoO4k5ZJBfk1MEL51gKzOKct+4dcf+ORDZ38LQZkVpw9ZLBF1/UaLZlGqWDpImauKgXhZRpTJH7NMxu/XVN85A0LimKJlJ1gHOhT0NsHb5Xy4SYCfE05dIzK1xYXkMyR6hymyvtHLmnME5TSndAV4pAaPLiAc2hxIVukziN+GASISUlbdOjFPEO3aBlZzi2iKqXhIHHeOrhehmGlmMIimUaoYhOfKXUB0VZc4nOUlJVo98KMCydXO/QmemUXR1HaqM/0iHNi9rL6TgdpLxAqgw8cWgzFawiQZfAQaQNAg6DlCQY0ZIVJkGBl3joaYqaZrRENUA26sh4bksE3hw/KrBUk8oqUWWH9aHBiRxydH+L31xXuDQ0ub+7xbtvTVmVK96Kc27tj5ntjGrX69bbCX07xb1eMnV9LvsraJaOqcbImknaPUNydeK4i5oe1paGLI1RWg5KGpPnAoiySKHHJOEZuqFSVAK2IaG3jVp3oopKgAiuiCWIXZGmNrngeIibbLdE1StkKsIIclut/auC6xDpAXJqkVanFNYx+biJ3m9SihesYdHOc5KqZD7RQTZxrIh2v0+RydiqhSMgmX5GEQZ4uqi2gKaIN59JVOSQh/gjEBRJVbVQk5JiJmN0dCRdr/s/YlVWRC3CuIFjJah2jJrmBG6Td/xb9PT2hywM3aFyE/xyhK4ukTkxpjxASgtKUWMwHLxozt7DhExUQZyQsopQBC1WVqgOE/bvbNNpdXhOLKwaMpFc0a4cLi4tcrx7RjBVa7Bimlcf1hJyhyqSqQydSvJQBJwx6dTxpCJJKe0KvVWgZFJtR0iViDQZIN71AlqkKAWVneCFBQ0BJTUHGEOF4kAECDVsPaNKPeRKopKW6mUCUYlkKKSIdEAAmYGirFByglzMSEV1JXfQVJsyTzkrE0zbqXWrZ2EOpUO/VeHJKUleYs9HNFsmTaXDysKQrm1yRxgzxH/cQ5mxm2JWGnbDphLpIVLsMP1un0PO53zO53zO53zO53fo7E4P0Q/GpGYC9iK7nZSVRIdWwkF3RPLBgNd/q8dnH7f4/LMdPlBLtuWE+9cCFiWDrm8TjRsY83Z9mzw1Izw5Z0lRaptaU1L52FLJyUnJ9pZEe9hA6kpcv2byA7MWr319jFGcsvHsKp96dJlfemvM23cTImXKo0s9Tu+4uJ02r99PeeriIs9Vbn1Tf+t0h8fUAZ+6EvP1nQb37kVMs5xHrmSYJwFfe9/mRkfls88N2LigM5ZD8sOcdJQSqzNc30WZVVgUfLVImFQVH1FmmOmc77wDX92qWPyCxR/77DLbxwnhBwGrG03ivKSg4IUrA37qTxv8nb93l8V/sMXwMyFluUD3yoi//OIV/sU//TbeGwbRwMCYhzyzKk6Jy9wZ3WM6kckTjWeuWQz6Nmok8c5hhDfTWNAshiseuafycFdnat/n6TWbj7YXat7bJBLl7YphR6ahmpj5nHdcg0mq0dYsLhQawaLLq6MhUXBG1Yr4gQ3xXH+ZG0symRcT6jLm9R7fn7f4lVfGrNouN2746MUio1sHRH0FbfMqtmnQnkso6SZe9ID4voTeaJKsh1RmmxO1hDwhtQIqpyArcyoBO8+OKKWcMoCm08ZelpieCvB6gWIeougX8JUZaizkC5eZFafcFQyMwiXrTMi0GfuWzKJ/kf29Y4ywQ7DkkUYW84NjykcMjiY2tuTx5W+OuXjtIurmBZTijEY75jjMKCyHnkjO5wl5oWBqOvpxQab20ElE1hs3B7IehqXStFzCM5/iMEebyYRaiG5pzGcdrq2u8KVnVsG0KcMWI8Hm241I9nyW1wUWUVjfwNE6LM4qTN1CEWdRYcULMzqdgPEwgMNlKqGaRygjTaK4oioqrHyTqpDqRHspmHCl+MIkpKoiy0Pe2894//2cYjwjylJSp8XVp1b4wg2H9d6grlKLs3ESC0tehaU0KEQio/DoSgvoVot4PKcZNjm68TarZ4+gqw6eP/neLROMwGHeLPEjB2vJwlJWGWUqnUUR9ZYZh0pNvhdkf1csC1YTBm2HqJA4CXPyWYRaFiSVRKGaBGJZEFTIlYGklkyjjEmSk5YlqnjhFyBbCpmi1AmFTEsgCinUrL4pDZFJmiVxIjgMgh8qYHIlQWrTVGLSJCQrm1Co0Aog0qiCHDcq8JSUyqjIEgG2qFB0hdiP61v1qIQ0zlBTjcr0MB0LszAI/Qx3puLlLlIjRi0NqionzhTGszNGfsL7I5tHmh1Odh7US4/39DNu3ZoTpEJfGOFqWziny8QLEQdbcGCUnG4pKMs6SZGT+S5hKaElGYVqE8oR5UlC7lZImkeVVOJCHlOesmwYGFaLMIxIYqGHNFDzGYFbcrRfURQSZquHaqY1yDGf5TWVv1JLCs1GV8T3OSIPuxTyGKVvsXNmUBRjOnKTfDwki0YoRY/SCFFaNql3QrM9gNxEUU6w2ktE8pSjkUynWaHLHp5sENkGepxhmBYiIS9AhGqeEIaQKTKq4tUwRDsrSQuDedmgynzSTAAkVbRWTpHGzDzqA65u90ilgNAL8cWBW4F5fIpkOjTaCqWiIjZUJRmKqfDtk/sc7ekooxnzExcnKUjNZs2PqKY6hT3Faa7iRhk7HxywvtLk2mMGpiEzOQuY3D0i3D2qkwc6LQrXA6ElVbX6daNUBXmZk1c5auWD1BBcWpRpRWzJ5C0RshDfIwVZnuLkDkksEds+eAFyZFLqHbJ4jEqMbCygFz5VoVGRIZdNSvmwTqMomkKRiNejSZKMKcUHcKOs0yyqEdfgydgtyNIEPa0oRFTJMEnTCldUdmQJtdGk0VNIopBZaFNIFhsLy1xcsNktx0SnOeMyIik0lPIERW7QsG10zURSEuGp+G6fQ87nfM7nfM7nfM7nd+hYxoBZ0keLb9Fqv85mskqaHVFlXQa76f+Hvf8Ktm09zzOxZ+Q888o775NxAjJAggQIiZRAMUjqLllSu1tqX3TZfekL39i+dJVdrnKVq7t84XJZbrvlltXKiRZIUSKpJgmCIIAD4JyDk3dcceY58hj/P1zf2GpfuFwibUGJXB/q4ITaa6255hxzzP/7vvd9Xh6EF7z3W4/Idy/zxiTm+dcsvEnEnVduYn1C8f7fXvOdr3+bJp1z8txdLMftv28TVbg+NO2YxPbxjmvWsnRqoJKkvGHJ65/ISLPb/MP/ruA/GDTcvjPia68lfP0HsoB0eVeF3N5b8L1lw3tvGgytkFefP2L9bs73z2MenTf84qf3uDcr+Gjhk63m/Nhdgf4NGYxrfvLHTe7f8qh2mmLZUF9UxHHA575whHE/4vyvP6Z7oDh5a8mL9z3Uhc/v/sOOb3/X4aUvH/Dn/qNDXhveoFrMef/xR7JwppK48MJjMtZ87fNDEn2H/+v/5rv8pfenuF/cJx+Y/OTnh7z9z+/xty8e8mru8/oXIdOHXF09YSsW4vKQe3dhWBp4rebNTcvjPOh5EbfjHZeXNY9WLbnbcjA95CSOenifyPtVaxIbNoGhuWoMLi9cms2Sqevx8p5JsNcxXxgsVldE2ueVz5t85s5dHDOi8zRv3mj4s6N9wkrxN781506keOMT0BR7PF5fkuxNGN3z8MIJTnbKxbtn1Pl7rKuErlHsH19x6M5opPcpU/xLuXYmjMKWgfSKXslWt2RWTppq2MzRhy6Be4BZ1TSqROc5kQrQXcjOfErnbkkPb5Maj5k9vs3YDrgXTLC6msVNOBk3PNi07OYm3dTsLQ2x6hg457xjD+jONuxNFG4FEzzuD+TxC+0s5eFpimEFlHpIUz/BzFecWgMsr0Bc1n4Q4WqHXI8I/aBP50hvXNAtarJm0C9Ek9sex4nPzB7TWAGGbfPRxmDpWfzcdMvj3UsEptPDDgMjRHUCUFQEXkJRpOzWAYw2OLbk0dl0MiwwvV6h0BlaKO9Ypklr5tR1hWMKy8MkdBNcy2F/siCKTU53Q0bHBp+/FfHc6z7uALQ2MQ2Pbb2i0x2OJaBGzcJaEW9s3s3f4sb6BRZ+ziSxmWxvYxkOWbni3R8YP7phQnJsknVhnybw3sWWV2dDngv38V3FVl9gGCmea3OZLel0xO3JDdyg4eFqTpVmBHVN6UiU6IAkbCnbCsvx8c0OJzf7BirwFENz1/s4LEPhBTGtZxKQYhpBLwW3i5LOhNoF3djseRrf77hVjnjU7ThfdLxxN+JmMiBrS2rxoosC3pVOUqQauvczOUr+taOrtXAJ2RgWjSRwiKrB8+giF6MY4PoN2ipZLh3W25rKKsVngd161Drj4iJjtWkYfPI2n7tzxFl2xm+9k3ErCrCF7V/VVEUCVU5rZ71XvR0YIgno6akyEarPS0wi0rrpByxtl6OdkMpSlNsUNfOwOhlerPu0ANsKUTpG9sVaScNrobyGUtso38Gc7cjTjE5ZWJv+nvxMFiM+HplKtSUqW4G5TyPpFgaIcKPeVHimxW7eMOxVBx2+09Kohs1WgoYDJs6A6WBJY3cUmYZ0H7I5W50zSnw26Q5DtwwCH8+I+8dQuIrY1Yx0RAXUusTxK2xrQNnEKKMlCToyQjamQytqhlLiIvewvRWtQHCCiGiwh1ZbsvSMqzKiWdTMaovU1Uy2Ie5+RRQF3DYCfuf9p5SPtphThyao8RtRdXRo2wa5qYQrrEr3Hypvv3fOrb2I1VXDf/e77/PRtz8mLTPGtxyCcECThrRZitVW4NVoP2EyO2E80mSbHU9PL9kS4eUGzrmAH4IeVGpND/oBhE2H9jt0Z2O4SQ/TMacZTWVgbkYIzcbbK1DbfSxvS9atmBgSTzlCmSuarqUwFbYMjIyKpizBkKhJB9NOiKYCCE37Dy/xoW3WHa4vN6OQPE0xy5I9d8AgGNISYnWazsh5uDpnmVkEJFxu5rhu0V9LXmQwmTm4iY1RmlT+H/g2cV3XdV3X9Ye6/j/hmtd8jOv6o1Bh4fPgxbe58R2HrL7JJngPzBdZ+mu8zQBr6nLDtvjw6gm2Uvzcc5/j559/meDI5Gxyxu4TGfPfWvDmP3qTx7OnDG5MOXn+CO/2HoancdyGqvJxIoej4w6j2iHiyrbKMeKEL3zS4Gpzm//2mx/wHx/b3JrEvLhn8vhjg7ODlK9NLF4dB3wr1rybV+ytcl6/4aOsjIdPQ375oy1fvjfl6ak0qkt+5R04PI74S2/4vHBnhGoC2nWOJQ3boqZwLJzhDf7ETYdBFvGd/8fHnH9PVKouv/YrJe98GPLSnxrxP/nLM24dz9C1TZ1afP89+AuO2Tdiu8KkiHKcYMpXPjtk85df5b/5G4/4S58vcZRPPfT4C//hC/zy39/y6rZkedrwQ1bUHzhwZ8Ib8YgjL+O9bYP1xEB5BsdRwb5TcrkLeNya7HyL56cur5wEbOyKD1YNRTpg5jXsBRmnG4MPLyyMquNw2HBnfIA72vF75xuqyynBMOKzJxGvv9xRjwu6Kxvf8/jxw2PcbcD/8f05Xx67vP5CQls3bDYa69DFHofY1ojh/EPc3d/jjc0BSewQjWpyawRJRhg2EtJOVfjsrAucVuFUhzht1KfmaasgP3Vp8hHmnYwqENVCThPWGKdDJoliXMjmPeGsqjGbO5iXNZ4ymB8/ZO+9u6xDeHU0Yb1bkp1c4KxnZNkDSqdlmDm053PU6Ij21UvaRcn5vOYkO+J8mvLCcMC8Stk+sjCjHW4WoW5o9gYu2ZMQ6zxFKdnwm3h7S/xBSPZhQ1opMkvUwB5WHGLtfPZGITFzdh/tEU4qzimIk4JtpzD3G774fEXZik2kfgZZFHCCFse2hWoalGqJAs1cm4w6g4oVjpFQ6AKtm17FIEOAjBLLcnCll5TokVb3Sg9lKA6PC24+b2LtTD57Z8KLr4h9vMZWIYbViYYBW9LuqgobRa63jIoxuC17uqUOtzRKY5gd4aOK99qn6Mombovf9/7wB+4S7r5x2MswPvXSlMW6Yb1YQVByrG9Rmy2LjWJYt3TNhKNAYHMuqfZIlMaMJYpOZEPS1Vq4vo0Rmv0ExTGW5J1JK5EimBRVgNGuUbZL1JaMBw5BbJHZEbU2sS9V38RL1CFBhOkKt7HjtLuk2sGN0OPHbx8zcSf8/UdPMT64Yth6OIcljVxY5QbHlfhKiTe0seTrM5HFCHBC9dLyru7YlCmubNRVgHJKak+YBmm/3a/toP8d/MpnXa/YxANe++Qx+47JX/mNh3zweEFwN8ZwNDos+r2uE0o8ijTHJt7Ex7Vc3I2PbfgEScl8baJ2Noxa9JUABa96z00VbjG7E8ErYkYOhhnimqM+BiSvtljNkGFgg9mCO2LSGQQHUIwH1GuRSNWYVoK2KrbrBaaSwU3b2ydUe0WQjGnyhuXc7OX5ppFQtQaFZ5PER9AqLhYVnjWmSQtKc469V1GWEUWRQZuijC27wsHWPtkyZTw1CJJhDwppChOrk/GyCYmNpzta5fdDBbPWWEaOIEU6URd4FW6paCWRwbIYih/F82m7GiMdMhn5/eY9F7m/mYJXUGYuq7okrQNyY8Wt5jmiJINs10/xZOKo3AGNHdJsVwjzx+kkx1HeQE/odjaPP3rE39i+z/LplosPNz2fY3g74fYL+ySTEQ/eP2eZZxjaR9chRhRy5+iYezdD5qlcJzHzp2uW7YZlWhG6AcJkjQKFrxyqSGNv1rjS/OsTiBWekG+tAju8Q1c+wEhtrABC9zZemBOkA+yoozKGNFmH0aWYnUAnXaxW0iV8jMaj8xWmIxPLlq4ycFNFp0xUM8Rpa5TfUXUVq/kGfzYgMTt80T+Y8HTuUOuUJGmxghbXNKmbhMLK2bYOR2HZyw9Xm2ubw3Vd13Vd179suHA9VLiuP8ylQ4NX6iNUUPcJZQf5lFBl1Mclk8sEN20Y33e4U03ZnLe8GzfcOjEZtiO6oUv86QnfObd59M13efL0imPb5PiNGR0O62qJZ2XETUxuaNykZuQLHK6B1mRl+oxGii+9usc7Hyz5td+54o/f2fDZe7fJnJTT7RXvfuTziRcdPv2JBd/dDfmnbz/lP/ziLb5wQ9hiO04zk/XmnE/fs/ilN2c9j+2zn/T5zAsDqAKWixJbbK20XKY1TmmiO4upk/Dlz7/Imw9KfuWXHnP47S0PDvf41P/8Dv/Jqz53bu5RyrZYTqb1igenT1jvxhz4AY2KyesCW2WEicvP/syYIi15/28/5JiI4uYRey9W/Gd/5ja/8nc/YPkdTf6ix/CWyYs3CtYXLe/ObS6nYDxY88UXRuR7O64WNh9/ZGLg8Yn7PndmLZs65fyJ7s+p+8OcgVXweAUfXOg+hezOJOD5OwF5bvO9H1Ystgmj/ZBPfdbis0OfyPL65ZF2TA4OxwTnJv+7D0756RsD7hwrzNplfbWGe0NmwxuyV2Pw4QN8fgXsJZ+/ueXm/SGRmXGar4n9SX/ud2obr5XFXMjAt1k4Z6RtiNd5qM0G1Q36JD8ByOt5jUlKILx5b0Djd2yjErNb0WU2eb7gaBFg3b1Nt7uiihrm7hlpPeT9M83Y1M/s1ssIVXdUJzWDwwFt1vJjjWJ5dED5FFZdiXN1iQpd0q5kY+2zF2nqXU5YyffwqMYSg1qz3DqsTM0nth37gdOnJlTlFdUwoRp7hDsDV2s6v+HyvORXP1hxY2ZyElnkj3Z890HLL7y2Y3JvxIOrvIf6C8Os9cBrfZTqKKsM27IYJJrgbEbdZNjS69kBSqnepi5/7+3rptkPBMR+nqtVn7LXcU6rTAbGHl+8a7EdpMSR0cdrupZcgzkbKlyxzXcKu1N4bYNnxdRiX7dqDAkZcCqGTUuLS2btePiRTTl/yiwwf3TDhJdeOaZUIrXJebhUTKNTjOIYs1nTli6r9RzXDKgmM3J2fLx+jGt4z7wusoi3/D7OrtgtwPKIBxJBaFG0ilWTY5k+g9ImUw21Y1MaHVWVMs4PsBOfYSgQkgylHJp2CLbFYNJh6o5Ah6ziGq23vSLheHDAhpbOmjPXCvKGZNVhWQZd2xB5Jp0u0a1LE+cos6XdyYLe7Bt2y+hoxFKhLdaljZ3L9rYWMQGFDjGUpA4UPYRxoxTDozE/eRhxdfGAH7zdEGUdZxc5ddyy7QICM6eqMyztYN5QnIQl3sDiiRFgVTMae4OiQbebXr1g2BZ1KbKvkk67tO0GggRTSZxljG8VzyT9lttvmXWbYmUWfuT1F1rkh+xNfeqg42qzpVrktLlN0/nyU3r1ha33cbyMxpTRmIs2W7yJXOQZXtORVjVBmmMbeziuQtlb9LLrgZkiR2tLhY1wAhbopeoprK2pcQOLUsljLdFuROtAZPtEYUDrVZjVjmbZ0Fg+YeD2F6Apf8hU+KFJKU21aTD0O9A7itIjicW7n5EVFoZtYg5PiMVm4DnUu6teJdHsdrxtpMy7kgfzS7YqI5kktK0N7RWGc0ina4y266VMypKbVkA3jHuewdUHc/JNjj+dMXvlkDt3Djh5foZyYbyD7LKiWGeYkWY/CQmHCeZswt4wZFE1fbzL+MQhvWpYSPTi2qWoa/x8jRNHGEFArXcEZoDbq2Q8AsvEnZrkmcba3MfQa8zkAo8jOquhDTz0usbUDo4MZNKW1ncxPY12HLSO0Tx77zhC9G11L68znJrIrTDrjMrOMeQmqSzUwsKfOgxHY3YpnF42/XTTcnV/0ymKAWELy6ziTJ+xN5ixrHzycvWveg65ruu6ruv6977+ZZGf10OF6/rDXNoomTVjTlc1sfkhZbfHyul6VejeUcTmwZwr5THc3zLeNLz9vTNWtcPPGjNuvzqivFOQPN8w+tjH9QccnRziTUJqv6YqNXKq9bqWrZCaTNnemjgRDI0BXb1kWw9xRxZf/fIhv/QtSZi74vhLLl+8GfKDBxaPui03c5uTQ4sHncdcaX7wg5b7z1V89m7Ct97d8J23huxNXO7v2Xz6UzEvHSuKQlGcp2zFVyuyZ21w69BlPQ0QZ7nomQfRjFd+5i7feCsj/2HJf/7nZrzxlRscu9ITCMxcoNUtlmrJHm349n/r8dmv7UhuR7Qid281ReEz2fP4+V9o+S8/vGLzX2dMv/yAqz875AtHJov7Lv/Vr8IbH2uOv5Cxq2dccI6xdbi1ZxLNYgplM78MOHvUUCuXl28pbo9XnFcB842wATKORzmd4XKVGlwWZQ9sfG7qcmSbXCw8figJcW3EzZfHfPGmx3PHI3xNv3zbS0aM7yx4kyV/8xvwn71iM5tZ+A9L8stzutctZtMx1kVOtP014s0VjD+k2lj89g8O0aOS/DRgNKqxLUUaaoLKw/ENdN8R+wR1TN5bABRNbtIYJU5QokqTpuwoWgtvb0SrL3HXId7RhNx5gr847FMqmqFJmxtUes1xcovqic93gu9wvhozVy4vOI/pQo31/BX2xZBLuyb2DzDGHjdCn7XOuTyD5XrMpWlyfDxhPNDYsYtzx6WrM9raojH36KaKW3GOJQqBsqZaF/2S1xrvY9gxodaE0brvY5s5nK8jPrxQ/Ph+y9SJePCkwdxmfO6Tt0jdoFci2K6LZTv9EEHGQbJ1tRwD3w/pui1+NabSCs8OsWQVbcpMRoYKAn5vMTqNErK+EN1sj1ZrfH3QswmLPO0t7P7wgKqr2alL0SJgtwahNeiv097i4HrkrUKJ2toRsoemcTrMXdXHTFpuyzkl9bnNW3OT/fziRzdMiIOSUHLul11P2b8RPs+RPyTvOkRof9M7YehKhIT4OEzeWfu4ZsF+k5IpSDu5jkyc1sI0Wgp9hspDyjzgSd3hew1Rl9JpTeImKF2zqzcsttte4n3QTBg5I7JAEeyZPT3fH5gEpvjVNa8nHkULVtrwf3/wAfdyk+NcuALgmR1ab9i0mpEbMd+se/WBLd7zRsCONo7TMRepSVYSdTmG0bHNara7BYlYB/whlkT46TOqukRmItvtFc2tQ/7YT36Wge/zV7/zmFJSHCKbwvGZeCW3byesm5r2o5a6LsmLGDMdUyQFrhD1g4SiTakrG1yJBvSpuh1t41PpANMXeOKcVjdY6ZhmoMhIsSTasXMIbAvHNulMxbYsaIKIxHBlLAIBuEogfg3FJkPnKbpq6AgxBhJn6OCedzSRCzsfIoPpXZeR0TE/dcmyDjvNmL0wplinFLZBapqoTYYdRkzCMXVlkQ9qHi8KzEb36QC16TEvW6ysIHZMkkFMEnmkZYFdtJiVxog8/DhGtQXalmYWAm2hOgvPE8ilQS6JEGVFE0Y9z0DLrT10GYokrjapujWduoVm0ys3MC4o9IrH38vZdI9gNcXdP+wlbVZxJV022q8pK8HHVs++pi0w7ZLZ9IjpJ/cIb86IpwmJJ7GQBjk1w/0xm3BDsc5xQpNBJNEtO7JsxtDtcF0b2xswdkIGCSRpS3plcpVK4sOc9WVDIjm1foGlS1q5ngzhgjhU7Q5PBgXjDUE2wO5EAWPS+Tld5dHVJTrYYpZe/5yJCqETBY1ZE40lFki4BhbKNjBLAWU6mCGEw5q2GkAmE9+SshCpXUJkOwSJy9lpQy1Snp3Z+7ZCr6R0fNok69+/u9zm4cpjahZsfblxXdd1Xdd1XdfvV9dDhev6w3pd75YZF/ef4NUG1QOb6u6OwzRkOzrDdWYoL6O79HAnHdOd4sN3H/GtxY5x/SruSUjqHGMfa8ZGQD2yWJXndJZEeYsV2GRn7UDbDByx8ApDLMQaLRmaLqXesSsdbpyM+LzV8eibZ3SnHzMaj3j5YMwPmwkfv5sye97mCwfwjjXk3ScVdgp3Ri0vH1b8k++2qDshP/3JghNZRp2bFCKrz4UPXmE7HoNDn+RWQLODiw+v2NOa4/0bfOl4H+dPvYr56Zwf+6yok33yqupj221H0RnCsKrZrjp+6e+lNFdbvvY/O8QaJDStNNM5GxVwcJTwi3/+Dv/l//oJN9+5Yu/ViM2hwVc/M+XbX16RLGxW3lM+/viETo05THbMJL5w2PHDhxWp3TIxTV68VzOOJ2yqllXZoATy7Ydsi47Lq5KloQgHDvfGFgdJy9k5fPBeizVq+IlPDHn13gFHsfj3NZelwyu3EwajmEbZ7Fman73TcW8A9aMla+3iv9ASHOzjLzrsj36ZKPhNvOGMTRnyV/9azK++6xIOt73cPxuMyJuSSm8ouhbXCvu+4KpWFEsfO7YhadlUJtlaMaoNJI6gMWO0b2EVCiNUWFaI2RSE3ZCqcjFmNenaxa23xLGH4VzhLfZ46ATEocPuyVPKl99gOH0PqxrT1QHl+RPc5wyy6YCTRcXKb4ldk13n8sHDj8nam9jDjuM6JPItlBtSN5qiO2U8qjkyIypt8/5FypPFM3W3W+7h1iF6siZtHFQYc/+TJ7z26g2u7sH7+x/2r8U3ghGGWMktlzofYDklpmXj2i5FWWA5Xt+/dlaAPzrjUmIgtSiR3X6IJdaHTGCfBL1txrJsjGcxDhTSu5gmhbdAlwLab1mS41YWXrFBha2MEXDMEM91eot7rVtsA0TjUOoCixbH8kTv0KdHlFhkTYqxhqdnYx6lD/CeZkx+ZvajGyasH68ZxRZu2zEIOy6UR7wxscIVj1UDucPHxZZEtxz7PkFpsNqIxNpmKPFzTs3EU709QNkVDVVPjB9EMLooqEsTlQToXrIR0BUGeS+v3pFtHVS+YjQq8WcOg+EAV0eY2uvVBLWzRNsdsXXIxeIxfNRylg4YuB6OKT9zQJpU7GmJ+1jz9Ey875qjbozTuuSRxko0R1pR1w6bNMKPHcZBQFvKXXRJrSRf5Rm1f1d06EXbN9u3P32Tn3v5mCJ9xNmpIgp32CMT24iIxxauzijPRZZ+Qt3Nsa8aTqMz1OUJo0oooSX5TtEUFZZy0blJpa/I25iuXWK5Nr4jcYA+LVU/tTPaEMducJWNacU9hBC5YNHUbc4ic9iUFl0LZepiVBGeq+gCC8/uqK0QnEt0GoHjoblEByO0aVPrCWvRdcQt/uEB20VJnK3ZXClqeT6FyGusGM48fFNSM4QMofFUjVM4tH7CKBYApKbrbDxfo72CVovNRNQmIcqqeruDpxtaTyaRLSp3emVLMjOFANHDJu0gxpMox3ZLF+yB3+GUshmSmIiWKI/YGS252THwFYFjsbtyeZquMIohZdqxc5Y4aodtlnTGDBWUmKWFZZZo34DS7y0uRA4v3T3h+VdvYPkOq63wFHLqVdMzP2pyDMshiiyCqKHKFbk8Nyce03BEbtjkxYbOc0hGJtP9iKPTjqujjtVVxmJn0+Zboq7oGRyBvUdXP48V7ei2MjzIcG7uY3ZTIj+iqYe0bdmrYES1IaBQQ4eoPO9ZI1ryeH2X0TSmzRVFalGbJv6eDB0itBtiCt+jLp49l8pHC1Oj0GRXz3xgkVn3dqOdQEpbn9HYolMTXIn42V3y8DJgNitRYqO4ruu6ruv6I1z/MlXCv+zPX9sfrusPQ1XDgHgFQzsksoec3l9iLH2Mzuz5Y5M9p1fDNo8t3PWUme9jHOQ8nT/iW99V3MpPsPKWzG2IKgO1rJg/LKmGFRM5m04MTtUT4sU+fmOBven5a6bZEbkRgtieFjZp3vJjN6b8sHiZ33rrHT575nL0xpKv8jK/M085SxfcMOH1vVHPvnrrsc38Y5tX7/tMXwj4wmdnvHqrxFxEfPeDFaFdEFjCB/OZHIzxEqFcmcQo1m+t+E7eUQ5j7nk+X/rMEUUpas+SdVZQ1hL3XffycXmcwnozjJI0c/lH30w5+b2Mz30tRTPr7adNnbFxAz792oi/+Jd9/uqvvcOf+Mdbbv7ciOPbA/7TX9znv/j1h0TfHuMkH+LYE24fwVXpc7qoWbUet2cdrxzZTCyPD9qCq4XGa+EoLsmVyccbj21psx+bvHL4bPv/3lnH1a7CiyLeuDPiS6/sMfB8tFK9H//uzQkkOX/7zYq7QcsXX4fDvSnqgydsAh/zVkw59TlJXaL3vo5t/XbPqkt/aPO/eMfiwbczivGCveOAV1/6BKfpho+3CrV0MZsdyvHYhZq2W7Pxdz0wPghsnIkiyew+7r0za1p720fbm7J09cWq4FNudniJQzstGNY3KNQlw3hEZQeSV0ppwa7ZoT+GmxuXzS2NGyv2kwEfPRE5edJv22svY5NHXO1VTMKWKN6wmgfEucOxr9B+xZPZHLdJ8DJNqyvURUiKj5oIKLHGaDS5WLWdnFo7lJuCpkl4bvACf/pnX+Urn7tP6bV03oLbIjowE76bXVF+/22yL8Y4liNpjn25joMpAQNK4TjSI69YmXYPU/csD89xaZsGu7V72Ltp2P1wQSD8Zmc++16iTmgCmnJHp2oCLQMHky4ucYRH2Hk4lY9udZ9IGDsDqmZDWW0JnLgfTthNSykCdekHwx114/Bg/ogffhxwVQVMXi85+Znxj26Y8Ohxi3GwpUgb1k5GIfLyKuT5E93nhH60OOXi3GEYdFyMnlLXHs3WJ5iE2E5LYHY0YjkQmKPpEjtjIsegqyT0LqFQdb9FN2x5enbUqqP1TexcsjodWvG7VDnjXUgSaZRZ4BWaxk4pmgkXpxt8t4a1Zlz77KqU5eoKLx6T7tvM9sYkymJ7rntQSrLnMxwO+q1sleVMRwbHk2M8kQKtKtJ2za4uyDKDaheSbwvKoiKvrV6SFYcle1GA1xR864e/zfsfn1JcZByPHVTUIxGpW4PVbsn8SlHkbh/xomuH3SrELHJ2ZsC23GGLkkA8NDqnbqze+97kKbafoQIfX0c0jvR7FaY1xHUmOGoNVssu39E6DolnECqhfLasnQYtgEqxSmwsjPIZ6b8WO0PcYtQNbe3jILL5DtUJxT+iqHcYCzASl6P7Q27dGJI/DLh4ckVlmgz6Jl5cKm6vjGiTHC9wsHxF5wuQ0RHMY08Ctd0xuqtpxcJQm706Y5F6VFaLbZvIRVOZAgRxaO2KTW0R2A6+SHu0Q2VKVGZH5/roQhIQarxQ7h0WuYJBKFaFFifaYCUddiZAzxnvXzztQSxRPgW/pqlWvSyo8IVhYWA3NmZn0/kxSqXYaYPZxWw2Kz56esHRyZSDiYMtEqBGkZ7vOH33jOViiedbDKYh7shDVx2btCBugt6GYSUN2bmcHEXt0NHZDc4e7LlHHMwq5tuQq2VJ8XFOJSkQ6y2mKw6omraZ4Y2HhIOQvHLwDItWZeDWaDuCQmJV5Q7UIFgWAaeYtYGXOUxn4EQyTQ4oJqADk6pWZE3VKy7ssEJ7Lnlo0jU7VkvILAO7j8PR/XusFgvMaIRl10gKZJh0VIu2l3utlM048v8VjiDXdV3XdV1/dOt6qHBdfxjKjYBcM537OP4toudTZhcBmWVBM+xjEMdVRHnQUJQ23bjludDnQlLLii3d04aiGVIpA9eQqDtItx2d3qI9Ie6PyOeKb775LqVyePU1m3v3oWol5SrGtSTu3MHQHaWleePuhMXmPt/4VsmfTy0+d2PCg8s1HzwY8O7YYJho7g9rfmcZ851HDbw25edevsOLtzR+PaBzPI7GEctVjum4HBwKNDCkyGuaIkM1LZ6TcnHe8jtve+jb+9ycRFShzbaw+yhu3+hwHAtDVK9a9r0dkbYptEc9TbCGDhujwRZ7cSdy85KyNbGikD/21QFvBku+8b/dcXhrwfntfe48F/DFyuY3vnXAc3sNRmWxURGnRdef3e6dOLxyw2LoO1xVPmm7QVkK3xnRNDVXeUHempyM4BNHMuiB99eQlwF7ds2tzwz4yRcOe/X0qiypAp8XjkBbV/yN9y1ej32Obq1ZWTOy7z1guD/EvxOjEpvh+iHDizmW8XtYAq3//gn/y1/v+K3LM+7s3SK+OeQTn7jBwX2bJxdpf47fPfIIfVPQaxRqg7WLMUODyinRc4OoHhLOLMqypC3bviEWMKFw3oysJB41VKGPV47p3CWTdoH2pyi/ZZRFDLwx57OW+EOP1bxkO7rF0F1hewf4umQQN+wJjH98hXth87ga0p1nNH5OEOzjnxQ4EndvO2gro8thUymKecV5dkZ9EXPhjBhbNmHnMOghiC1uKOqBimZX40g62mDMT9w74NbkkJkHNQd4QgM5MHn3po3/5u+IzqBPXzMl7VDiUCVaXlItLAethFJgYiwnGLIwtk0MSfazHGKGlGIbF3ZcHxdp9H93bY+mqrFzsYT7vT3drETJLKgAA6N1UGVLZawwxWoukHiBWfqDHkHQifZBO6hK7NEZXlcLVYGtpVm877N575JX3rjJ9Msp2b73oxsmLJYFg8gi0gaDJiJSRu9BX2wiYkcziGzcQcWqMblM4XKXMuhsbhkVu7YiFcl41zGNHZKhcAAMFqI8KE3qwqSWV1H5WLaF4VckVoJld1RBjWsbdLGFlgi+1kQVFYudZpko7lhgrAZkixzXbdisTVxPNFI7jNLnYs/hdXvANJmRUPJoGWO7GTMz7D37beWhPItB7DAajXDdjsFIkVYBT1aPeatcUVQSHWKjBg1B6JFUmsQPSZIE00z54TuXLJfgik3C6ig3LYM9m1tM+KDMKRZzVD4ntibM4o4wkGHHmgyXTkCKOsQWT71TUG831GnTb5+9UUjnBqhSWvQltm0Rei1uUGDuyt4ir0qD5TZjF7rEbtDLrVQglgoZeoiK/1n0SN0zGcQPpmiMltZyaawM3zHx7Qm2qeiaIaNJyO3nZsQ3wW9d2rDCVRHEFqGdURk7XEPTrBQ728UTqYy5w/N9qp1DVy4o1IShfMD4orhwKVYNZZ2JswDDVARdRt1FYAfEdkcnC/RaYDdGTxKNAofEt9nKFM5ue9mTLHmqtqX2jR6M2WmR3m9wnBijG/QJEHVRsqkrhqLzl6lHV5J4ctO3MWKZkIJb+n0UUVVlsN1gEPVARatOefzeR7zthahbU9ZacXq64vKDC5aPVqjGIrkfMJxaWJ1DK8OgYk56PmN/T+wdNtu1iSnKg7ajWeQUAxMzg4HpcDj1mExv8aS5YL4uKZwKdyODMxdn5hGHwz76pzM2GLZ4zGwaJaTWFrOTTF4XO3Sxrbi/IQjCsTX8nnmQhAGlaxJ1No1RsNGbPmayclzMgYMrP6Mt2azFCxbTpXkva9oUHXYjdGKNua5QIjXzllixTbR3AzspuDRMDoVyel3XdV3XdV3/f9f1UOG6/n2ug3DEo9mG8dwk7ZZU85Sj2YzqqcnG21KsDPzWIznWWFMbJxY1ss9gYrEpbJqtpFCtmCUGo2HQL02yhcF2nWHbkt6WcLkUha3N84dTJqYoku1ePbygYFztmK/H6GSDZ+xxZni8/PwB3zlb87tnW16azfmxO1NUavJ+XjJJc16+n+MUB3jPGdy5N+ITNx0KNWd5pXE6ODhxGIxO8L2OwHJZrnPKTGDsooo2sKYeia5487c+ovmw5md+9qS35RpdhyeLMUM4Y66sium0JSQzXLdleNPj5usRhzcibLPtoY7y3Ah4T8hleWUzi1z+4henfP0nNb/6jSVffmFLczvkay8cEP9szjvfW3CZt2weSLLXpgfbv7hnoC3Fh2uBvzdMvIbDgcnqcs5Hp4p0MuTWnuJ5WfgqsUUYbNaaF24HfPbWHvGxRRm2XGVwNNLcnNSsmgH/8IMNnxn4fOXOAHfgcFYH/EZU858+n7B2QoZP32ZS/SqhJTB9eOdbMX/z9xJ+++FTXj06onjDZBZH3Bjtcbm64kwGRM6QWhTAMjWqXfK1h52WGEMPK9ewliWknPtloWmhbRerjnDGCr1p6CYJwXhBODf6xLehQPNnPnQJ6alIZOZk5yXO0REjsZIcFth3NEExZF2u6AyT2zOXzJMFm4X9dIl90BCVUzorh3pENN2wUznrzma0M0iUz9NWcXVpUy0HdLOKwTgnNgYscNFJw77v09Uujy/LHrzoGlsePP2Y/8s/mPHVr034c5+K8Xm2gNPUnDUFd5oOq6n7mEeBUspngbDhtKHxLYesrcn1Me1alGzS3Hd9ip5j2f01Y4mquNO9kkD1qYTy56xePSFf2ydE2FDUKXrd4AQDrFhGWxpd1n3/2rY5YiKw/aT/ubYhigeorAbVSsKegBldmJcsPgoonrbMjzqsQ5NQ7/8IoyGDjsLoGIUhbdGQm4o9o2GpMqLI4Nb+kN1A428doqDF2yywSxdfi4xC04Uet+MxezOzT0bYXOWs1gVVaeF0PnteQigb0MAm8D3CyGPrWazqjMRxUV6Hakxsy6cNLG7pQ8ITn5uOxZWqeLoQw0OL7fjURt03acF0j8l9v5fP2Ja0020/9IgnLlWTs83tXvUQOSHhyMZ2GlpRR5gWth8yCKfseS27qMRL6NkEJjVx0/X+ck/eFLtOVOicHBg8civWly67XU48DZgFJW+VNtoyCCOD8ZFHeBSjihWdLfL9mibMUVcuOBL/0aLaHQ0DvGSItmvcqobOxdAeulY9LKNrJGZQbAyaZODTpLAtO7ZNTpg02NqgWcrGWfIxpK/2e5Bg3VkEhk+YVLLCJs86/GiAHg65m6h+aOEeDrh3L2Ltb1g9bOnaGiNQjO8lmJlHdX5KmxoYbkUQuewqidb0ehm96T3jH6RtitPUz2RdjcdO72h7oq1Ie0IM8STJXEylGJ5JIioKS1PaHmlaEiibYBRh1zWuVmiZBorqQvn4vlxPTX/TloGE1YjNQt5sIevymbRnOJlSOStUpnE8iVuse1uLTgsabZDlJW1a4hoJWm4MrUyOTdo056O332f54CGi/J/Pl2Tzkq6xCYcR09GQWGnKXUdRWrSdIt3UDCYeUSyqio4ma+kcB9c1yMu2lyVtLRPfsbCtBHtY4q49lP0xXXiAFxQEzpDOKfrHZbt+T3sVWmu1nvevn2fOMBOb2BGHkwxTPDqBebpOn21rSzqK26HLCkOAp84AqzOfqVFMsXRYJAI7dRuU72EWitRqWVsl0bzDjkJITYyJQ+DBamdhCFh0LN+r4qr4/03ee13XdV3X9UfV3vAH/X7X9ofr+vepuo0imdZoy6fT4H84w7sdEI9yxjrCDTUGa3wrwPNb3M7j6tzHPHhCOBqitzZ16+BaNcPIoKlEcVyyWZlUWARBzdj1OXi+5NZRw+JqyAdPNty5r6glAawIKDY1jlKMpjUfYzFROX/ic3N++E7Cr30n46df3/FTn7rHrz044+GbC5qnMXduwNc+c4MXhwH1qqLWPiqrqCQBa+QznILdBqznFel2C52cv6Q1Mnp1qHmlyR42LMwMVYjkXgwXXg9q16JsLjWGLOi6itY0eOG1fT7z80d4bkP+ZsbNO7Czx4KEx+gsHKvDlu23nXIjSfizf87jf/yPNTe+vublP+kT33D48mcnfLPcY/E7TzAWNvdecjgIXZb1ms08ZujX7NGRyIlQxWwrk7XVcWtocRTbPF45zK8a8qbmzr2IH39xzMHMRdWi1m05jANujjQXS4N/tqj48bHPj93KeedhxSUun73vc/8TY4KgQD/YEq1/lXDyMfXqmP/VP/HYfqvh++EZt8K4Tz276jqiA0XWznn7oytObbkeGqKZJt/q3qJdq5qiFGZASBc0+LpGBQJgNODC65PqgqDB0QrbtUhEwFxAV7U0/pYkGmAZAbvFmqFVMAgCitDCEoXFuMNRY5LylF0wJZUoe78jGQasgh3dDwyeOgZ7mxyzDvDuN3hV2UMKC1v+WRIPLDrPQhUujmswC8Yov8Y1LeqsJTMKgtAiihKWi4x2I31DiLPe8aQ8Z/H4N1i571K8eBPD/xI/SDec/OabLN5a8j2/5hNZRjwb9Of32qnxGk+04dStJO4ZdGZK1wSyccWSXtMwKJoU1/HppesyEFDNM3WCPGeiLJBhltH1QEdT1OHSH69jWln2x1UP8xfgowwVKl30Sgczz2m8jsgRNXoKjklWaBJRiRgZ3UOHy6OU4vvSLyYcHt7ltiyHf1TDBHc2whpYZI5FJSvetOBpYZI4DXU3xW5qdsKe9E28mcXxMKZOFdlHOeWuYP+Wy/7AIxbVtrLpvBZzFHGRNTSqxLaHsqfHrCFqQ2y/wolbJrXLwI/6SYpM4mzXZBB4nIw9hocjQmVxunhAdCgTwR17+h5pmdKUPvEADmY+p5cFRbrE7AbcCG2epAbdtqXocnKxWmw0QxLiWOY38sJJ824SW0NuTTWVv0EbNbvSps/Ui1PqpiLPS6xmQBD5mH7DXuf3MZWJvIg1vJetCM2AO3ePseyMw7szzGbIk6LqJU+qqamiMba1oROJjynk/iHakmSEHLPJaMoK3w9wbJ/WkWbRQOkCU9m4pksYmL3Mqc0MmtbsvTUybjIaC6sq0K5s9w2Grig+LFrHZTQKGRszLvNTOmvKdBxz46bibJnTyuQLRbq2e2aDE7UMjyPCQ03+xEWZLmtpoEcNY/EQhRGWYeFnFa1V0nVDlCgMZMCsIrrGIVAOkiMjkEXEtqBEtvSM3loFNoOxhSFKubyj3XRsdg2mU6NdsUG42F3QT35lkkehaY0aiwQ/tqk3JoUzx58P2FQ+sbAFkoSdxKmM1zhCXq0UeZdTCszRE9BI3Q9ttDOiyjPsrsEMxfPmUC62PLqswXFArAaGgelZJCPFeGj1+a5NpVFN1xN6y0JT1gaBa/cesCoPsdqsj7rsBx1ORO6VdLnHzsgo5MZh+v2bVE8OcbqnWFubHJFnLDDMF4kSjaoy2hwiN8Ebg+5KrHbby8VqwyPqjB5kWVdBHw/pyLDADHtVjyuRm5j4bksp4y+xdTRm/1jqAaiNTboVpUqOYwXUncIyWjK7IdnZPHgsAxTNrX24deix3F2nOVzXdV3Xdf3rGlJcDxau69/1Wj+MOHbfp5w+zypvGdcRrmHizxS3yoRVc0GxNVlzyIFXMnR83r0sCRqTiSPnQZ/atDFtIcpLsprqif5p63H52GFvf8fhcwYfLmu+/0/nbB9fUslW9LOH/ImoYqmO8c0ccpfKNXl5YJL6I16ZaHxl8td//Yz1d+HkJx2+ah3wv/8opTWH/AefP+TuLYdmbSBp5hJ3bYshoevIr2pav5fGkqcCSDOwJSVNosrRPD3LeXhpc/CJMV94fcAwcBHNgvzV1bK+1BSyQZaENKNgOLT4zJ+c8cbnTT56x+CX//kT7vyUIoo9tn6CpZ+lYohpuGkVnudw/NyAv/inM779XxUYv1Fw9/Owf+TzuS+MWD7NuX2m2Pcslr7JduEzG9rciGrSzOFRKT76Bj1IeH5WMwsyLuc+Ty/l3Oxx90bDFz8ZcXswom5LTMPjZDakDlrevDJJsoIvHyte2h/wdz5SzN+64hOf9rDcIZ8V0P+Tf8qgnOOzospf5r/+Wyl/5+OIV9oF4XiPF44iwhM4bB2KquG7ac6TbM1IFmdmw84eYUlOx26NOPy1Lc9bjRVFtKGkyDWYsUe7sWmanMBSGMsRxr5YAjbodIDp7HorfDdQWKsMFgM4rLGNIeFIzsiKqy5kOAyoPgbz+Zr65prs4w0Xt2fozZzxcsyjexXWrmVgbPFLiRj0qIYxw42o4mGuc/x1QjM0GLkG3cSmjhRZqmhbi5Mk6BXsmSULToUaJawXa2onJbRjyu2CH/4/32L54IBz630uqit+7MEpya193r95wPNtTR1fYDoHuI3b26gFkJhVO8JpRmttMcXigaQ92D0PQRbbvRpBCTDe7FPj5H/y31qJuDcMbO316mVrsiPxXbKdRVNusQrpXUR5L0H1JnYrgxoZoFxBe0RR56z1hrHj9+r/tCr54W7JWZXwY685PHV9fvoXH3EwvMPpHwCb9gceJjy3d5NmtMUtZCBgYEQtT1cmB5ZNldo8Xqwwg6CXzuetxzCIye01c3vJ0ycFTaSZTux+S250AaE5JJ5NGY9zLtYbmo0m3UqcoEPmdoQyNRyC7zhYEndnWcIKZDA2uTHYw7FDcpHLlymysB+Mps8UDa5LovcoywbRmJcrg3wpuMeS41CafY9ttWBrVwy6ksixqVYtV082RNMxh6O9HtzoGZpK5CaugycvnPhcbIPtZtffhEaeRVlpMkp2hUGh3H74sT8z8KsBT85tnqYRt6cjmhhWxo770R5NZfHEDjBT8bs8JixvUPkLjJ2Pijq62O4ZB4ZEV3YRnSEbfLtPhuhs2aK3hKaB4xmYspW2vD7Ww+0qutpGGwFNLTIsF1sAHvL1UcRo6DJ2Wy6NjtlEfs8RSWozTz32fYH65wwFcuMYbPMSd+thWRa5MWJ6rGkrRWjYzBIBCULQBowlLSJWLDqPMCiYby2izsPvxD7SYTgy2eqwhU/g6l4eJbARJfTAzhY2IDujJAiGWHZEkWcYTYPkYpYSKTnxMZDGtsKw7H6gkukSz/D7N7/83lpiFkuTC52TnlU9hNDsNAE+5iDuoyBFhVKlJpWwDEgwunM6U9PkGzqZLNsenjxnZtqDYGyZbPShLRadbWMHJqOJhx0OqKlRXYkhvqmuoqxN0tImClyiyGexExGERukBtpNi16KmESii3cNu1FojbgLHmNG5MTr3Wfc3TZvEmPZ2n2VXogSa2Pl42CSOovY7tHIwM7u3jmgdoIqG9dUWzwiwXRnqdL06QkCbEg0kYUW6NKhriZKR7FyTgeOyFiXGrugjJ92DARi7XnLosyPPPdorr/doPf1YUV8ZWPG1MuG6ruu6/ujVj1qV8Pv9nOuhwnX9u1rS3HSbiCBISU0LY2bQ6JxRIBDwMUZW8P3LM+Iwp7a9fuPpVZp4Nyaahj1sOyoqwjBgGE9YdZtnuzmvpTYaNtWAQ7fDHvgsTxs++N1TkvsJ335nyo9/RjyyHXUEE7Nml4dMBzajWz6nqxE3Zzu+8nrLB7+5I1o85SiY8TOvHbI3nnB8x6bJNUVW0JqyODFxHTk3ixq3pahsLDnrYxBI/JucmbuG9y8rFuuA2/cTXn8j4d5+jGGJ2tagbjVW0/bnKsei7xGo7Z65lpxkdI3BR6cO3316wfFvjfm5ry56VS6dg0fVy/ob1fb22dYx+MVb+wR/3OTrf/+cwTdK4p8w+cq9kODL93nnny9Y1E/Z2B6Hg5Bbw4pCOHXnOY8rE9s3eH5WMYsLHq1MPl647Pmal244PH9zn7uJR9coAi9icOD1w5RvP9KMbc0n7lh0ic9feW/N/E3Fn/pcwivPzzjtco7fPSOMf6eXx+fnn+Kv/ZMd/6dval553efu7ZjqtsXtac6D5ZS8+BCnGvHUW9GEirp5QrE+ZJtZ2KKlH5gYysGobdoyI2412ohoMmnkG0pL0SlZzmp8UbgMFKkBUS7L3Q0qB2cty1zVJzrM4jFVbjA3zpkYh1ilS+iU2Cf7eNkUxprzumTzMGNSFnSzMU4TsZDo+T3FYe2jrJJQRyjhOJYhrmei1nZ/Vt8b1KSO6m0JsVWi7IBALNJigbHWJG5Lsy+qcI1zNMAxU54+qijXcP5LWzbb32Jgm1zdtAkPlqS7u7y1fcx6ccJNf81ReMIuOSXcHdI0DYm/4qFyyeoSa6Mx9kQlbOMLLF8UMr0OQT9L6TO6Xqig+9hShXQ1WVoShR7DOCa7U7G4VIznNcOJLGb9fpCkRAxvmeSVibE1KJwFjiMxmxn20uTi0mB52MGnPD4zNIhfO2by6ffwd/BDJ/7RDRMmE6O/6F3TwWZGKT4hRxHbHsvFjmWlOQzAji1i22fcBjhNwXAQcBlo8l3NxeUarYYESYdvRvhd01NUI2J2InkRbKFl4vgdnaUwDZfSlA1qy8gOmEYx3lBzNLrRy/yX+RW77YZRYCKQ/yoYgZ3TGFNiZ8O6tfsoQi80SCyfq8W85wbIZC8Jx/1NIPILaVc5P18StZLjueqtGx4uqpQNf4uWhlKgdbpkLVL5tmMW+zhhzV5ksEutPlrSm/rMwhidlmzLHIwh9wZTnuot843D5cWaTFXPGm1jjTJK3N2OdAjNVUQl3hcz75tw28lphRHRpy1UyH3IaSUmMmMQ7BEOS5SvMSvxa43pjC1WJ1Irv2cpNOLHcQTwRx9DIkyDQNgWuMRxyHQvYDJwcTZbVOczUD7x1MVOHBYbabx93NYhLR30ei5OMAZ+yWTW9naPbKUpbJNAm9hOjWHFEAqYUmT5LXkn3IOOiUB7TIdU+1RlLUId8G3wOqx13U+Ks52kxOjev28bCleuj5GDH7h0chcpDFolzbXd+/nNXO7eNZ3cGLwKO/N44BVcrXdYdkngpyRHklAwI3NadjLEKFzCkUO5070EyOpsWjPDJqaUqV5r0hmSISs0Abe/NqxOclw7xtOA8SjplSOVqBK0iyVJEKqlajO2ecR0vE8SVpjGuldjOBJlKbE6y7wfYChzi84rtMRF1lvsyOX2nSNCSt7dfkT2RKCiU6aDhsJQLAyrvwFIPKazs/DdCisaowKLthJrh7yyDUXR0TYOtlX1QCD8EN93sB2LTgYO/8I6o32nh1n6MoWJDdI4QDkmpi83y5TQU+i8Y6UlcmeE3RSYVz5X64y7z43+1U4h13Vd13Vd1/X71vVQ4br+XS0zumQ9n7F8bsUN+4jTrKTNKsb5hOFLBdw84Hs/zMger1lNXPaCCdNIhgoNeDY7OXPVmiRISIIhqdh1DbHqZoyirl+QVTuTOyMf42WPqycN1bIk+51Tfu2Gw5fiC/yugCbCdjZ8dz7iMydLArFpNiFffWPI1334h99Y8otHK7764j7eXkOba9qFZNOLL18TmxGdEu7UM4q+pUX1amIZtkhAafpBQsuucfjky0PeeClmKBYBrWibjLZx6TqNaRbY8nVuheDzqsZBZzZXP1ixfZrywUOH29GGv/+PRIWa8zOvbPD9mF07Zmw3GK3Rfz/DsPHtgK++PmW7grd+/SHJBw339yb81Ksdp48rvvfQ5bZSTBKPi1yWt/D4qmKUxBwMbAKVc7W02Czh0Kl47bmAV29EhL5HXkAYaEb7Jtu64Lc+VNzzA754V7HMXf7219dE5Zo/88k9XvnEmLr0WG3n+OWaO90nWHznMf9gqfkv/t6a5l7Bi8f7JEd7JHek0cjJLj0eaIu7OxN/0HJs+jy5sFg4LSdeAxODKpzgzp+dV1e5TSZ2A6fBsDWdsNGE7daTBnwCV2wt9DDL1tXouY89XrPzhySpj310gZXfw3BLjLTj9EwzfG5B80RxdPOIUL5X+xzLEOpdxv7whNNxTfDQp/EKOs/u1fVDLap6k6XSbM5h8qKkSBhoWfjdrbGVSbEwGSUBcWDy/kcbzp9uiIcNwX7H3GxxEqfvpTIzI1YeIpyxDmvGmyGENvXAYhNtSLeKb/5gzY2zQ1bjFYOvhFhJTrtSrJMdd8017eUhv/fuluIHO37q532iIOoHBqYSEKNLyQpLeo/+7C+rThle+ZTFpldYs0gYuSNevOcxSnZcbM7YlVcMhIdXGeROSy1L9tbrFUWln2LYFdtHAx580LFuLI5+uqOaVlztPCxT8eHyiPUqJS5deONHNEyYF+fYGxdnsMbThtAH8OOcxqlIMpejcYztaBw0u6ymaw1MFWC3MTemSqgjFEqRZsIvsHrSfFW3qK5mW0Dmwn4UEocurvTHVk0QBn0CQVPYYGpi4RhYMY1QMoOmb3YrY0xgV2J6IoljmmbBtunwGtnee5hRzm09pdId5xcP0Koh8Pa45U2I9sbgbFlZC/Y6zVTsBFbGh/Mz5suOkQ44kEgSx6TWijzNEYqgEDSflgbDQ4+XZmMSW/bnK1wd9v6prTT1w479JGR/6JKuA6xNw7tXT6g3GZ2XYBkVKtjvLwKthDtQUKxbzKjF8Bs6kfhncg+e4hoigYl7iZSnROJi4LouZiBxNgaJ3XIl3pnuGSFXmkvTrRCYgmzgPdPD6obstI8bSFRkwXZTEXoG+2OPoo0Y7CDzO4IkIJAoHFp2S5Nie8bmScZw38EfKKKx36scHqLYbCzCgYvndviuxotLassj6FwGnk1kWJiJIt1VbDcWrREx8J2e5toYOaXwN2sX19K48jhtzU6UDHHM/mzce4ayXBI7DDzPxY4KwtZFi/VAQBWupqslQgj2tebp2GVoJziSgBBaFGVDvtj015xl+fhxQ1VvcOuEuguwvRajFbXKnK6T6YFDIyyERtGqtk+T8EyTiR8SxF5vixFliSQ2WF5HI+PhUlOud+T7M/bHIdGqYPc4IzTFe+c/m3IbCnO3pZlbmHLjbFu8Ozf5xZ98mcwZMbr0ePf3FrTZiCRpmTUdbrBh17o0V0u2rUW5KBimA8LIJZ7Y+FHNrpKIDwc3dHBteshpKoOTqsQTD5ttk3hiwdKYloCHXJrmDE9glKKAURb2riYZ+kwGCdvaJxNwjauxXYjtinAv7iGW13Vd13Vd1/Vvpq6HCtf171pNBwOulmfUasSqFYWBQfPE4P3LDe0owz8ccfflAz7+fsp5veWmXzE4cKgav1/AOK6FO3RwI4nEswm6kL2oxUxENWnTmCYfnc8ZZ1P2jkfc/+SAB9/suHh7xTf3htz5vM3tUcBy6RMkBYmuOX9cM5l4GL4ktLl87fCQ849CfuPNU/7kwYY6djCbAbqt8L2wtzcoJRGOJqb1L2Tjuu2Xv6YF63nBVW70dt8ff3nEq/dj7EDi+lT/dT36TtfYWs5UglcwyDpFXcnSBoq14lv/dEExyAlOPO4eD3lyfsk//Gcuugn4xS9A0yb99t4zbKquQrWSbCaMKpuf/Yl9PtKXnH6vhG/UnPxkxU98xuasPmR4uuX0rOFRVfVwweOpxfGeZtgqHi4N5nbMjYHiEwcmJydDHNti2zZ4UchkGnBZar79dMtBGPKZ2y4/uGr5p29dMq0Vf/61fcxPjlDvZbj173EQ2LxXW/zSNxIG/9zk7+61tPccvvi8yY3bh6gwxyld3loH+NsFw2lMvS1JMofYc3qFuNZXxLdLbGvE+mqIFa77c7FKbda7hsxOiSOX0EjwJXGuMgg9mzYp0WqMUe/Q45RgMcDQT+jMBN81MAqPj7ZXROaA2jZwtylVKMB4Rb7TaHuOb99j3BrcOrEIb4F/PmC5uGLvpQ5rUnGxcynXFt2ohMsAe5lj1CbDWKJHMxZVTZJFlKuKp63FfWUQas04Cblz28MdWVjnG3ZNSWrWpGWILY9dQPduRjOK4N6a8ZN9FibUFxuMRcR8foZ9K+JTqmCWv0BaFpijlNLJ0UvFR49rgipF6cNecSCJIthiydE4hkXjtFidmJgFBC/XsaYTa7dbMS8czHXOCR7DvZhi6rOZSxKKjXaEmiCpD21vGTesFSLGKaqOxdbm1FrjvmbQ3XM5tGoeC/9uqVg9yvnwBy73ji9+3/vDH7hLaNc5q8pjpDWGbGCjiEAr0loR+SEnoWazythuah5vGybOFtcP2eQmVmgRy6a589CNQZZJI1ihrRZT0hMSs5+UjGOHSGBytoPlWkTOCE951FZHyq5nAwhg7nF5hTNrOQrHlJVDvbXI9AW6MPFrk8DasVVw4EojGpCmLQUVsRthKpPlLicLzvnExCfxhnRJza2py+pyRbrOyVcp1dZg3VVYjYFhS4xKx0ZVuK5JrAzmmVAyhbhvyOUDtUPeVH18R2VkDD2/H04wkOYQDkMh0oa9PF70/bI1bh2xEqwxtpKxukaZ4nERxsFYoAnUlDi5xok9bKMj9NNe3mJYFQ5B/7t4TodrdpilwvIFxGFiCXgv6ygbC+2GtLZI8Ru6acyNfQtnp3mw2HKyP+BkHGOWDuu0w2qlmbZJxg12vuODwsDPGkzPF44pxaJh6M6IBh7jouT8aUsVdMQyuYuWzLdLNs0+08QlMsRy0fSpG+urDaqx8ZKYwDN7cm/eQCmb8a7uxTu4IWFkY26sXq0QCgDHqinWBq4FQexgxQXu2qW2SwQx0AaK1vMJaoMZDi/eMYi9AZvU5eHHG0w/o1lmffRm/8ZMBeZiYLs2rZbBS4CSDxEzRqsUU7kow+sTJCQKQ9QvQTAgECuFaVKnbg+1dEQR1ye0iHrGos4r0l3GwdGIyV7Jdpn2sjpj2dCZBkaeYlZe/7NV3aFHLi+/8hyfemnGOT7J4ZD98JzySgZeF5SrmpFEJQ3kg6qlrBqynfGMq6FrkrjtBwKtDAisto+YcUIfs1OoqqIS+qthkIpyoaGHd0o8j2u3bB0HowqJjTWlGfSJH47SUEn0ksLQMYXycNyO6aTCncXkot26ruu6ruu6ruu6rj+SFXkR65HiXhbxqMg5HLv9+fadJ2u896RNTzm64YP2KGdDWtNm1+SMwxOG/oCJRJablfRGZE1GpXeMBrpX3xat39t522bO5WmOMYs5fDVg3zT54IGJ84Md3+x8Nj/tsac1+cbi+Lai2nQ8PnU4nsq5OeKe5/I/+tMt/+d6xqN3HnFrdE88pQRejGnbfXyjRPE5QtSvZTigsBz575qzJzW6sZjtO9y/E3L7RoTpBz343GwbtKZf5HWmQsn5Tws/TpO1bq8y2O3mnD55yodnZc8xePGOYukec3g75erxB3z97zuMXoQ/5vi0xhjTVdh1QkeDfEOBik9GNr/w1X3eWq358DsbmFncfcPkK58K+cGy4YfvrAmMkvu3XfZnPlcK3rtS7BrwnzN44e4+L4QBRQ5V0zI7tgkOAz4q4cOLiucnJp+/YfPOwy3/4K2ae0ceP//JGGNkoD9c4b77EenRmrfWBV//W4ofrB/yQmmx0gO+9qccbnkJ2R0H/VHJk03LO1bB3TbnhnYppyZG3rDeedRlznTVUd8MsVsTp87YOiVtLSkFCkMi3DoP1/fxbZOy8vuIxsZVSNDbQA1Y1SmBsWN8MOWqDhhvYqrZFYV4oLsL1AbUOMaZmvjLGRw9YmuIQmGAeu6cIG+pnwuZxituzSwWI0ncGNGqJYHnMTdawtzu7cRhXGBt3V75G0ce9droLRV7ts16s+NCEv2sGS/dDjm8KywDgyPX51GyY55WmFvFrhhiNWVvp26GBWZlUyYRxUVLsdwS3bKozRTPtGiXHstRg905zOwVu2a/t3/fnJS88NKUIHT6BLv/3vpWNw22HYIlygKDVqt/YX8QG7v8v4NdGuSbFT94Z4OfBAy9tl8+llpTuQV264Fn4HQ1tZ6jyxFd6eDrls+9YqB+WmD9ku4WM/NTHjiyBHUYfxRS7AlP5Ec0TAhHPsVKiPHSmIUYlpAhbQZqSOkW/ZvMM0wiK2FPPObmmtoUdYFLocLeny3rzm2l8XsPvPjOLRI/Zjxw6QQe2HRUbsPIlylmQN1K82Tg+SFhEbPONuzqhqrwyLsts0FAJl4Q02BXrnlvu+WzzgmZv6GSXM7GYlkH5PMrxpIL6llUKiCWLb6q2K7n1IVLLRMerdguF+zmNZ3W7EVef9PJ5KJvJA+0FQc6vsAqTJ9Si/+8QZk7MiXARmlyO/Zbj7a76lUEIjFfO5q82Qn7FVOXNLaHlk15V6HLOZUd0gnOReCNQvN0HbTEcwgMxs5JG/Hxj4kajeHJjfcZNbasg155kHcGlYjXW49D3yVMPDJV86TKyUr6KM1CImsGsJ+4jMYDTM9lkrVMA7/3iLVa0wTy+xrkRUEQNTiGSew3sH+jn8a6xpJ6E1M2Nq2/I3S9PrpTCVBQG328iUmErjzq2qCxSyxLQJhDjDYgCAUIKDfhlDLzyFKJSGlwHU0heb5NxV7oko181llJUVQU1o6savqtuaU0KnNRrTAHJJLHxlINlkQ/9tt/j5OBiedBU1tczhc9yLAzLRzXYbtaY7Z7NLZCiWKjE0tJ0MvaTOFOqKr3lRlm21tsVJtjtVGviOgs3Q8RqkzTVcJ7EEBjhx3I8y7SN026zNgMEiahz9XIpRYFQt3AWGHswp6TUGVXpDrFf+6Qn37hkEZgNMpnP9pj9sKQcn/Fr2wy1nrR32htVzMcJ4RFhic046YjVTWnlxV1M8V0SkpLUjqMPnXB7mEtXm/B8CUBRWRcTY0uHaxWlDsm2hyxs/SzwUOeY7iKrGlYrpfYZofrK3YlPfR0FI5ZlCmnF7//jeS6ruu6rusPU/2b4iX8QR7DNUvhuv5tV15vIAwxlWbQivp0hH1zyI1CM0WRz00W5o7jgxjPjqhXARvTwjt6tnFuKgM/HGLisdtkmLZErSdgGpQbTZMV+FXH+oni3cuc6U+ZfOlrM2bfjXnzu+d89xsXnO+l/NTQYjwqmC/HzCbQZgXvLzo+N8kovAOOb7j8x39uxF/5xxvsdzNu37CxDqU501RWgWvJ4KL7f0vFZS7w9kWDyh0++YLJ868IjD1G9X2CnH5l5CDkRLE2CMDNoc//UjVaVJ+dwW5Z8nvf+oA3f+sUPWppxzO2TUtuGwSBw2HssHqy4r/5u4pP/fEh+4OO0iyJTDn/l5jKou7tFppPDyeMvuLw1zZnXP2gJRloXrjhUX5qyDeXKXfXEQdmyrJxeO/MZUPLK0cOb9wd8MLJFDuV2PSG6WiP23sWta84rTUvHWheSQJ++V3F6YNzvnA/4quffgFlPKU5fwv/yY73tMHbZwm//u4Tnnyj5qWXQrxPTvnC4ZjPvTDiSZbzcPsE59zgLBTm3I7dxGbiWvjjIan9FM5FVV2gTYWXTWiDLU6wpVm7zC81lTIxnACnsmHTUTu73pbdTiRaMyHMOnAusEXBu3R6nkI9qLiab6iKLU05IDk3WPkaO3XIb1WYZxnZQYbKO4Z23FuSt5bBelFy5I+YxPQDorkO8dYZk2EMJxaG09DNoIpkUmTQFho17EjnFrWxYziI8dYNl/YGywrZrgs+/P4K3465N50QTxJ2SUPuVfBApCkZzTaj0S3+akp6Z95z4HZrm+pkyYvxpFcvPPlwhH3rI15yXuth9qvLG3TdkqNhzPGtIzxP1Dy6f29ICfhdzvdO51K3FYq2778t0+4h7UWV4QUtblWxfLKlCgzmkpphyXDEwKnAFVGCI4psHyVw/2XL1dOWbLvl4MYex570cSueGBEzSx5ngeG72Dc7rGjwoxsmmEOTaSOb5pr1uqRbOQxHLoFsdeXFFtm5H3CSWBxYHnXTMl+DF5qwtCi3OTtf9b98YphoXZFW4jMyqJoC3ZnQtviSB+o8a4LrqumfPE9tWa0UKTltKPm0iu3phnc2DzDDIcPQ5SZ76ErTipxD1OfKIKsr6k7AhTmbPGAr2/9KM7HoL9iVfUFzBZbrY9sFnm+w0i7bbIljb9ibTolDGwm8STqPPVWQK0liCJj5IZ6/6zNkHUNRkFPohNJu2Aror9QUmzWB8piva06zinyzo208tPKw1ILOKlDtDBXssJs9bGdJa3tYkjZgrKEQVuyApszYtQOMOOgtD13XkBdzbFvyRf1eHjb0XUaeSeja6KrDMQ1co8JoZTjiMpnOONkb4oYuBBF3hw6JqyhKg1ieV9sjMxVVM0elFr45JvIbrDCmaFMowN2JREuTlznaTbCG8jpuydc+ViXb75i0tkizliiuCZCIR3l9RpRa7CEFm3RHXsocIWQYu4Sew65WfSRk4pkMBn0YBVdb+d2F+Cu3eotGonTSGlUp2tDDl7AFbci8hS6RYCG7VxlYhkNgZBhKBhIlcRTSZHUv78mKvL/RW62oSeSDYtczHDrT7wGfYnWw6vWzzNtG2Js1bVmyXMY4Ku+HLp4naRfPptKiazOsth+K1ZuCYrNkbz8hGLqU1Q5rI/AZF+UENGQ9N6SMHD75yVs8fzJlpfJeGSA2lcRz+cDukBRG4TW0WiKHXEyjpVMW3mgPtxH2iCYtFLbKiYcdWlQWdofZ+DiRsBqeJWNYMoSTybupWeiK1apCsJTaFqtHSa1C6mrJIOz6pIdGGBACL41SynlKbYy4qkdcXn7AJv0DoFyv67qu67qu619LXQ8VruvfdjlxR2uaLJ4YpJJO1kwYBmPun2SYpkSmm5wtSrZXcm4s8KqavdkJttWn3fdnfyqnZwS4Zo3vuYTxmFY36HJBVxY8XNU8epiTVR2rEbz+CwNmr8ds3nQ4e3fVW2p/540r/sJPDyi3Wx5fTLiz1/HBuqXaGYTDFMsY8PyNOa/9zA1++/+2ZOptMWYOrlhllYOqJaSxQ+sGe93yu43Funb4E59JeP2+gR3Igs2hU0W/HZaBQqcqVK8eMKhs3Q8jjK7ut+xFrvjh9x7wK//gY56+u8AYb2k4xK9y1t2COIkZdyf4uwXf/GeKv77c8p//TyfYfisplH2cpK1cLFE1q2eW1Ju3x9z6uY5H/81jLn6n4aYT82OvRVxVmu3v5TzMdnw4F+uF5uXbHj/x0pA7wwgrVyij4/jEYucYfHdh81LT8JWpxdV2wN/5ZsZ7TzK+9mmTn/jUlKy5wjr/Jt3Vh/zOKuRXHxzx8MH7VPaK/eOImbx+z9n8xN2abdbw7sVa0GjkOiQL5tzJTGzX4DLIcNch2cajjoUdFpL6iuMqp4xdclGlq4CWFCO08DJhgqWkW+FNeFgTwXtK7GeCViYXZk4sUn414irc4Kw1u80GayNnddhWQ7KkY7+u2NYX6G3bQ9CzjcZ2OtrEoJ16JHnNYuOguoBx5CIbvKEfYeoaPw5p3QqPhMy12OkKp5Hkt5oNBpulYqs3uH6EGhuYy5bT04L57iFuNebJnZa9lyG/a7AsJCFwQR2naEnrsxWls8E4t6nlWitiyo3Npu546M7JHuwxepxy8qWcYzthU7hsdwt875DcWhNZh726RVIb5JmRwcF/X1qE0v0/db0VXIZjrhdSSX8TSBy9Rb4R4P0Wb5hwc+8GOQsqtelTHYpahjBDqqua7z8Sa0PBuQSanCtuHe3jOxmLzOfQaiinLav7Lt7zkrX5o7I5ZJoSj0IawjZFlTGp0kTGgsPYpRuY+ENJXKhQqctK26xlMypTFJWzTdd4YcCN2ZSDwYDOCtg0BQ8XO+y1AifHNyz2iwmd1dJ6kkigGUmCgV6xKQ3CcYJOwJEm8knLuZpzzAidbOlsj1HscFqsGHQN29wg1R0jp+VMOPXrhsKp8esdVyJTak0GusJSU8ZTCFyPeOjgJduetxAYFpICOoh8oiSh0QbrvKWqUpxGomO6PopPGkzf6fohhVg+SsfDtv1ewSCJDAOnZS5ylGaDkYvNo0D7nWAIqRDQXUqufYJuhZ512F5FwJiMIW2TyjyUuijJ/JCusAjNGHSIVpcEns/AVwT+BtMeyJCPvEopxXtkB1gTV1JMMSJFkgREdoJrPVOA1FbBpZLUAAjsHUV3iGReJK6FMobCTCS0h6hmieGXqJU0xjIV3OuVBWJB8Ez66a281iPd9NJ4FbS9amHmBr29QuwEArgJ5CloFZlEskhKr6+RqVGrTRxH0QjcUjprrSkKRVHlHIcmpSNef40jm3TdUJg2fmdi1DWtIXlDde+3aomoOoPQ8BlEK2ZRxDZtMGITQ8COpk0t78C8kywZurbD3Jl9VKYoSsRZJG9aGWF0Ahl1rB5uUpdwdZXhNBZebONNJOUhQmURRrfsWR52Y6DMhm1TcGhFBAObzdMhTbNCb8d9qoMQU0XKNzwe8hMvPd8PJGqJBpLcXy032oL3nz6mqud9Pm+VddTpGh3UvRTJTGwGocYNWrI6wTdKwsCHuiFXOwqJm3Q6Yq/D7Mw+01dbEgnZ4eiKUltc5rs+ArLeFjiNgxX0H/EMXWExjNHRlq4OGIwUhSo5X6aUlw7DUCbd13Vd13VdfzTq3wVVwv+3uh4qXNe/rRoOZ33U4saueVBWTM/Pmd0a9BBDxwp7mNvtw5tcPUq5Wu1wwh0vS0JWlvTxdJEfUFcZytA4XiA4KTpR7hYpZZNjBQ5x4GM5a3aXBdb3S558JmAvmfD8J/apz3esPqq4bB9w+/kv8KWbJWcXJp1v8JmjDU17D1NdUdBQ6oCfn5Q8/ZLNOx+mPPe05OCuLMlEhSpJDCZPVwXBtmY7nfHVV3w+dTvA9kUBKjDrTFpAJItbWAhKzp9KUYntune5luiq4LTMeefjc7796x/w5OM1VryAQpTVkpa15el5w77nMLGeUMaaaZPw9b/5MV/6BZ9PvzrsIXe1KCCEFdbJ2uyZQiGyTL50Z4b52YzTf7wl/E7OILD4hRcj/lqqePvXXNjZfO71kC++EjIZOKyaFjswOB457JqG7yxyRk6FtV/wXubyz363oTlf8j/4VMCrn71BvbDxrn6LYvMWv7S+wa+9qXn6nXNacpybLeZtl6P7He7Ao5lf8nbu8d4F3L+d9cllE3NI4y+x0j3KSQmrEncecHFziQqGtGQcFPT24LLwKesCRY1VNP3v23SaVtvYw5iBK5y7nK7NyBqD0rZxZWrRdQTeDmc16Re1bR4w2b9k449J3DVBepd8Pu+Xz9LTCaBwYwWk5YrY9Wk6H+2uhcBOY4/xi4pkqlCZZpmZOLmBSYZbDTHUjqodMKwq8GURLcvFFaYXo+YDjPMCt5XzctIvAZebql+wjhqT5UVNnrkYhklTOZgjcSN01NqjuSwIJ1uCzuFyaVOrFeuJ2NsbXn/lMSel7hXEYp2/PRUxggwEWgzD6vs3080w6hBxI5udhWNZaC3w0md2a0n8M3u1jOAVOmw3xli2xHbKIBYGoY8Oxr01J98tMTJN0FjkhcFqWvNTP73PYbflo6DhorjNuHvMUqCl/o6BKJlvaI7/AD3AH3iY4BUmqfZwbEXoRUxjA7N0KW1NG9iIIt4Tcr9seEshdFpEuqJebXuOQqFbwsTECRXhyOhprsquaQvZwJrUXcFaBVjSnK9r7MhGhQ4rVTLITGb2hP39EyaJEClbNruatFnT1Buurkps0yUzPfxiR2ZLCsCKcndE5TWstdDuU0ae5Jx6/SBjVeW9DEnSA4KmwTNiurBg/6ZJEh2S1gU71eC1JmPL6N+c81Jj1ULTF4J+09NntRBgHQfb14Sl6mNf7EDhmi6lRFzGNV4XcbubsDjbsru0MbwUXfl93Em5OUfZM4zg2RTKbBMMXfTZoVYkqpmCRkk8pdzM8p7I7zoB8pN0Y1NbbQ8vRCak/UXmIF1zILGN0tyXHq0qSS9SHrunTNsBjvYpvBzHtXGtmKqPFpTnoGLiHbBqbTpr17++y6YkW2R085KBLav/BtWZEsZA5FW9baWurT73ly4jdA3CxELZYkXJKLZrjBqixO9tETJBc8Sz5jTkdUmqLPykY+DKBNjkYqd4dJEysFoOjj2KQYb2x5zoAY5M32obyypJixWtnRBaDU3mkHopoXLQUc3QHzO4sWV9GtGUXZ/eIJE0rmORtRZ2KXm7Dba/T1NX2J2MdnZ0hkK5AaakaMhwQV4P2+ivTbVzCaOwt1dosb3YOYaMleV1EmSGZOrmTc+CmFk+S8clM1JsE6qio9i2NJ7NG58a8fz4gKyQnFyLzDAY2B5PTy95+HaBzlKq1ukHH1pAP3lIU8rQpqQd0MMQBWQkgxvbinuKbykYjjrvGQ8tcT+txLExTOE0yA3ZwJAESN1g5RJLJKDNJdna6j1snh/jyu/TW3JiVNgxMwseXyl8AaMODv5VzyHXdV3XdV3X9SOq66HCdf2bLrUKGYcropnm9CLHmsfsxmssgW+bEXme9UrTvYMh6rLrGWtPn2Ts3e+YxGK7bDFNhyCI+86jUc0zSylirxzQGXXfG+wdjfpEgXjUUJ0ueHfvgB9/bUQ82PKtX9nw8dMn/N3fPOPWl6bcOQhZbURS3xCOROlr01FJy8qu6/gfvgC/XI94+LHCGy8YTKP+3Lx+1PL9zuBzzw34T14aczTssHB6KHgnFght9h52Oec3jUmnBAJf9NGQYtOQYUNxecX5+SVvfvAhu6xkf9ShsxFnhXjTKx7lMbOlh/YTsv2KzWRLvB5j7a34x7/0mO7I4CvDiFI2d6KgVj6upNopITvCHc8i/ok9vn4Z8f6HDyi+XfDKFx1ef33Mu9sVJyl8+cURo4FBKikTScToeMi6rPnuRcdB6PKzL1h0fsBvvl3QNSv+4h93mD03ZHdaE773Q1CPea+7xd/4wKb9wRxXzqWHU6LNguPP7mHENlu149uPEt5rLzG7hDSqOPBDnE5Ya4qzi4b7q5qLgSRimAyeFlyGeR/JfiZMiG7Fth6xI8N2CkTorALppSKMaoQtDD6vRtcGu3zXqx5sVdGENmv7ESMdkZodRXuJNmd0VYXyt9ilzSJdkoxiGg2XCxgqiTf8iPr7Mb7h99blfJRw40Kx8RR1m3PeaPatMbqsuVrP2bgxlntC1OYEngDhPaxiwzBuMQ4rVumK5Qch1m7HYGZzMDuAqUsVmQQtBB9njEob4wWDduuLLJhUrxjqCP36Dru8gTmc49c548ER1vqEwUaxtLZ8dDbieDNAVxWmqL19g6Cd0LQtQejRWmKKyPGsoIcuSvXxkGK8EceNaeLYwqhzaQ0f20gY+C3mJKORhqFxKIq07y0jd0DbbJGojDoy0APFCycdR3c8bvgljdqyzTZUZIy7MZtuwNho2d8rKfXkRzdMqAOHO45mE9m01pChW/cxJkXjSfYgRbbrG72hNcELcuxtxfkq48ML8b2bDBILLd6ipmVVy03HJPRdglBhpjWWIVGTAjRsWDcdQwI6bVJlW3RpcvNEYuw6tBVRM0dHMVMV4OiC5SZmMlhTWw7Pj1zWzowgMNhkIkPaYZgBzli8TXEvWUlEI78SWbo0hhW7rTSRHXHUMRxHDIcGl1uDZVmRaZkYiT0BkkouaJu0brGblqFnYLQdVS7ef2lW5WUvSVSEY1qE4RhtpfhejH17wpG1JnyvZKE7sscxOnu/l051ToYZHOAbFVoH5NWGVu/wMfHx6OwGrwt6W4JIq+jyXhpfmSZZHbDbgeO1THpIo9gyZFpr4ZgFjdHQCfV/17A5nWOJT950cfYHTA/FGmDRmiGW2VCWBud1RaPXz1IL6hJzk5E+XEDpMd73CYaqV3EgMT/Winb3TE2h/ACrtnsQTSmjDq8laRNaV7I30h6V68VOn5vqGx66y1hJZmtt9lDNsv9+sFvnrM92tJ7JfOgwjis8rbFtm6YTL9YWHfoEjU2mHNogpat8ak8zzA0k3EGGL3s3IuapojlvqVuBW3oYbMXcgGEOMI2ntBJh2ym8pqYxxA5iYXYhCG/DDnoFiW0qDCvC8z1GjoPbKMpM4cp7whAT0qCPVzTrgnqTs1rlHA0C3OGW3VauiRKdVnRpQHAn5Mc+dUKEy4WuiTqR/ll4uuD7D9csz2W4ZfUfiGbc0OgaQx6Pp2ktg01jYuiAMJTX1sRUDWaUENcuQd1CZ6EqA/lY1J4E6+ieZWIEks4gkE4fGovAa2jkAFCISkXeCjlq2xEEHq6oGgSMGkzwfYtoumM8/v39Utd1Xdd1Xdf1b7auhwrX9W+qni4ecTg4x1HPcyOIOatqmssL9g4SgkQa7Ji5WIQdixduRSyrjvN3FfN8x2g66llk0iQrr8b0bXwV4uGgQpPcySA1WDVwVaeMRgFeNBbQFIu3G+YvLLn9/AEjEv7W36q5+t2P+M0i52f+jMM4Mnl6NuSQNb7p4PqaAzvmNN5nkyZ87VNzvuGZfOetLZ98zaabm3w/c7jxxYQvvJQw9cPetlDWiq4VzWhDI9qDqg8nxOhhi5J7L7bWAl13ZJdP2Dz9Ae2yZmZmjF6MObVb3n/PpRq5zCKj3yIbvsPYNVFhwaC12Y0rJknD5bsVf+ufPOHVPz4imgkM3ENJ1oS5w+xk4KEoDIfZOOZP/umA/8MvL3nz2yVR3PHqCxOazx8RFA0jWSS1FdPRgMHE5XxX8r0rgztji5+8ZVM3msUy57URfPkrhwxmiuzsDPu7P+T8wYq3HPjOboj53tvsNTbpzUMmY83d5i6jWcS78yVpK6yMEeqjCX58wdFiwuGhz/dEQaINKkmiM3bs6h07JyCpLVy3ZJDeII0t9ECU3gEBQxwzpqgcSs7Aa3BVTWAu8YwBOxWwrgp8K0IFBulizmbc0qgpth5Q797HKGyu2oDECSjvXtKdNlwEDU6lyJYnDPY+pF6MqJ6s4K6F5RQkyxlP0y1mscWsDfKnCcVey9DxuFo6KN/CmG7RRkuQXLLOTbbngi3z++WsXjYYUUEUCPdthDHQ7MVGn7jXFA1xOsTzNHHUUAnrr9Os3BzDiLBmBuanOprSxMr2GLUrqE5IBnPmC4vTwqVb79E0BbfHLlVY45YWtiwEhVUoMaZt2CePyChBdW0PEZXkPtFIY4ie2ugZg2EfNVr24PU6Ap22XK6XNGwYR1MCO+hRBGW5QiUt+lM2N0PNeVlSqNvMXMVadzyuDA4tl/O1IgsGTHRNs/oRMhOmToxOdoxqt8+Jbc2GebFlIFaCFlJ/jE/LTHI747bPW5WoOsP28DtFaIS4OqHNTM5XZc9KaMuKy7TiKtWYWhFGDW6UIq2aOLx1bVMLqDCw2LpLpoXDVgVcrq9EH8VxYuNkezzqrtjUiplp0YQHdK7B1B1yme4IrZAokg3rHkbjMA4cDLsmVNJcKspBS1aVbNptvwW+597hcOLjJy5JllGmZS85b9uij3AUaEto573/q3ENyrJFFxLtGILh0bR+D8twbINROKVuLZLSwfE97u87nC+2OBSc7gJW51sY3+tjOnS0EkMCTlVTdi4qv0IbEbY9w+uWdJ5L4SlcgRuKGKp2sRP6m3HZGn3mquNlopOi1Qk2Yc+WKMycxvaJJY7SbCBbs65jgtbgajdHW1MG+zZ5K7wD8c1nRHZJu2ixq3Oqq4psbTJJTGLPZ7Y3w6oa1lVKUcnGvMZLbGzJtNA1Vefgmg6xZWGZwmEQOKdExcRoX1QUQhOVSJ4BtlX08Y2FKKS2ZS8RsivVU0mbtmJ1LikfI8rMpBpmhEIstToGRkgUDp41/WqE5EEMBeYinXHlUIwU02xKrOZsdI1pWpTBEjutMdyERqZ89ag3mkj6AU5LJ8wOQx6zI8kpfeawYT/z1bWVQC49Npew82uwFYn4Njxp3EW6laE7GRjYZGlBd3PCrM5ZP9A0hgxARH0Tce+1Yz65/xy1UrSG3IQhThzmZ+c8uljRdQ8pW5lOaqxCPngdWqsgHAR9rGZbasyywhKqq2tSlxLFYGEF4bPrQ9xZrdiDZNBUYHUtjTbRhocrww6tWNY+pRBcvYjDGzn53OEyq6hWir3AY+xBdMukvpBElRLXGRBPRdh3Xdd1Xdf1h7/+XbU4/MvqeqhwXf+6yyhr1guTk+GYoS7IOKM9G5E5Nba5YRhOejZTZe9Q0bA/T6h4x/asY22ntElFVti4rsHRaEZQx+hSM3c2XKVXjFcm1bLDWA3ohtI4WXTVmOl2wQdPal5NXuXwBZeXPzPl9K++y++VBk6i+I/+wgGHzpC2dFg2NXuu3cdcn9gujwYmmc75Y294fOubLb95tub1Iubm5yf8sVdaZn5EUUnEuKhTa+nNaFVDoQ3aziSydQ++q135PhXL7YLV04b1gyuyYsk8jFG2xnFDgv2K7uIpg/wEO0+wJnMYimo0Q5UBU9OjjlJOJMY7rFl+fcOvVbd57i+2vGb5pIbCUEEPdBTWVVcLMNtjNrP4ypf2+O2LnI+/f0Zkr3l+5vE0VaRWx+FkTDyxOF/D965qXrkJXzryef+p4uFZzuyk5ODGkLBxaR99TPfgd3nv6ZxfPz3k7YsNT5Yf9kT/YuZy4yhjbBTERzd5e7XkgbNl35rge6fUwQlhtiMdxpxmO9wqYVLkeIZPVYWMyhWZ8M/UDB09ZnAW0E4NbK8kMlLUOqYUyPe0JS/2UeUSN1j0PaKziwkkdWPq4XQZ+cCEJyP8ZEDXFrjGjsi7z2a9RqUmz08OyL2MR7dNdH5F3uxjH2wwJXfOPyH0H3MetrwcaDyn4nF5ypFOWMhM6InNR8aOQE0xsz3cwTmh0xHWA9K6JtMlhetidg3FxQhdKiaHNVEQo3OfMt2CKakgYhe3eqUv4ZbIHOLFBrVnkFwNyYYe9dLDmJ3hPh6it5rTOmeQLij0gi494oVbKaqpSLMlB7ObLKIMUzk4ht3baoRHKP2LhUFuSkrIs2hIuVBVJ2d9A8sWRbvVJ6V0ZkVj5/1gZ2g+sz1vUxPVNByPRn3C4v+LvT+NsSzN8/Ow5+z7ufuNPfesrK27enqfpckhzRFJmZJMwoDhBTYs2B8M2Absj4IBw4bNTwZsf5BFwAsIWLYpiRb3ocghOeRounvIXqu69qzMjIw97n72/RzjPSV/NQmwSQ/F+BcKqKxKVEbcuHHjvv/393uebJYSz0KSewKc2hJG4iwRceFMycoSVTAknFvMRMbZHPDcjPheYP3ylgk3yY60NThMDQbHDqaSYVUmUdVijjMk1cYXnRRtg1NYDA2D4wmMNYt1mKJLYnMjlJAd4a5hd50J7H6vCBGR9kQ8DVSxVZR6yEuOht2JREZHW+pc70S3fImv6yx2KV2XobQD5KYgScSTuGMiZZy1275fkjUb6krHmIpDq+jhpxiGR1xGbIOELnXJLQXfM5DVkk0kDm+ie9/0hHylcjGVjs5O+01QXOmkmoXRlchdQdKVjFubgd5wK7ZdWowjNIFNQ26LW3QdpQ5oqyVf3JQMZYvKM4maBEec+A3xYuVgeBJNplPFOaous8kDtMKm6YElAgxZ9d19VUTAugbVVvotld4YfQRdUyRkrUUzVVzLgUbAAw3KYkdYZgSZi2lZfRrAaDpCSaVsNerlFdvnMUG55uhNFefkPvueQ5UFxHFLdptSRjvK2sS2LWxDoexKFHFItUBJxS23TesIlQh4tES6gVGLaJFMWpV9NEzQbyVDKC/FN4VMV7WEZUAn6K+NjFzVFBTUQvdYt/0/C1puW5TE246mFUrJlGEzxhoZveqEoiUrU6qmptBaTKFCNOovibhRgT4US52AtFAoCpVWtpEFg6AMUUwXubymimTUiegilbSW1CsRe6difxhv+kWCZo6xhla/rQ5vM7JF229cVVuj9TQGUwtDYAsM8RiY/dcxC2zyTObQGXI1iMlvt1SlDkObb781w3Q8llGM18r9C5Zelfzicku4CSET8NFlv+Ahy9AZYXiCu9GRVB1ZKyM7JoosU+8SwlhYJWA8k2m0UW+fqNqOqu7QBRPEbNgKJmtqoGtdb75QBwVaILgWFif7FnGrsc3yPvVBqNMelT2ptlJ3tNqWNhvTiLjH3dzN3dzN3dzN3fxrOXbtc7vVObpnMJxpkO0TbGQW2xWVVvZQdSltKKwBQZqiSTvkw4r1i5T0tcmTZ35/86lcVzheQC4ObecVN9xSpTHpTqaWC/RDp79UdHSH6dhC8RRe3BR8tHjOr351ztvfHbD9xOHzbcM//B1442tDfu27HWqlsTZFiqAmqTPyqOPBtOaDdo8ng5L//n/N59+/uuXJA483j03BmyYXNVBxoYSGhE7X1w3EwUhUgKs+jZBVGlVVcJtvOP18xe37KXFc4I4dSqtE9RrMNGc61Hg2kXiRh6yCGqXpeiD2Yl9nnupUcou11ciOFUxtzSwd86O/csoPv3OP/9V9D00XgEehi1S/hGjXJUUrY8km3zgao/8pl//sbwR8/tGGwb2WtTnkrXsjZhOF0yjnR1nJN95Q+PZY59PXDX/wWcT+ROLxvfGXzLhPf468+5Q/WKT8vfOW67MYOY4wE5OD/RnqdIRhnXLVldyGGa/t5xzFb6JOJVxL5bZt2d8rib2EXaZy4FZErUakF+yyCstXmK32OA82RLaKnt6irSf4jcFiEqIbMp2b0uUJ5tmAaKfRDTuKwGJd5qi1g+uMkM0UI7NRPZVGVkirqz4FXS73kMd5/75dfzAmEoaC1kNZOlTWNfLeOVb8VeK0wp5fYVTvsJo1cLVgc2ZRjyzqai3eWjNUGvJtgeNaVLqBZxkcmTqRgJHrE6r9lDSKWUddzz9odBc6AS247WvLl2sFLRZMOI2zXUkhdey7CgwXIHnIXoc0a5DFH6YPcBSTVX7NZjMnzBOk05qTX1U4nCWc3i6owjWTyQEPOCZxYhRBWRT1bJFIEDrSDgqp6N0j4i9xsd0qX0JN+1WDLCHLUg/j9zO7V9vXXYYm6b3dLso33HQLfP1dzJMhlSPzmBWqZhBpO7JOVIMkXL/upQGaZuGPSo43LsVqn9mTyS9vmbDe1NiuSWPALtmSNTVdVfdqwDRRqK2SdlDR5EJFp2JJIYZc9nGViWyS5TWLpMSoRexeZrMTRfMEd6Tgz0fC0tF/AqnwIkgJtvnlAagKPKRCRookkmJNIBQzgU4tbl/LDFspaKIKd3/S//+UvjfisrnZkU47dFVG6wx2dcKuELq+gKbQqZuIYe3guxqV1eGkbk+KjQSBdZXgShVmLTopFor85YHZVMSTt2PXWf2tslDyOYbFfcUmkndYmg2DGFU3iERsvMtIK4Wb8pZVYBOsc6Q1lOIguRbRmBJNuqBTjjFLH9UrYBf2pNvONzFa0ZMRblYTKZXQdRnJ7dBFNcAXh12zP5CjCW1NQSUonaLzLxQnwttbqj21tJECtp2FUXQUpY2pSsJ9QNTqFKVOGPicvDvtjQifnb/P4lLrD9DTbo+63TAemlSFzOltjutnOKbf92oUoRgJWrZVhTPsMByNPDJIEgkjETwHkdB3kTUFWXR8xA+cWhgKVHJK8qKj68QyROrZAnXZigYHqiXaawrKXEIz4Hjs9XBPyRAbY4N1BGYXUskuTbNFaWqqwQxL0WiqsF+mGKXYmBYs1IJcydGzmloXCQ7x51g0co6pS6S6hqQ1qIVJK3SVcolsV+jGkPuHj3n3W4dIds4XH214/pOAYCmqNwKKmPSVjtGhjqyLrWDXG0mKOOP2fMvTE5fx2OfibEepVjz5+j7fODogFcCZsukJvpbWsrlZ8un5FjlTMSWPxozJBJjRdtA7UQ3x0EOxPGtoipKyM2k8i1IzyKUGuXQwOo+RrNGKtILoHxY6nl71USlRi9HMDEPVsXSFzsppKgvDV2hKl1oAM52cSFg4ihVuNsQ+UFjuSspaZ6sbmNUdgPFu7uZu/ss//yqmEv6/c6ePvJt/kaPaKse6Q14myPoNJ4OvU371FH0576HTZRQTqC27jURUpozNotdLD4Yai2uINxrH0444T2kiYVzLeHkaskhvcUctqbyHL3kkgpNldzwdDpkMXTaLknEzQFqFBLcDnro2+n+nQfppTvpZze/97Asmx4/4+n2HI92m6y5QGpc8T1kEGY88VXzwPHuo8O+eTHmm6hiiUl0GtAJOJRLHek6Vq3SNTKtmoDR0UkHedAQLUaXesUly8i9K5G2EO/F7w1ZernvmQV7EXK1kdNfCfjeEhUEVWeQ7j72DDq0aENrbnnlGKOMdCIB2wqTt+If/sOGL7xq88xW9fx8pDtDiVlwWFoxaIpMrPNXm289MftpMePk3Wh6WOt9528MYtHyyzXhZl/zGI41njcLzD0I+XKY8eWDxvXf8Xi+//uwXxN//OS9p+U+Xc7KLnMf2hsCZ8XigMzsB5zDmtJiRREsuVxnDfR+vsiiHGWm4JmpPUIYHPM4mbIdCfThiNd2xDQqiM4OHiodtX6NYgrFmsGoijC6jjixs2cQc1QwdmfjUo4gyYjWlaBSUMMafm7SNRBoFGGrd14ONqc1Ki2kTiyCRqbsVStxhGj5l0pJsC/LNACW9hKct+sZlq5cMvRusyCMe7Gi+CFhkOWksMcRCHirkTUCWOfhtheNrmNIxptB/ihTLsmDsDpjMJ5yvO1ZJQ5glfZralQxkU0azOpJtRLBSsX1h5IgpdxrX4utklPitijma4QyXKFrMdTZje/Wccjil/mJHq48wHYmH92YE45ibhQ1ZS1bl/cckeIFlVWCWZm9xEHXlpm1wG8GGKKjqLxGgciOS0V/+vBIX8WhyX5vvL5s1g7K/jBcwdoOizbkJG7ZmjL+fEVsxg13HKouxxVlRN/GMgFAxeNioKJWwGk5ompJfV9/Ctex/+uvDP+sLydRukbWEXCuIBLEzSJkqNrIms6wL/EAhdit2q45lnBAosYCNgrhdJyKLSspIZr5nwFAiE5H4CqyZxdGeuNFWuY6+jGqbIgqfieOuTKMEdNoQvWtphIUgq1Aqg7F40Yk2pJKHamR9BH5VdbhWTqrEMK7w3RKz86gzE7s02WVL1ELHtDPEZbHYFMa1T9MUhErNUMRF4ozdOgEBw3BkVDtDd3UEw1VqalzdQrOHLKKCVkTHpY7ZUMdRNGhVlHbIeZyiYkJn0nUa70z32dQV4dJh+fwCqYsotRLJBVlOMLQASxnQaDl+Z/bQSKXRMawVarWHXFv947UIG0Z2hSp4E66Fqqmk25okjynVmFSWcEQUvtR7cqdpS8hZS5ik5C2Ysk1p5litgqsOMUYFpZNjH8zpmg1holNvVNrzlIQQfTRkRIm9V9Oud2yTjnQrkQwUsG5xzBFlptJ1JZ2oWGQSadZSyxGeNOk5ErIkFh1K/zFaDHv2g4BeKo1GoTfIttR/7dXGQNZVTC0DK2M66PCHJkkx/HIJoXb94yMsCnWbUyg6vp+RBzWyoWFHNrKRYehjyjDGmBrsTWakVUaSRchjFz+/7X+dK0MQmtB0DplYcAiLREandBiq2PDZ2OaAx/dmfOPxPaZjj+89yPnZGzf88JNrXl4s2N3uKNOM8tZklDbogwrF0qmLhDA3iFE5GKhcGEIhavJr3xj3pOJ1XvV2C7EWN5San6w3rC9uMEsDVdgZpH3apsCVPDx7QVY6ZL1XVsKxPRq/QnEC9HzCQFbRagXXk1Hc7MvNei1eSIreCJHJNW0n7BfCOFGSVm1v06jKnCxuSOscIdcQW3DNKtHkmqxTub2K0ByVYbBPIcUEGxEBvJu7uZu7uZu7uZt/HeenH5wxe9bwUHlA3NyjG2Y4Mw1bAMR1cRD3MSY1e4slz7cS205n5Jk4ewbTMmSbXOBPj7C0EbLwb3kO4z2dbJdQ5zK72EQhxKnA96bs7RusigUvQ5iNVYxK5eL5a+T9KQdv1dyfDym8msPgit//zz6l/fUBv/lNlUA6wBXV6j2Nl+cOJ2T49pcd+Me60DA2vR67E+9NO5laLBMKmTxL+2SyqYiLTBEr35Ju1hTnEfGyI+oqpDrHOOoonICyhDq3e6DdziixOgfrcM1XPZ+FNOFClhh2FW4gjGo2SRPjjsQVswzlIaVxgf2ewduvQv7+33iNdQJPxlNyRVgOlN68JY6LRfPlkdGWdX7r0Zj/8Nsmh0aLYqb87FXDq1HJn3zm8Xgt8f4PrwnalO98c8rhiUcXXLB/+VMkrvlL1oi/+uOGpkwwEonnssT0vo19T9AMWj7evaCM7iNbNnl9hhM8Jdor+/69VXq4TkvVuSSjisGlzXmyII52DKMTgs1rXto5xmFKdC+CVz7tKKPWOiIrZljb4Mh4nkJq2TTmBi3t0HxQ/ZZMyWjGOdJhjXE+Qb62iEe3KMJGYR/Q3ogktziXqWg7DTlOCbIK27sk3MQMNvvUfkpyW/YXmxvvIarxgvOVRVEraPaYylzivuPCxxMEem5srhnuadQH52zPPa5zlVzY3owVD7T7zP0pz5UL2rzouReWZdGMNRRVnBVsbLfByFLQDVR/DY9U5KsZ67ZiXw3Rlx3K5AjOcxa5h53oTO/T2x20dI8//d0T7j17xvZQ4vf/6im6VFELKUCokhkZqur1IEbxPFWUL9PBwjYnUAniVwK+qEhKX81pZcE6Ex+7hImoaIjnm0xUd/1/s1uFLFPBCbAskTAPuDQLNqXNjJyR6ZJpe9hVyeha4iwomEqPePvxU9ShQ7Os4a1f0jJh2YJW7ahTkSnfY9zJBGaN0azRBDDDbbhNthipiWc3aMaMeZH0Ssmw1ImGOQUyQdP1t/ue3TLUbYb+iKrJuQ52LG5E2KhFm2iUTY3Q0pptQiqonF2Lq7lonURbNqRSSlsLDaNGrdU9vNHuYioBr4tLho6BYZgsc51ObvHMFjVoKVWLR/MRQQu7/IKb2vgvuiVm//sStaGJW0I5x8ZCEZ1+ue4tBFPN7r+5uzZnoml9AkD4RBMRLc9lmiSmVWqK2sWwuv7geJNuUUQO38mIX4nXLp0sCmhMh9YyidIBTumS+zGmWvXfyI1SYhYuqi4O3S2Nm0NskKc7mkilEyCQRjyDKmpdp808YWrsIYJRqqMJ68agxhSVAFGBCBIcrUG3cjLh42l0QnXYWwQOJFEZuOH05wVpO6bOVDwDmliiKBOsqYY3sGjahGET0bgKmbLDKkS3Scf2G2h1ZPF1qHu3DYag02rgdF7f3ZdR0VphJZCIpKiHbMqyim07uLIOaoVny/03jTqUMAKNoVkwmjpEpFyINEdtMagjHMUFe0WRDnEKg0Z2kDQfX5BanYoutGjyHGPmMBhucLoSL9CoNJNoO6ddh9RdhOJVPXNA1TXIBQm1Qx1V6PqArnWZD0zmE4NG14Q4Bs01+eZXXN5+fMBPrxf88JMzLj+75PYi6wGLY/G94LpIIjEXN+R5wT3PZCiglfqch0f75LKE0VakioSrydw2GZ9+XtFtYtROvCBlFGWKlShkXt0/t5sqQRuDpUxw7AmDUY7b1ZwvVQKlZObaOJ5B/2NQgDjFnsITak2JpNVp6rzXyARpTSNqPJ2NoVcI428XNwTC8KD47DsGLQm14pJtQkZzg7LUUaoQSYAb7+Zu7uZu7uYP5dylEu7mX/S8kC6YRMdcV2e06lPmUw35Ruj3KuxaoRrr/SFclYaM1rCuCm52G47HY+aPXa52HWleMpFtLKURaXAcX8eJK+K8pisVFp1EGFo8eqzS5A5XFzXrtODZvCMNpb4m+/pqxfBE5980VRbfOOCDv7rmd3+U8eH5T5jufZ23H5akzQgalZORzDaScPwY2+rQK6i6rAent/1po+wPaE0hxOgZddNgNDF15/OxSBO/vMC5illkJaWqoHkuhZxTJRk3i4KVIzM/LDh45ZP7JdPRMUth+ZqFjC2bYtFxtlJ5qJ/ipvdBakjU15jtCULcXugqU69l9zzn//l+yP/oGwYzVyOSRNJVo5Mk5FZ8bEJdLvPMdviffFPj06uQv/OhxNtDmf/p8ZDFVctv//4txazmO79xn3uWRhd+gnH6gjTOOMXn89inDVYcTQK29yyO2wkHjwcMrZQXQcc/qRz2rTOOpEeMjpZk6YqdD/sX+xzmh0TFitDXqKWG/djmPA7JKpe9sEY/sMAp8eUxm5WD3uSIt+pUU3Q9wGwF760mNUvqQU1t7WgDcRacoyo5XbRCymaohoFp58j3NNrSotsK7ltEaYjD8wmqdUt8s+Fn8hHOzZxqmGGdmJQXotIboxZz4p+nNF+7wV4XFMaU9IsP8I5LlAcy+9s51tdHNKsQfdAxGiW8TDWuX4U9dvPAcoiclovwEj23eDjWkfYneJaw+KVcKQ2VrDLyJ8R+TbC9xN5M8ecO9WRLks4IPv2MfKljrDqG8wmrtECS0z5FopcNxfAxu5/InLYWf87eZ6213O7f0rUZWZ2htRqWNOiVpw3CgCIhJH2qWBgInloCUgVaTwbtvlwqyCoThlRSQUrYc0JquWHgQ+bmuKnJRJwlD6teC093yKBr6LQFmi7qQRl2OWXvHP7+34ZdcY//xf/4q9hHKttSQw4FL/CXtEw4WwvEgcGxZfL0RMWVDdYtBOqUMKzRYp3CLxj6HeQ2fqOQDlp2ToFf22iJyp6vkjUSt0FEmreI9FGbRTi5gi4OnLrQrUjcik/WyJhWOprkYkkCvFfjWSmFNiLpElRd3ESHWI2MUk3RiNFMUZ3wiPKMrV4xyubYWkOSZSTioFpLDAYq7sjlsJtyE5ikSdGTZUUmX5D7J7LSmyIqI+u/GHHpIJr8nZERNAIxqVAL854tozQDWrHsSASAT+0jKbumxtcr9gyTbR6yi0SSQiFuWxo5ptMkSlOAFUVNYoLW3VCIiHqaIo+m2G5Ml8g0qkod66hShm61aAIsmYt9rkkjWQRFhtFF6M4E3fdoopQsEUmHCmOU4HkylmpS1A1xNyTMC5wmxbU8XLcjFvWHtqFMajanCZY0wegKKhakiorUGnTZgtY8ZqiOWFRiyRIheQl64/dLAwH6CKIWT0TxlQTbGeAOcvQmIavB1UXlQMAUZUwnIm0cpFzFlMWCpiUX0ZS2pu4K8q5FlsEX9FvfISsNFEnj0UjDbFReXUck4jAuovvlFMqAyB1gyD66opO5HXZtsJVzdPHvEo2mbNktBQtghb7vkzQCLqIgSyl1PqQrQmTNQtI69G7M3HMQKbQo1nlwNOLJ3gBPVfu4XNp0GIqGa7v8+hOXt47HvHhnxs9/seP8szU3oYgNBTiqSXWjsRzW+I/m7B15WIqJJn44VBKq9mUHTlU0/smLc1af7nB3FvUwJ8/E4smDodmnYqz5Ya/I2XMMBv5APKBUwr4RVEhxjOs5vHXvCY5ac76+JWoa1ObLr21VN7idii11bERCwdFpygYlkzBkG9fxSYMSogzDMxhoOYEuKhUVu11HOSsYeBJl5eIkdzaHu7mbu/kv9/yrXHG4m7v5Fz1/dP6Ms03B6F7ExFpztbzt3+94vsEuXLB1Wpy1gqd4jEYxjpIRxCVZljEeTHhgWJRt0R/YI1Nnp5dckJDdOLhqg/64xY99xlMDf6jz8vwMP9W5/9joIYiNgNFVc+bzhKtPTZr9KfEh6O8aTF5YzK+u+Z1/sOXBfyNAtXLOz094OEtIxwNqxe4ZZE0t1OYKsujVliV1K+wMBq0iGG4dUquTxjd8vij5q7dnmJ9cMA4m1K7BviNT2jV1UdKlHdtVTdxZjHcRmlhSWAmNPEMRIMV7GVFdYTdjgrOW4KhkOINd3HGiuJj1mql9gFTVVLOEB9mQv/mjG37OgO9+XcL0mt5uJjKhitTRCEtaJdhoEvOBxt9YSnzlPnz3sCM6z/jLP4xI3lT5r//6MU+KEun6M5Twc9J4yQfPB/yl91t+fnbFvt0i+RqPhxOeuCMiJeSni5DTpkCyZGKxNFHGqAcj7F1Ht5TJ/YZkltHu5mz1JfZrlzM953YkkRXn7OlTHFuhzYZE4gIyzFD2YSp7LDYr7GyPmppRYlF8UXAZ5LTCotZKqJsWRSqxTIdO9alrTfjraKchyianEAy6ndJXUhpljWl17FwfZ31BVcxpipyJf59td4N8UdOMMxa7EOMC8tMaZWjjDgccHrgolUNXqlwfLng6BUdquU4btHLEwew1RQ3K0kA1JdRx23MKbNOiE6x3Q0PPNY7LikLEvgdufzFoZ1OM4ynJ/BoDh2gvwvvFE5bGS6RTBUcJ0K0lhjRg17zkgG9g1SvUE4+f/PU/4B99Bz66NPCz92msGWrj0kodpWAeeGC1Rs+CUyoBga+Y4FIrAvhfUpIhdQpao6MpOoZpI5USubjEr760Jw5Unbnh0+gtaRowyIdoZzHb8XNG+jEPFYO6OcHPV1x+EfK3/qbO578rc/yGxJqYNR5DJBSRmv5lLRNMTVQVJFFCIKwLYi3jujQwmxtk9jkTSo+4wtlfc6ucEEkxmqwztAfIZUCRdj18QxcLgl2H1tXQaFQN5LKMpyns7RnshF4xLbHVPfYkjUV7QaWIaL9Orkg0ecBwMKHTNeTW7DkG48BnU9wQZ0CyYKd1TJche2/skWQL4lpnYjj9rXclxaTrCVUWkbc3LDoFu56QGhWmrHDk2BhqhFaa1KkOeiBACdRCxdFW+CKRgEVaitZ/glJVKPKIvGlQKg0zNdHmMkIuYEgqx4O8/7i61QhT7ijCBsk26Vpx/Z/10JWy8/GVBmXXkrswal06FmTJjDqJsNyKVl5jNC2qWWHLEmWpskkS9GKHRoFSGyiqDpaIc/iUXUBa7hArLUFeCHctO8VDn6YorspIEG9VGa9QiCONyskYDB32U4fPo5rCrwhXHWoQML8VLmDR2phxe1GjTFYcH8ywJLG9EAsJq09vwKZ/nMIY/OsQ0+3IVRnLHoNi4hsKuqzQ1WJJItGKHypVSFqpOJ2FaYhufo1kygjV77Xwu2Y6QSpMDSVtWhGYG4byIZorngsluqagKgpdHvX/X8NtaBSFyskZ+0vspmPdaGSrC6pYp2xXtMKWIcwZ/WKvIzcUNE1m6hooros1czh6uo83HaJoKkbdonUNdVmQpnn/e8eGy+zRO/zKvYKXX1nxk5+fc7W7oYkUmjxBvwX5JGc0sXl1u+Dvflbx1viE8Uhjog1Yry959f4lRX2Koe2T2znm3kOc/SGDoynzMTwW9oqwJtdaqqKgrHKK1GK7zBnbDk8OHWq74iLLKZuqrwLpltqnWeqsJFM6NEfBMwZUcUWSpdhShTcyUUT1pOed5MimTyBou3WNUlb9Rll/3RK7Oyy9InS2/7zvQ+7mbu7mbu7mbu7mX9E5efcR3eWHJM2Ei4ua8f6WTLaRVAfdUNirLbZqxi5foLgtnmJTFClZvOS6SnCdOb416nvfegNvNXtM9YCXBw22rXG05zDQpjR0LJMAb1QyOxRpYq1npB3ODvqO+CJoWK5K0uwz3jXe4vEfHfO6HHO0XeKXa3728yO++u4GV5vzem3y9ChF1x3aRvDJhSK7BrUTXnDxtpKsFjJtCVXZUXQl5y87PvvJioflmoHgpkkdlQFB3tIkMmPHQVI15kqKR4V0s8/tQkKaVVRWi6vIHJV7lFVD0Wo8fpCz9lSMhYcy36GPJ1RBi6yobIoNvj8neWPLn1Z9Ln7wGd9vB/z6r8qYpjjofakI1NuWvBEGsJpG1vmTno3Z5pydLvlrv1divWfyZ7/ncFLEdKefo4Q/Zk3HDz41+Rv/eclVanMw0jEezHgwMfBHLdfJlufrhKvlmoGlk672CFhyZpxiDmO2Z49wJi2HRkyYqUzUl3xkdExjiddeQfuqw9enrB9KeHOFm48KZouCUvKpk4Bu3KCOZS63IZomUiVJr5wPrlLq2ISxRK2HNKVO0Zm4TYrsKizF280FNJ5BGHao4tBuO9SGRh15mEWAlljkxQ7XlriNTpFmKtW1j/zODUr3Fu37F5RP95CaU4bzx3QC4Pi64vnDEO3ljs18iufL1JHKKq5R8pKhf8TSg6i7ZlzN0WuJVSDgHhJDzyVD7U1pQ1V8LRImErizEUXSl8LZNTK+vmJ0ZCGn+9xe7jC2VzSGeDxk9Nxl+hUIP0gxZgHH0TX/6791ztNfjPnaGwZK6bKneyJyQFN2mIFCa4qTF3SNRCbS1JVIeCh0TUNpCrGBjdRIVEpB19Z0rUgqqKjyiLIWGsm618VnTcnyOukrJ4LxsJDh3rTiID/ktnW5uDb52799yqvfXWAfuqxul/xHPznk203Kk4nf6zp/acsEu53T6BI3qwUrcaHMkJnVUXl7PFXtnty6ky02nYErnJ+SRqEayOuczSLkuox7kr5tid5Mx9h0eqBgIxLxighrtBimgz/ySYstsluSDV3c9JiyTnAVjak0YWkkZGaG1GYMVY0Al2qwRt12VKk4qC76LVejDdmtatZ6gFzfpzMjPKdkldv8+OoFjpNixENMScfpIgxVY88w6LSORZqw2ooahcbIsHF1G6OTMYSI0RBLEA+jVanrXQ8ZtAT/IN0QCKLmdIRudn1yYFOEBMmWcqHw8bZie7WiFHF/wQkoSrSoo/Jl2uwlFCdIsxap8tA6FdU10e2OXJ9RqmvkQqaqBKTEoIjrfqmgdhZNJDpVBaVc97BCr2pIU9iK7o+oImgWXRH3LlpFvJjmGnGlYikSBi6KZWDbO4I0YiNbGI9tHjBmWdySrhuSGF68annyRsl4onCx1RjjYps6RTLuUyBx09CJToocECcycd5hyjLXsUZjDXioKwwch6StWAUxciX1B/5GqinzGiWrMFwNRVFpy5K0bsk6vdewmMSYtUwijIzicO0JV+yQTRRiOlq/uY26ECtWRHGoT0GU2pJpfoK6lzLZD0giuV+MWIrRWxtKzUHNd3SKQdvmqI3PaGqh+9B5Eo8PhhwdDWhNYdToQAAIZSGdkZEFV0CAR9sWw7axnSHf/Mo+z+6d8OL6Nb84veb6xYZd1BGEFSdzly+inB/83WvOxhEHT2S+PT3iw3hB8qLFemhjjMZMHx3zq7NH7LkZI92gLho+2Nyy7Wq0IqOLEuyqxWklWtfA8RQGriN4kWRxSSlLCOCsLj5e4Vq2TZRc9AxFjK+irVb988O1BPhTJiu3RLscVwNT2sJa/FDNybsA3zjEnsBZI5ZUEqXoFt7N3dzN3dzNH7q5qzjczb+MOV0G7E/fpsjPORjvUdv3WZQrFvmWsTLDVXUeOFM25SU5eQ/xNt0RpiGhSQ2b9Zrb1QK5sLiPTavFKJrBo4cGsrisE4cnKyWQa/I4YO4OsQwXw5QICSCCRXyNWleYesqLF2NU5xPeOxrxb71tsdo+RpdNfvr8I75YfIt/90/s+EVicbmwODJSDHERWAkQuLgDE4d0E9VUGVgBZRfz+tTl5lVK8PKUQRlj+SVRXpGWG4q4RWkbLMOgqAwitaPcz7CUHbeZS6g6PEgM2mFCAvwkCBleTVlEEtN7HbqI969qZlrBKlHRjTlxGbJvOtSdjq5KVG2JflDzH/6lS5T7Q/7I/Q5Nc2laGUnUlWXxPkxUM4QSPuWLH4T8wauavT/h85tf2+MkeEF7+U+Qg1tukxH/8acaf+1HW/xY4cFshzsYsT+dMXnU8uJmyz++ybBtg0PD5mwrLjkztMUB8kHC4FYm12uS+2uScMKp+po97V2UsyXL5BRle4+xHVFVCsa1hOyClo95PrvF3pWwM7jOSzRd71kPaWDR1BHeA4n4ViVbJ2RahTzR8XUbqRWLiRJD7ng1TzB2U1RcnL0LytwmvSz6NEmuRKiaQlUklM0x5WyFU+lYi4z2vadY+ZZsek55LcOlR3fwitQ4QTfvsfFWsH6BZb1NXUlEtY9SWbThklyKKBcqrbA3jA22eY2TrqiLome5CdOBWBgk5ZqibLE6l8xoaJ0ZqSVTlBJeW6Ev97jyNjhmjHfQsJYtvmJqvPQiykNhC9E4vt9yNLrHpLL5YxcFowcafucS2jvG3Yi2EqmIjqSMSYycUTNAUzQ8kYzXSsqk6P+7W4/FE4FOyOm1XQ9lVGW9t/9N/ZqyksglmU277i8KU8UgjSMetAWD4DHDesOufEoUbfjRL17zwe+3+F5KZ/uEnPH9n3Zkm+8y+s2M8VD0t39Jy4SXy00ft5ClgLEyZHBoUZdBH1uvnJaj4Zh7Aq6nBVykGVc7DWuWoRUFZ8uGJNExHQFHrFHlvO9+pJ375Te1lFLlGp0a8mhesX8woehqxqqCPZ2QRxqFrGOqJvsDBWM74UV8SWvmTDqfnSExmE5ZbzfUxX3QTynFwXWj4Y08bpyGbJNx6Nj9wfSx4lEpQ9RJx22x4jaTcFSrB/n5zZdLiTKtkaoMRy2ZKyadbvUH5k4SzZoCTTWYyGNquUSqDEKnxTR0Zq6g62esIwPt1iOId5xvDdIXCwgsulZUMVIkQ0RUZJqtQ2va5NIVejpBVYZE3Y4u8BhpEu5QtGY6mkroCEuCrKGKNPRJilybVDu11/h1rUNdGCizFHdmIuluv42SuxBFVejE5643WN6QKCwom7LvSklmhzmR6G5nXKUFg53Ge0clTl7xaqFAJLHWUoZxh+OawleDhk4Zidf2LYbhk6UVcV1hqRZ1W6OyJir1Xgs56AzqUme7y3oQiF7m0Fl0Uk1arykrA9fUwC8JmiE6HqZWfmm06GTy1O97RIomk3U1ZjdGUhWseYuZFl9WB+SWgTEkTEKKOqczbcoiwfC8HqDZOSsU26HcCHtF2YMrq4GCXI2pdxGS0zKfgOUqSEOZ2XSO786wdZuy6vouVdFIvf9XF/0k2l7NkiZpD++pnQJ9YPErg7d4dLjHjwcv+MGPb7jZtJzMGk48k8vdklfX11yvLRb3ctyhyh/7+tfZ/6rKU2+A7YnFhcIu3PKj25TT0wvkbYItNaiO3HtwTQE5ksDKS8Kg5JOmZmibSF3BVNbRZImwCIgL4aPVsYW5ohM1nxIFB13Te8ez1JZkSU1rCypsR6XYpMWGtj1moMPYmVKGt9jljlLXKLR/uhbmbu7mbu7mX9W5qzjczd38/x49WvDpymR/ppP4GuHyilZ/zDv7Jp9/lqPKMeviE/adE6RUZ9lc4wrNXlkQivdMjkqVxSRZTbeRaI0EW3NJW4vX5zuSzRneYUedajTLhvZJQSup7NYbho5HEm9pmgq7EKC8hLa2+NknGUP9AEOLSIuGVfgFqqzyN//2Z7x9/2v8ka/l/PwSrKrkQHRYFXGxItOpFoqIiYtUa2tQBDW/+8NL0pc3HD+SsE9GqAxwFhHXu11/Qbfn6VRqS5EW1FmKbsq0rUern+O6BrK0jxaniKL6UDcIuzWKM+Lz1ZhvT2u6k0sGl2O0o5yD8Y6RPaVp0v69cN3K1OLCz7X5jnrN//v9igdVxf1HQ2RDp2pEllZc4qaYbcurq5j/5OOCb/5Rl9/4+gRjW9KeXaAlu3558hd+0vLb5yGHsoT7wEK/p/C16Qx5LPGie8XHu4C4ylHdjNA6QPokIrc3WENH9BOIbg3044xvNPdYFjrW6QWenSF/ZLDdP+Cg9FlYZ4zHb6LrKtJli1KmeKEN0ohOTmhuCorRNbq8j+m55FWOs9SwKod2pNARYSkeE8+jsbbEVk1WTtFLG0u+xTVcJNPi5mJNabpIjYmnd2De0qqHcLQhvJ4xixZsDiXkXzxHnz8jy5aMvtqyeXGNcf8rxB+dMmpHzPwhxuQx/qoj1hvUhUaSvUZ/IFPdvIumFNwbZ8SmhTXYoVqHNMoYWSt6rsaAnJk+QWonvQlOUhbI644Dq+PDXFgWElxRm76SMU4svu53vOhqzm596s2aJD/o5QIHb9nsryckTxueTE44DW7R7IqxqBN0Tc84E/y+OFvilFNqNSf0dui62Se4Ra270yUUUdURunhkxtVBb3nI5Yy2E8mJlLbSkBsNVZwZNAd9H8LcZGC8jT9QWO001usXvF6EfPB61aey1cNhr5dXuwHp34n5/a/8gm8Mjnnypx798pYJZVsySRrmhzaHk3080yaUxGJAJtVAV2RUM2V5XfPBaSA0lzzaNZR7HuqopsoF/T7FGQyZuD5p0vT9HI2IKJUJgo4ubMnuSzx+d8dkNuyj2Ns4JExbHCXmo/g1OAbPrCmO77JcLaG75u3j+9iKQ23FpMJNerZHbWlMDlTClYq2immkLXX7BvrwBkyXmXmI4dW0Ud5TXkeqMBHUrJuWbbGi6XIGtUuWSGz1FtupkLqArklo8JBbEf0X2DuTTA5opJyJqqJVCUETcp6kmL7OoTsmCktWUUntFsiSi6qZKL6Lla2JJRV1E5IPbJrbqmcomLZDrq7ZbSUGhy5dVaE7s/4WvQ4L0rghLhQUq6YQMA7BcFBTqjZFz3UQakYlRBXPIkUFXWMmFVhWy8TN0ZY116GobJSMhwYmLtczCfelSBZYXPsy28TFFC8Igrh6WFBEM8aygaOFfecsyxMq2UCpQwy9YaAplGXax2rKBFTvEMcVGpcc9CVV50DhUQtNpEwfyRf6HmFONZQKr1IxKDB0+sNuW4T98kgZmpheRbR1KZMMWXAkJjVHskbjCtCOgS6FSPoA08lobi262CETW2+lxRORq21E0wV9pUYXiyFDpokLnESlFo6JkcnMcTAUk3Ajc1ac4gtK67193OkAyzKRaMlEYqIU3+ggSzJu0/aGjyJpqaKcRNMJq5IrRCUDNmrIIlEZjCyO3hEAxg2zr97n16fH7A0cnE4lMbZcZpCennO6WFGtd3SJghEWqJaGJinolkLZNtR1jaEZfdStzEwcQVtEQDWVfnMtPLSBrFKK+k9bI3cpstFgaQq6sJoUwqASoskepWIzGA3wNYvbJCKuDRy5wzIy1s1rStfCiBuincvh/Xt377Pu5m7u5m7+kM1dKuFu/mXND/6+wuz+LV+8Sqn3P+D47BHJ4Yd4xgNmRxmauEyKdXbxkoG1x0g5RJc1FmXCVeaQkXHPHfPG1KesKy67BXK4QJwC7Ps6z44OkWWDLMhZ1bdkbcbt7efYskpjJOR+yqA5Jisi1E5nkkWkZxo/9r7Pg9GMTdlQZhI+Eo9H7/Pn/xOVw7HJvYfv4oiag2ygdg1l09IaMYZq9FCC9esLPn8eMopu8R8Lu4CBKqkslBKp9jjW4WXbsUngqa+g6iq5nOOMPOJkjV0dE7sx40hmJ1LLscp7tsnLscryqiatLrhpLOayS3V/i2OLBPQhV9EZI9sjK2MczWTg7/epZPPrCxanDb97pvPH/lzBvZMOWTJBbWk6iaxqOVNM/vR/d8Q7+xLyKkU9+z56dtZfVv0fvw9/5yOVfd1guBdyby/j4PCQyjE5qxp+vNLI8phDe0or7SFbEteHGeqiYqi4lB8nzJ9OsfYLijBh6ES8HypIQUMzOceSnrDev2DenLAzbhntNC4PJLyy6JMK5WYLowTjcAy6BHKInMIuG5HUQum+wZqYjNwpe47LxIE4sdksExIlIgstwtrGmVnUhUiFxzhCT9noRKsN1bXG6GBL/TClunE5O+2w5KbnBCjVGaUc08YVuTj7YaLtatJZjJ1eMX/wDcL0Ai03uUy7nu+m3bpUecm9ict04qMkHXZxjGtuKKSKPBmTyVeYlAxwicyE63FIpDXMFQNVi5GDllVhEl0XKF/pUMRSZTJgYqdsP1fJkgHp8oad5uE8mFA86pCyK26+aPlx4fLrRs390ROi8AbNHKBpBk0mcbFJmUxVJua4rzaouYbUKOS16PQrtALQKeyHushNiwWDiq6ZOLWP7EhkZc56ZaDpI44mFU0Z8WK14mvODqk5Zpts2F37RItLfCEgvFaRsxX2WCfz9oi/OOd/+/8wyd6Z8637v6Rlwtwo8SyP16pDE9WU6SWK1/GOO2LmjSi6lNfnV3zwmURylvc1hZemw7SrmA3BV49IigC5VTAkA2UvxheH0dynLgJWUcZuWRCFZ7TSHOXNlJ0uvshBrxgs9CHKTkVOZRbjBgrRnmpR8bmQN7wzUjC8E541AT+sRjThii0lQS6hFjXunkeoRBS7MXISkU7OOTHGOJLHaV0TqRWdOBRuawq1wzbEYbVj0WSsogKnqvAdGBseWmkT1nW/pZyoKYokEYQSaa5y2ewoheom27JxHZaLkKi8R2UYpGWLPSwwuiEM9jF3r5C0Z0TlBiO1UYR+s1WQbJsybFC4Zbvp6BQfTV3ThCVp2lEKwr+i9HAOXS9QaDCcCnU4Q9VG5NIKxahxpSmWqlKRsWlTyq1LE3f4/hC73LJMMtrKptFSNnGJbLd0scLnL2/wJzCdGVx2IWW9pWbAOpTRh3kPR4x2JoXSitc3HN/ANOaU7WmvghRqxX07QfEU6jyHyEOjQzXEjb5HIYn7cJkm2pLFGdpcI+sqmkxFV1NMs6TRO3KRWtjmBLKC5UhI0rDXG2YNHHYj3HGKU2sk0Yw0WPc2CBmHUlfQCsHUTDjYG2HvGayCADvyiaUJZrhFaipiEf2fDjhyXFx3RKd2tIFEcPOa37u4YHx6wuNnhzy+v8984PQ/1IRStKgq2rqlVeT+RksVPAeh8EkTXm1XXL3cYpQJ6VbjZtXw3jOff+vxb3DobNG8kWjnsd1dc1kuiV8mfBG8Qs8KXFWhFNUVL2WnBFSSiy5pNLbCsJP73lkpHMSmjS5gkopGI+ouqdCuFtSShoeOZWqUZUhZik3pDEc2aOUdtdkQrmZsuoo0krCkgi4LKVIdt6gwZsLUoiCJx1twM6ZDDLMi3f3ol/BW5G7u5m7u5g/f3KUS7uZu/umT/8qScamhX+uE24ilW/Zd84sPP8Y9UMk1FV83+0uPy0DqDycT28JXNSZzHUN3UYQ+XRRG1ZxjwQ1TG2RVEAsMqiYjS7c0msTR/X1qkZ5V454RUOUFh/pjttWmV40P1IfUswDDP+eTtGbqJOidhNsN+UenP+bDf/QmOznkf9MZ/Pn/+ZrJvXt9VTUTBjatwxHAx2bLiy8q/sFfXJDm1+x9JWQ8fkje6qyzHek2pSlKRgcOg6ChyBMk02OdloRZiSOnPcuqS/0ekp4Y4v2UhuYMsbSIY63G0+H9ZMsnpwte2wp/5u2vUKebHkK+ahuONZu8DKjqiFIxMOwp2v6ct4YbPvrbAf+3vSX/wz854tFEIxfU81oikk2e3S/wghrj5mfo0U+pAoWzzyL+/R9c8XvnBsfmkPsPR7z1DZPBaEgTW/xi/TkflRXlVYGjjQkFpLsEJ3Q5skKWJw2+dUI7a7gZ/IyHu0NUBX4yT4jObmnu58xVF4oM3t+x1N9k9OYFsjjPfeGRjX6KvTejvZVg6zBtJKSjZyT6mrBZUCevcaUJReGQ7ba4xpB0Ii47V9SZjzqxOBzE3NxkxO2ayL/F+ewQ3phxu/scdTlD1RWqqUYbLdE/+hpje8niiUd3c4kyG6LNJNqzlEH9JtGxQXM7Raor6luVZu8d1totni8RF7GIIpMlE9K1hTy/RlEbPtwDdWmidUvmnYpkeCjuFkUXyROPUhcX4yWzNTxVVaKmImltbMMhW7XM313x9nDOVq3Z2Qb3tx4/f3tF+IMDDvdbJgfnuPFDkpe3FEdbqvUD0u6Wsf0QSZKR7TFNXVBUNUmdUDQhRTVA6cbokdsDRKsq7xPuZdthGDryUKaxCrRM7y9LyypFkoUSshf+MVGFOj5AkYc4tkSVp0TJA3Ii9IGC3xRojRANxGzu5+z5D2mE+SG6Zf47Tzmf3PB//g8N/pe/8csCMD44Rlk1vDVQiNIcKarY2/NRZZd1s+D8ckWykZmIm89BjmE8wLZjnCqBdoCtiQO5xErW2Oo6E2WMYqXgRDzVVXzN53MaFkHM7TrkfmQwG7vUTkarpGhFjD04ZmsKAF6ApEpY6zG2oVJtEhpHbGkyfrqLKWqLqbiVv1bQBjqKUtJJJlUTM3EsOr0l2bS8ijfsD6YcSQmm7LJVCqKuZMoczym47SqynYyeNLS5ilxbpG7YpyzCeEJpq8hOTl0obDbCzfiSLHM4X2Qo1YC4LHm9LGm31308XdVASUvkQUAdmXTNY2r3NeoipzHmyE2BY6aYgdzDYqR4Rl23KL5E04gtnUldLvoXZUepMGqNRpvSCgeqnmJWBoq49hcW37ClHMqczMa9gqa80FndbvvHe6BZ7E8cbjPxeNdkODRFiyzsCbZ4kVgx4D1otuSVSRw53BY5s/01eimu5R08v0Qzd6jtPsUKruQM1RliSG2/tVXEhyFJpPUUXSsxOh2pVWnrmlwRklCQyhK7afFKCy1rkJUEydBRtTlmmRI1G9rG6usgalWTGxLoG9xoQOzlzNJn5OoK196waA5Rmgx3rqPGBcljlbycowm4ohygftHQNS3WcYaUjVGlpoeWjCyYTT1SuaVqNRQ7RDGELQI2t2t2Ycbn6wUPDoa8Nd1nOp2i2g6N3EHbUldZv+BwxKG/rjgNBA24RelaTLVmNJzwjaMTFE8mSlXOX33ORZNxu44ZGybFpmKgK9RikaApdFpNpbhIWoqdqzQO1Lp4sCwhqKRrUppGFF8kEdKDUO4VnWknNucKlhHj6RVlKVN1MmZV0YlYny7MtA2ltmYTpOxWCooRY8kldeljygNU5YxCeYSsd2TpDhYphvhcnTtmwt3czd3czd3czb+u8+88O+T0NuWNSmV3/IDqZkC9ZyIbN8iyiayp1E2Famr4xCjXDe1eR2M3vFJfYYUKxQKquuPh/IDxaEJWp1wEMXW5Ymy1/QWJqNFGZYgimaiGQ9sKaPSITbxiHYt6gzjPfoFcPEE5krivTFlet3hjnWV4zgc/eoel9jF79oj3f++U/+j+Ef/2f9PgrcMDdMWjE2hCecMnH6v8e3/+xzxrr3m4N6OoZ/1NbllEvFw3XF5X7A87PKlhMupQ5AG6bqAEHVLZoQ7EEkBh3cac1PuY44LEyfCsgqLtuKgj5vdPOBwfcbtyqIcZ10HN/nRMtgyRDYd6r0TRdIx1gD6wWWULJtYMSVL45pMb/sLfj/lr1mP+23/cYjRQ6FRD+MgYpBHO9e9jlr+HnA748PvH/J9+UvDxTpy9p7zxtsfhexLWXkt6I/HDpuEzt8DelDh0xJspytMV6m7FxkrYU/d7FaIuR2zcnzO5HDDy5pROjXseYp3cw3tjjNqeUoQdstFSmT9nUT5Cv3iOemxix/tsLRvFE7aLnEW2wdFiqkVAK9sk1ZxSSlCkIVYzoNxeUwrivNyhFx2mraC0O1pFws7fxksWSEpJ8GrMhBNqM6VkgjlIUNNHyNkZ8nc77L/+Bt10Q3mzY+0MIDzh7MmK0Y88pMGO7jd9qve3aLOPERS2UN5DzUvazOmhhY2xxTlcc949hRcJbtLhKBbKVGYX1f3CwJ01dDo4jca4ytjmBb9oD4hVOHi2Rrdi5rsJJFvONJvZRHAkAvLUZXYrIJUfIwc6TaPyc8XlQb4jbxM+HLl829hwPDgkrWJUSQFV57l82VsxdrWPF9UkYUSmFuJoh6kLG5yKyMarmta3ArTOoBMwf7tFT/QeFlnnAtq+o1IzdIbolo1RqLSbNblfIEk6M2mPnymv2Soa86ZFS/aIdxLN93bE/2mJ960Ns88K4r9awl/4JS0TwiTuP1llPCOzdW62W5xNTqStMRYlq3DbE1OV2R5T0Z2SriGRwfIoiwpLabEkE3EuUpIdm2XTMwqsiYbeFqhqhnNYMx6M0QeQqDAyE6bsUagaaiLjDXVGfsGqMumCjsLZ9ADHRA75+aVMFl/hTL7Br7fwj/TPOBwNmAdDTFMmFKwB0yBORR9/TTmeokUhH6YJllCbbLak9Y5EUbgtVUaJhlfQv3AkqLT9rXCFW4o4vkkpb9lmoqOl0aU7vFIjje5RNSEvz12SJMVIa+rhAVVxRt2ZPaSjPmzpggDvesn6oERd7FGONORtjGxXBKFFbZ4huyrd4BA5vEQ2RpTxC2pp1FstJDUlLx1hskHWEywMytagkju6rICoQddLZGPLNq6Z+fsc+GPkScJ5rmIVKY/2p3h2IRoQFF2IXrjEUk3uDdHLksty1YNpBvtzVq91TOUGxTphUWiMZwqS2dAWFes4pExN6rZiYmV9pD8TGh9kuqhF6nY0ukYuIvcp6LrFwDJ6R+pWqIDFC9xQSFXEMwOatiKpLpG9lmFlUonlgmKj5Bm2khLUI0JFwdnccEVGM8zZawZ9JYBGpxDJFy/C2424rTuM9IqRo3N1cAJcUHYFhqXA1qMbORzvPcU3crZFRbUzkMSCRs56xoI1HkDcEDwPeP98yXPtNSf79/n62485OZkiOTpxp1FFEWVWcxVtuX3+OfplR1PmmEdjvvbmGMmb80/Wr7m9XjHNC0YCoOPqkFVYwxavEsaJBkOTqDQJvRJb6geU5gq5VrAKmYSSTjeQtAonyShxkbqOrEj6aoWUt9hSSVqKzaOG1BZQtezanFJOEVDYFo+izVAoGc8EvTfpUymjfZdMwGiihKgTWqWCzpTRa9CcCVYfqbqbu7mbu7mbPyxzV3G4m3+Z47r7vKvl/MS54k3nEOdEKM4tPt2csS7EZVjyJdepqdHUhs0ooV5V1HrFk8OHKLrC7fAa0c1V5Iy0CHpDlZqGGEJbrep0qtSnMa+CJXVnM3c0kJRe8123JY7UoEgV5WjIdXiNejlmOKl4HXRcplu+SF5iZy6+VfXAxIG7IfpbHv/BwTX/3p+FI+cRiybmJ9crzv+vl/ymuSI/MSiPGsHqp0tLNmHLy88bxkXK/ZmB1XdvVQbOpE9d1MYVQ63DbceYeQXCOqauyawMdSnYBj6eaeI0Cr9wIvwqYj5Q+EW94PLQ5G3rLW5HK+xfzDh/o+KxvYfq7eHYA8zKQpEEkNEheVzwP5js+Iv/9884HsK/8Wt7eMZEMPcIMhfpdUvLfRbnHv+Xz2JexAXvHamM3tPYe2AT+jUfvlbZnjYsD87Zz4wefq4Mhz1fK5MH7HRRL+9YTzNSO6d4OWd+M0Z1NVorJksdLFYM9QpvJdPO9xipJuE9jYl8zcv3ZXi35enFGO/hPkn0AVajs3NrMreiPJ9SVRa2m6D7AW2gYLSnNOIxb12s1yr+3ETfD9lWDVGm9AuG9kVCoUdU1gHG+JbFQsdNJfL5DutUJt675g3rgNjzyO0tza/qVH9gMfrJGP6ESvX5S4rvhTQv1zirA2plhL+rkbKQXbqgnY1449CgCEPC3MVdfBV9EENroxcRiiP1dW1DLfuLxXq7pBmZhN2kPwcKXIG9vEFtFR4ZPpWp8uGDBeGm4fE25tPtMd70hk21IfQ97EOfe88l0lZGt0LG3ZDIHvOd4rpPRcuKjCO7pFXCLlkzrCquI5vE9KmlLUEqs6oHHPommtpiGSauaSKbEhoSpSq8lk0P1tcZIysKn55tCeoxbxzpGN6AXR7RSA6x67M3TllKF5y9CPisuEbuXLSvTXnijVgFGe3HHcp37pN1BeVFieUN/qmvD//MywQjnKPPFXR1iNUFvY7wdKmxF+1YdHOs48dMzZLdbklnNAyZo/oWelVgS7cU1Zhlp1BoK5ogJV0paKbMIOl5/aR1jGK5+NN95t2WkepiyHBriEpFjNTFbNMjFKXAVkukZojCmra9z/1gzqIJqdV7/OpezTJVUa/eJHi9ZaIZiOO2pl6hK614RSQt9zBbD2kk42cRQRGS1hVq42EKuKJ0RVaYpK3YGhY4uYW8GZIIJaa/xsFjqow5sGXOcpl1UtGYUIU3vLxMyFYVkhbTNRWSFGNYFlVo0+kV0lVL570FsuiLlcjaZ6jRAN0dUpWCFlugOyq0RyTKEsoGs5EYdo+JqoLMEBtNiTqLyIKMRqhArANEdyARiwQRok8rbFcjsRV2Zcwg+IT9+YST4zHN7Ya01sibjLGIzjs6oZyQLhsUS8bdC1i9P8SwXNJ8yHQScHV+Siy5mGlDGi5wzIpu74SomqCLbypx625neJMJWjigWxXcpDmq/SmyNWTQHVGVMjlbrCplXxphiXSIBp5Z45ohbSr4CR2NKiG3Pt2luEdfUKsRvj+msxSkQseXBbF0wy4UPt+cg3xMJRds8lOcyGBg5BSWR5isqWxxBJ/iDhMkKYXMQzFr8nCI1GhMrT0m45LMdPvYf23EqOIblJJCzsEVPIYGa3NLrQpPq8sXpy+5OQt4+t6Qrz+6hzUdM3UcwiZlt4iobiWMLKfTdIYnAx7OZsTxLfHVigMhru00UhO8riOm6isJkV72C6FdXvcAxJvURFfEZl5EmjTyrEQ1ZAIzQ5FcBuMBA1kh7lbc7lLKSsG1TIzaoK1KEl0sDDI0yaRRwNMalNahbKN+C3w4tKlKnZtsSJ2NYdeCsoV9Gy5ktELDbu+hnKy/7OnFz/5534fczd3czd38oZu7isPd3M0/20TJhvjsmvDZhk9++BbOyQ1T0+ON2VeIix27K0HAMskeiy75IfnqmqsqRk+snlmm3Vex3TFpYXGxitG1DNtSKDqJVpi8/JjWikgXJsk2RC1aTjWNeFGwGzQUbsKvT2cs6w697phoNs2g5DbI+FzScZtzKH8Vx1qQlTY4Aur3jL//cs2j3/3H/B++5/A/y77CP/445i//9g/4Bnvsfe8+oZqAovHFJxVNFTJx4ZkU0fhHxKrJZrHFUjVGVkshdgdxzsyzGUwmxFbFRW1SGCZvtzKnZsQ63NB0Do8OC+xE4guEZivl2yuHderxO9rnTJoZv/FHdC6+yHHecJjOPuG2VIjCAZKnoGBSdzKDk3v8956+5j/+u2u6cca/+baKrA344PfPOPioID6H/93rnMuDnDfetRjtjTh+PKZuGj7/aM3HdcfeoOFoV7BGIzVKitGSwVTBeKkitUZvRbuOXuFG99i9+3fQVu+S/7jji//q52TDPayP90jzG4wxdLlJep3DcEhg6Nx77yXhi0MCXWIZvCazHCIjorkZYGkemtVQFwnJKMARFY4kJdsOSCUfqWnJltckWcssn5GfF1wnAgoZYNoaqVah6BuyMABnwm6zRlu5fTrhPSxeicf3eUzhl6gvhaHsPuv2Y3jtkTcz3pEjPiuf4P9EpfutkPVtTlCMCC/2cN/5OYnxmGK9I0kN4qHKr5TifbywyXkU+ZKpNWU00Kn8G0LbQZdndMIRquYIV+h6qtNpYX/5HCUxjS2zd/VVNl9fo79Ysy4yHndyv6T5UHH5xY3ERMr4LVNi9W8vuX++z21hMNLhzHjFdDflvP4Cq7B4famxuSp4650bnOGMxS5jPnLxTaNPJqC0SErXQ9VVrUEXbDxxdhKwfa1h3/TxPJMilxh4Zc+JuDhb0sYpe5JKsm2wN0s+OR/QdU94dv+SoKtYD3bUjzOU368YODFVrhM9bDCE1u+XtUz4+ItPcIuQr2kd76oWjw5O+Ol1TOV3jPe7HmiSdTLlzmW3VsiqKwa6hTseE5QOSDVjo0JxDDJVxi1l0jQhjDco3pTJ/TGaXNAU52DWJIrEOPPR6xCrmBL7EkG5Y76RiEYiKr9Gq2yK6JIzr0FLJuj7Bh8vf8y2HjEpDog7qEcB+UilW/tIW5W2OkXWTaRARlckSsfESWVaTafMJRTdRXd8JNuFdN1TPAuhsSFBqlK0VCgtRWRHIQhz2rbEF8sKW6QEJHahAuMNWqmSagFKvE+argnlugcgaqIfVEioM41xZJPLIwxZp6xuUMYD8sxGKgx07xYlyikdlVIOGXozJPKef2CHe5RWiKy5KJUA8zWojY4etsjiMGwM6NoSM1LRZZc6S9jUO/LZDEsxUaoNydmIxnKJ6x1RGxGEKnrsMFEnfO1ezsfJh9SDE2b1jHtPI774RCcMr8nzhrjzef55hDmcsjdQyOO2h6lMZi5dHaGIBIA8RJEPMa0pcqFQmRsaR6cqPdZxgaXk/denKgbouUZUpz13wzIbFFujVmSq3RTZ36HXGrtdSiXJRHGG7OoofotWBOSVyzoX2pwttveEtCt6Lyxqhal5tFmB57v4nsIqqMGe939Ga2hM7iuoA5U0j2nEfk8uKZsYRR1jStBcn1IJY4b5Bkobo4iUhS+xu7zmH1+c8cGDKw6f3OdtkT7Yhby4XEGwpVVHSGOZr753j7rqeL6NsZIEzxVVGoEbSsjlIZphUmcStdpR1Aa+ntCpGb4nkZcVeQGN/5IumZPXLnKQYokEhjfpUz3lhUHSWNj6Gk0rMOz9PqKlbWMy3UOyLbSuxFYr0jQjrFIGaktVGMSZgqJ5fQWlFsDHYQXdBGf0KbrsMxm/pDMeg7mkngZ377fu5m7u5m7+kMxdKuFu/mVPTkuz79P+SMe/t2LzBxaLWUD8NEKuCz66dnhzv8RY1kgjhbp2OBwJU7XEKqmwb0s0LUKRa0xzxlQAB40Mx8kwVJ1a1Eajkm0Skmzd/gAv4Nrp/YroQkd/pfL939zwR7wDVrsFQX2MkbziZrNi7+oYlT02JwlXg4L6Ys7s+JbV9u8S/cqc5IsDkh+c8Rd/lPPb1y95mhzxj6cqb0drnh7f41VqUe9esWlyambMHmvo/pqXK4+rXYJmxTBSeewMOfBtLE8m9APWWsZoLaGrOxRJmMZukCSDtZbww/GOk/WMIuqIrk2a4xpDkOlnPs1K5pNlzuOtjuF4pMl3kIqI0bBjvb0hGSccOAdcWWcY36j5E7//Md//KyVv+h9xqz/lL/3dv0z9Qcrr0TE7qeK9yOFrT10Ono77m/Z/9Okpn8kX2M80VsWMJPHBT1B9k3uxQVCnNGlJbCkEO4vudkDnJzi7Pb64+pys0OnOZR4ZO7ZnFdknMYd/xsE7e8pi/Bw3aXC9FRox8/vHnB/s+NaNyjYc8tliy80ywX6mIDkFUn5CfGYRT68YpnNCp8aSz2lyj1jyMa8z4jxFNWWM6QhHAOiLS7TlACk1wN+h3hTo9kNqE/zDH3EhvUd0EWB7xzjy+5SX97FePKf6NRstWvDm/bdRLBi9PSX+QctArzm/yKnf/hTbd7A2Hv7MY7uOsA5Mom3IeazDMdjOmDRPWWq3ZPoeee5TkaCJ5/BapBJqPLXhTVcmEQnmNEQuhsIrj/n2mmFYsshaFGXEq8LkZRSSG8+pG5c//dV7GO9Z6Fcqhenw9lsqiqbirIQJL2bEhEKKuLyXMdn+F3wRpF4DPxr4/d9iYdBPJ74nT9EkC1M6QBbMESVFkhxsTUWd16SxTLgx+XGs8feaJbNNi1SZTIuOsptzk98QnsZo+8c0zQbjw5yJUrM1HJQC3nx4jP12R/tj95e3TBi+Medd74jpRMIIh+gDg3dtH31kM3aWXC8a4k3NMjLYLj/Cku+jHddk1QK9EnGjAyaW3LteK0nh1A65PdshGzmPj1PGwzlZ63CZXrItLRTPYdAoGJVM0SSMxzKD/RK/us86Clk0S4rSYiCbpFKEUoSEwRnr0QFGanAmJfi6ge5LHMkJX/gZTtAS5Q9R5A3p1OY2jXvDwGyaorUNO8nEkA3kesNqE1LrLqgm2FsGmonGqO/dS1FEmIcsKwlTlTgcW0ihwuZq2atntLakUzXs5ZhE0FHdmlFyhjx5F11sWisokzmWtaVZlsTVBlN30XYiov8aU/hcdz5IQ7R6Q52v2aoubetiC2uDEaMUGpLqgFuhyCHOwEQe3yNcLqmrGGssDpMbim6N1g5goRGVAbkgwqQ5y2bNTE/wVZ0m8dgVOQMz4yL0UWcvCbdDjHzI5uEGuzGQRzZdF/Q+4PW6Ze+xy3uPaqq25pM85aR5jHLjEIo+W9Ex7mK+srdP2e24yWc4EkxkGVNoYJqE2zRgtajQC9AnOqpTIrcGdqnjOhKpK6opkO4Unsfi84iwWgt7oFM3HkqXsK5qitlnlOU9bP2EbfYSv97DOR6gVDOKdUyp3ZDGHZ2h0fkZStTRqmDnMoe2RCMIwE2HljaoqkYnqKg926Gi7UZgKKCtyeuSwneQaTFEvaSeUVxFfHH1C84/tlDVhvSypY0cYh+OHxzyruqRJQmRIOLaFmmloyk1mTTBiXdkPnSyTRs0aNUS2fKJM5VK6cjljjpzUDsTIQfNmxKtlPrnlZRskWKVOC+Q5BxTGVMjEgovKSqHDT5NE+CnGV7ns5EVbosMsynJVJUdDaQBc6FBte+RT3PIXqHUc9rYo/DnxKHLySykMGeM03+u9yB3czd3czd/6OYulXA3d/PPPtcnO5YfrPijX31Gkq6ID0zCGxGKVbDsgj3DZZGmPHQVtptTkqiis1VUw+C+JSDiEtssBMVgLvTguwXS2OBgdELbNORlTpxv0PSU2VHJchNwU06wmh1Da8vOPmN+/YDLeUFYtLTFCz6ctCSvZiye/xOkd/9b/JHv/pynhxH/8K9PefH+RzzWvkm6hfDwFd/56Fu0ZsO/8+vP0HcKW6NCtmQ2RUR1fQVNzAklh4cpL6Y5cqHx9kxi4hhIxohjY0JeNkimQSEg1hcR5UoibFQeTXQy8T7YnlC1DVVrI9+2/MOjc8xLnebFEdurF0zu2bzzyqewC15NP2XfOWAbXSGZIZoyotB+hqk+wo+nGKbBfnBAICXI37jm/mnBf/C//yFa9j55JrO1Wo64ZfQIDt/Z5/CRyofJJ/zu1Yq81RibHt61g5errKcBWzPgcOMylvZ7veYHj1coFxNq52PU4bsYo5rxzYZX39Qp6i2zT98gQUHSa8yjAvv6kHHwC6pBCu4Tpr4HhTBzLPBuDWLpjPzJE6TzMcbbOfnrlHh6wOTpLZNFS7R9xlq+oStDKkmA3yUMK0fVNWTVwigVtDYiL6+pl8dUOwlp1FAkCV06QR7/grp7SJ5/i2b0HK95SlPGdHyN7IsI91sT1E3Mw197xh/ff0byYcD/a/QPkA+/TpYuMR+foJRPaNXP2D+bcJt3TG2Lh+6IQN4nfHiNt81p7JjpfEYpzWnKK0xxLrzUSMMLIlvCkWbcShUxu56NtzJTDlsde7vkg4uSPeeAxw8kAlFbbmqcMORE2Ydfcxm84bPOcnRtiNMWfLI8xnt8xVdUm7pKMRWfjSYxuyyxj3dsm4by9Irhr9zvzyJhHKM7BnIroSkqciJS6TJtV6DqLUYr4Ot1D5+nEY+dQpoUvKlq+MM93r9e91fjY8/lIu9QnBnjt27ppBV6p9G8cvjcvMZJFaTvQhxs0WILOal/ecuEt57Y6MLNaosedswoljmyHFbdDetggqMMkds1ptMwVe71v88ejcmFo9SUsdWMTG7QTBNbS/DDEEOrKGWHRhyA1mtuDAPDG/OGEeOMU9xcx8wkGs1i3neKSoJlyFrAMxIJdyhjVIKD59J4OXN7TB1q7Ls2lfKKZO2R18f8IlwzSHxSdUfonaEEJgf6Bn8QUUlzNM3C1FSMYUZbJwSlxLyZMtYdlpVOF8zYa00SreCiSrkVusRSaDGFK7emVoThQOZK3CZ3txiZTZluKS2Xug6w2gzJvY8zP0O1j5DWKqvFayiukR48QL+0sUUsS5gBwm+gT28pPB1Da6nKI7TgliJaoA0nKMG035I1UoHUhTSxRJkVVFJMN9vSiQNvopEuIlpTwfA1vEHHcCJu+y1ceYw/1LitVLIiZban4w9kynWOoxrsj16zqB6w7+8opq9ZRA6DcoqsnVLufLw8phBPwsanFl2lwkG2PfLqhkspYLkGpdapdIVLZdsvmATQxhhLdE3EopRpY5ADF1uqUfwK1QLVEbF+oe7RsY0cOQ25zCyyyEBXr7B9H00fo2hiubFFdvdpmwg9+RpzgUCoX1DykKHviZICWamTTUREyud6tSa9ukUSj1MTUclz9AOJBTlzx6bcaX06AKlBaoQ7OAXZhoHVQxa7tEYVkMimojNydEtFqmtKc4S62BJ+saFwVDp5yOEbI958NuWNb+2jeENurhfoeU6nmyi2aA0I1kGO5nmEnYLdlF9GlmSZstBJ6hRHvEgUot9UkKQOplLRSQIA01CmEk0r6MZQpClGBJ2jUHcdRW72u497w5q8EAuFAqyQOqnRMkFStiklsXxakyoSV4KiXJ2x79l07YSwTMgSUUXK2L/fkdUVReiSeubde667uZu7uZu7uZt/TUd+XvHd2dt8drHi8N4ee09uuJluSIsDXgYLyljmq09ACnSuHmqMXA0p66jLknNWfeXYNwyQDaIipKIkkyI2VcoJhwJLAK2F7/nUs3NyeUqYdriaij6eEKpP8eUNVVghR/DyIoBXDwk/+YDR19/g3/jm5+zZEe7T30T7rRf8nb/yWyzyM0btEeHuAX+vCvlz7zxDkQu21ilz80FPuxeA8tGk5rS5h+YEtIMOPZS4khfkksKR4bOv69h+R6LWRK8lkrDB6wrqsqGpXaqJ2qd/Dy5UgqHGF/oZqSQzNDvGhYsxSXk1sQm2Nj9+8zVvX36Dl9I5X0lsLtQ1D0aHrPMVhvSMtkoxRhJR8zuo9TvoA5FIPUYToMRzBWd9SzIbsLSmqFXL7HsWD8Yb2mXDVW1gmAfI3bBfUpTuAmX8EL+aU21VzI2N9gZs847Zc4Wtu8JeHSBpG2rHo6vg4Pem2FOTK/mcgX4IL2Nx/KRizenTW0aLr6H/omUx/QRd+U32mhHuqGKdPqK8XDP/ukP6E6G9r3EdwS3QSbyObn6DsxxTrkRteUM7uKHzfQx9jFykSG4Ko4piPYSwxZDSHm6vrA4Z2iqbpYM7ixjVJcGlQSJdUnop9e4r8LBkuNL5zje+hjQY8RPptymLb+FkTym6C9ofaWT3P8W//Tqu5rG1VQyj5nZoMnYlRpXAWh6AcsOeNSM0txRtyzjxaPOabqAwPbCJIlEZqNEUmwPDRi8b1smUpSJxfaFzdrUikj1mkcv4exXyVCZUBoSWynCwQ7MesTfRWH8WoY0dppNP+Obw61zcnKKLJI5m4SoqD+WMF9cKP/5pw943I/5s+JBMz4XMA0PXkBRB+JDQVBU0sbxq0NsSVTZpJQMqgbhvqP0MnBQv1ZCDY1I/pbYzBo7CuXyFHTfM7r9Bsa3JzYb97w4Y3244DTycW4MPthnDkyW7Umjof0nLBMHHq9w1bWbAtcaNc8MI0bk2ULcRhjkh8Vumbsljeb+vB1RK3IP2qlhG6hRmzrCnyje5jpwUaHqOpXjoqo0yFJTMglorUVwDW7bIyOkqrSf5h+cR11bCtquRtiV67dDepGgjhdRSkJWAON5DaVdcaAVZ4WKNJKxcgARV2tIiVAs8JApRo5A0JGvGvB1SGQlxV3JivInrZ8RJSnIrfKk1TaNQ2RE30pYy6KjbGkut8aSSZWlj4vXcgi4T8MCSrrAprJLWHFJd10iqqAMMaCcu+rBGF3CLZMjIjrDH90miAMmY0rQZ2qxiu9nh1HsYjdgyyTScU3ljwmaHtt2hlgVZJ2L9w34z1aRbiq6jHQjav9rDHQVksJZ1mtygG/kow2nPUKirgCBZkUo2VhOzMwyS7QB3lKHPNiyVOU5uoBsayBZqYmIJwucwZeDsEe4ukOc6ZjOiVFNWkWBB6OhByrpTKWqbsnNxHQW53ZJHTq96LItb1rcWa0dFtSs8q6POI0pJZzDR0DSFMttHJUczak43FstwRR43OHKLOhxSiAO2nNHkFvUoIg5v8VWFrb5BVQvy1iVcfMTV9C1Md9f3tCRlSLBYs3zREisltjWnrjUMu8LcPiA6b5DzGk2WUepWuA6QPK2//VdrGU1J+ht+YZjAG9MIVUxk0uQKbRXTZDKp5JEdexy/MeWPP5nw7PAJtmczmvhUXcnqaslrwZ7QA+pG1BcK8WpAVnvo5bq3QRS2Q+c6UCUYVUNbFTS1hG7UmMWaUtWQ66rXQRamILdKGGrFQOhLpwoVUDUNpldjCsBKJrEWJNccSAyWgbCSfMa9fRPLvIdpPaZNNgRxiC8qH7lJbbcoTYDmDrCMmqaouBHJoEzncLr953wbcjd3czd3cze/jLmrONzN/z9mfAbV44D1fXGDq6FaPt/zp0RpyJH3hNZJsRqDStGY7kosS0eAzzxzTFHlGLKGoVlExbbnQZmeyVCSiVcxgbNDHo85LxeMwoJtdo+0sXhoXxLvq+iXMr53zW4UwfMRYRNz/oGNNY/49q9NcP/MU6zw+/jxf4UwzvH/1CWHNx7n3/cIByF7C52r1xn504rNfMFedEJb1v1i44OPdYauyhP3Fmcwomlz7LRkms0ppJrKb1m3OWm44WA8YVcOubyNUO5VRIJrsB7SkglbPYuu6OupjidzvB2yjT1Wekm61zJxC5RuD33bEo9TlMjieXTG5smMaRqxfH3JdG/CYLilqH309TtExim++ha1JOObQx4ettxoFdM85SuVjyJdca+ZoiYDfmdzxnUH2qSirpa44THVxiFMznCtCTPjAPck46PyFZowwM0HtJuAqJVIFI03bm7YjncY/j7tssCTPYrbLUUpLhz3cCqZ9xZFb397f7alMaaU5X/O8YPHLDch15LBu4XL+sTFt3cUa5vl63MeHN8nNSJ27S3DgUMdSzRJjr42aEwZc55juQ1dbNFsJlhyTVembNUrak6QrXsU+i2N0WKrQyIV5NBEnkxQ/ecMs4J2DNbE4OOvnqJ+WHHeHHK/DtieprTdkDp+jbSak48/ZnBvDsqUfaXhmdLyoio5KVsSe8XF3KYsK9SFjadpbGZXrOuCk/KEanXIbZTg2DvGkuBNdMT1DUY3QNwJetaKhw8mXD8/52crn0eX93l2VOFYHa0z4NBUe+uCvLUp7JgqVJl9a0q5a9DVAbfRa9709gg3r/hJ1rL8tGZ5vaT5ZMrvfOs535NO2BOXuFWNrmvUXUMnt1+e+1KNpJLRzISeGImNrNQ4coPSuGRKxloPKBuDOR2j0mJ8rfPBsCP+icTkqQL7Um9SLPIZ49/qkH+8ZjjcJ0xM1HT1y1smxIHYCLmMy5I0H/DpiwjLv2Y6sdhut0Q3n7PQG77+jceMfJ84yDByFa1oiWqJTmuJ9Q67KmmSFY0mM5nuofk11ljCNRomE+HtFLGNHC+SMGqZ1Ie6qQnzFXW+Qu0MRobGVmkoZIGtcynbEKnuqNwKSajysg4zN2mtmrhcIKsn/QKgiyUqtcJWVSpHxpfsnpmQRxlJrPHC/IiJaVGoAxJ/TavmtLFOnSfIek5rGBSCwNJYhLjofspcaFdLlXW1pGxk7FSldux+waA2FZVuIQ+FziVE2g3oqoDUOUfZzgk6hamrUYnDX7egq8foukJQhyi6RmVpaLmPrKj4O52m20EnQI3X/eOp27Oe/2C3ElInVCc1miYOgx11k9EkNVUISVzDpMVRFXa3CqEt48006lcZxdEGqRScAxmtXlF2KlPXp7AC1pn4xl/S1j6j1GQjadgigeJVpGTsrvboophUaWmkAFVWmCiQ2zZBozPUdQ7UiteNxTY0GEg1+6og1Sos5Ra31TnRhawl4/lqy2uxqFIU0nJBI2n4To7S/3qKkq5JbSi1lOFugiZ0nYI54u4IpJo0e8rQD+nqBd2qg3jQa2ZWG7HUuEYpp5ReTG1UWNUBnROQRh2dJLNvWyiWSW3K/XZdrxIaQ6JRdbR23Ossu12MLioHpkmh56JYRfvsmKcPfP7kyZiTk/soho4itRRlTphneI7OdDKju7wkalQUSaXUhZ0CnCok6DpKfw7LFYaaIisSwqmZFB21iDE0DXK3RhWJFbvrmRPCT6MJKUxVUXZbmspFkTom1gipEjHCjHUeU9UqKCZNu+F4FFP7Pk3rozcSficzHDd4soln2SLnQl3sMMUPfz9DTX2aRCOr1zR7GeuV9M/7PuRu7uZu7uYPVcVBHMrvqg53czf/bPOTUue75Wc8SO9zdtQwUj4nfP4ebS5u6GXGpc4iT7jWHdRWZtw1vPP0hFoqURWZMk2Ikw2ZVEOrUQntudxQ5zOyeshYTZgaBrcCtvgyJK4XbE2Fe6uOvChxtybnVxLqa4XNoUZ8z2RWnPL03W9zks0Jk1/jOlyQDmGc1nznWcOLly1cvE+V/jp1bnF28QPe0H+TXOjiSUh2W9Rwn1BfkzwVt68yy1uJqDPwkXk8schOas42Fif1EEsdMB51vf1Lry32ZWidW7jwOHAdMrdEF+eLcoBu5my1qz62/l78jKuy5MXwNd97ZdMchHy1cbh4dMPg0wE7f8NgMGC3WzFWv4Lm2TDrMCqDqpQoO1EDrum6mtI3sJQBikieagarPOeLQGHXHjERxYSkpHBaWqMiWZeEWk0zumabv6K+HmDlWp/qvq1ygotr6ukbHB+GKF7Cye5XODev0aMJze0tj+Yd+YMxm+YLFGtO1My5qWK+erTj41jBrp+wXW3BHtMkGz5pPeJPzhj4CYffM8nOQb29ZDqbYMr3mGotK2NLLCm4Y58wUslTmenQxZXEuXFJIjXEI4P2WqKrUuTRRwQvcwZv7KPJIcgDNnrIw5Ew6J1wcHxNNj7EauY8ev2an19cUW8DbtpTJP0eyTLDfCelfTlGVyfIzYhRdM1WGvJh49E9WrFo54SBipZHnN3f8FA9JNUTNq2LvxmwigPObjLqWOXNN1zMYUsRiffzM2o9IhVQ9+GEkWeQJzFSYFKud+weJezJA948eczt9pLr9xWk+wssTebe3gHDfExohJxemMynA27LV7xMRD36Y6KNzMHxmsULlavfnyL/hmB1ODRt01/2iVEVncoU2vu6P8xrmtf/+6atkRXQWwNZqWi0AHFgyrSA1cTlrdzFtFumo5TBt3ySUkJ9oXO9rBnv7YhPA1TpqxTmK0xmlPvpL2+ZsN0qHNZSvxU6vfyEy898tt4NnVVhJR1FrPUbricjKGcJYdvRdGB1ck8WFWR5RfhJ5Y4k01mlEY1SMjAtHFf0+4ekUo5NhqHoqF6NUyjYpo6rSwRZQZjJyBmEcsfeZEbRrhhpFoYigHMT9swZ+8MxHwVbyDLqTGFRWRy4EbFX4uiPsbWWrNEZVyO0bI1clHS1z1SrqNucTQmTrkUSiQRXx7MkNomN2k4YYKDI1xRRxC6RKSqVRR6zXdRcbndIRkO5lyK1HkoQI/nidl8iXQUYD+r/D3t/9mtblp35Yb855+qb3Z72ttFnz2QxWWQ1gmSVYcEF+dGw3/yXGX4wYL/4xX4wDBmWXCW4JLNksphNMTMyuhtxm9PtfvXNnNOY61KAIcNWAUybyeIZgUQEMu69cfbea669xhjf9/uw2zkmA1Wv8EKPcdhB5iZIJXK2xLQN3nA+gW4CWdFuOnzbYeWRyiYEZcwY3kzADVM01ON3+OGasezpbUUQX+M1GU11gFxMaRrjKNi8PTELPM5X0Ac+faeJTjHL1UhzCFGtmUCAfXSkl0tK4xO2OVdG086eU2wtXvQNi4uAXgvyqMMbl9NWPvBGQj24cSixPyKSYYKysBXoqKBN+imiJw998iwmzFqCKMA2EXe7E+XNHoRl37YkfY3L00gDn3xp8Lo1D0NNV9Us1ECj3QNgQqfd6wUd9UTNE2T6Gs8BcLpwgjfuwoG51TwUiqI2DIlLflCY1pJE58xyn76xkwzttHUUBMNalYSICVAplWFw6o5TB7XLmIhw2EQre6KzgMvPXvDTT77PH16fk6YJgxS0xiDrI21f4+7xwpfM0w9YruY8vd6wvR2ZCUOgR0w1Ui/mhEYRiIZmqZAd9GGCrA6YWUJzc0KpdEq4SK1BjU6hE6F6NaVAGNOiBkO1fcBEAbH7DEY3eJEs+oFlEtIEHr0+ZxaecbSa06FH1yPNeESWLYWWPHR6ukYDf0nqgJjHniBsOVKgWXHpwe50enzeeqzHeqzH+luuR1XCY/1t1WI78rlK+MFHOR8UPt/Ga/7gSvD29jPmT95y/2c+ZVjw7IXBq0q+qCqit46XZvku3pKZmAvmjAZSZ3cWikNzZPDu8dWRpsuZkWBbQzN3EfIt91azr3LK7p7Nw5Kb4Y7P9HO8Vy2XY89//A+fENmGu7f3yKBnpiQrM2P45jOSFzc8/0jw9q8WiKxgOKbcfZXykxcBddaTh3PUaHn1vbfIQ8zLTcwqmRE66XxqOFNLPM+pZt3z5MjCSwn1mmV84OP1is50FF1NLxSBEZgTU2Tf1Fu7MAkVcl3VxBx4JwoCZvxQa14/O/CHPOVLU9KUPyFuv+D1WcgLE6D3ERUHvMximoo8OMNoQ1FtCYXPYDVmlhEri9q5dLWniIXBrgrWmx19VnD/RLHaLIneaU5djeI5Z/uI1Bw5pT2HswE5+khtiS8+xpwOXB5jBj3nN28H3j28QX7iw/33MeFvibKC8SYmPD1j//2/YvHVc2Qb8lMv5b889WTf+uyudjx7tme3m2HfiQk6aaqcdfATxtU9m40iyXL8S0u/Dqi9PWexRV3Cgx3YtTN0ZhiWkqH3GL4x2HZBlFiqt4JslRHmPQ+/vMeqZ4z5hne/ahmCmiQfML8xJN+/5S82Z5R3B0xgOYRPMOWSyP8z8uonnFZvmS0DhBiw65QwHSnuNsgvOsL8C9TwQ5qnW3LjUZQFvY0Y1i3iQlO8s9jPW569mJGfS3zP2cYdINESBg/082sqxzV7IljJC+p3I8qL+X7+fBqklfURrzxRXVe88BSDdE2/pa4qen1ivmgZZj7tbsfm1Yab2x35Rcyx/IBR1Jx6NxRI0VqDdFZnTRC4kFDvvRBh1KCOuIBTxQolPVxLgITI74lUzBPphguGPrgnDisu7Qvaw5fkNzmjfku6i0hXwfReM2Z451s6f83sX35O+JN//LsbJgx3YMTXtFxRFCNF9xp9LBiUBm+N34zMIsm7zSvOZ+eIKIA2p5MdwnNyf0XvpmqlnGTX1nQki4h07TFLO56mEXMv5STdlLOnPhiqViCcFGllWecpaWTpI83Q1vhxQYKmsBXz4BlP05qNMvz5NyOZr7GjxEjBS/kMc9Acw3tmY0sgU1LZcy/vptdlmw1SB0RpgO1jUl/SKInb1fsu+xZYhxlBYFDJiN6s2G98jIAzNdCOPsWpoz8kGAnSDTGyCDHsKbOAbBYRz0eyYI54quncxOrUkHdXJM1XnIIfOMogYQnjKmIc9wgr0CMEUcowOPn9iGcCVHROOfqgHLikoYtydJmjvGYCVjpWgh1a1MIlACq8o8vkPUIy42Yf0reuse+mQ90KB5uQtGHJXER4cTdFC6ayoPV7BCOZ+oCk2XCvDHOx5Dyf8dXNlpm09H5JLUc+/aAjtwn3+zlauYnZmynWxiVfmHKBiXN0XBNGJV7oIJIxdXFid2goi5xcJswWI88uz0mkZC96XOhC4ei6upkGEVpuOfiJC2ig6e4oS49hOJDWl8TxW+J9Tpb+BuKfUpxuMO1zjv6vePWmZv/Oea/OqIItwZgwSwRP0yte+2/44x99n++dn1H1Ba++rOhPI72jKwrDYBT9aPBIaJkxXqasP8j4g+dz/vTlNav1NamDNXoghoa+qjme9iRWIKSaLBytrojjhOerlM0+nuIxle+giwWDAzwGEWlzYKwGhkVG3rd0Y00g56jA0JQtfpcgs3GKCVKNY7AcGZsaVS3pxwAdPYC72ezWyMgnzVoyZniBIBPtlESyHzs2+wesjEkWmk5IujaYzplfedhAovQbdv05uuzR54q46DAXPssxYYzN3+wp5LEe67Ee6/dMleDqUZ3wWI/171ZfPzXMbzJeNZJn/2HDj+oPGP1fkF58Qn2ruUWRxx3XMueN4yKMCa/6ltnrOeEyZ34RTlZPM9bUtaC2ksG+T3LwlaVsT4wO2ohGCI+zKEP1BzZlQ7ELCdM9/7B6xs1FRV7uyV+8YDcb0U1DK1qehHMG3+PPN2/4w2zOGFzwn161/C+HjJPbzHLJL+SWF8UXfC/+kGHseJVpyjuBWLVY91ysjsyUi6VPuJcjh1PFctdyHHvKmUVkI9vkFbJuMK/OePAhCyK+id0K8AvizY9o/C1R/cB98oK+/ZCZ9x1zYcmTgk4H/JVKedW0mMsdP755SmISqvOG/0Y6MkHLQnTMtgNlf0R7ztLsT9bXwjQo5fOsTzk23+CfBVPSmaoHbKfYZTMc/fvyy4R9rDgsjvg6oD0+cP/gEc0y/ECTuWHNM8GHv5XcLcRkh34b+4R1TWM0tn0+sSmWi4JGv0C+3fPZR2tsoYm/8kg1FFFKcTpwdowYPm0wh4rF+DH3za9pxSfI8wZiRdzt6dp88vvLq1c8hJckXUgsz1l4MQVHxP2Abbe0qyNWzZE6JEATnxvatENenCHfXtN9+TnJOuV08zkXVxeUukS+a3n74YInTwWnt295W7ZcXMw53Lshy4lzbtmoCwg1cbWmsIr01LOKLE3hEeYV27cvqZob5uEXLB4i4vwJp4uAIrsn6hv0dsFoUsInCxYvFOe5s+pX9H5Bsw7p1mfkr1yioKLqG8ofVyzbGZcLy7P8Jfv6YeoxZn7K08wnCWZsij2/PgV89MGfMSv+mCyHw9sDv3m9QBd7ZsUSL8mwy5BncUljBDebtyTLhO5JwHV4RjJKymGLp9z7FSHtDKk9dNBNQw7hJgnK4HkDb/uaX5gt/i6gzDv+L1cdP9aS/8C74q/kkbFu6OfPsNm37NslsdmR+y26/5TNP53xP1n+DgGMP7wGn5d8/W8f+O7rkqrXmFzh6S3KLBnFSJ8Kqs7QNB5ztcT6llZoBo7EkinycN8ZDoNljEL8maP4C2w48pWpEP2CtBSYuqJp3QFyCoERrVLEpYNexPT2LVuzJjclM0LKIZjiMHx3ON/NmS/3LOsle78halx6QM+D3NE9eJSixnNsgxmTnN+63+Of8CW0doYXDyyjjEhYlsLStpLdMDBmhoWfTdvjztsiVw1PTMrSX/HlbsP9WNG73nxUKC+id+YpnRH0PdEaFpdznixm3Ibfoh3v4HSJsW8JogULVXAb7ZCexAsVph8Q3hNMVNKbI7WDamiPUb5j8LZoTyCUS0xYMowKKZzsZ8R3E6lc4jvmRLhncO+ft8QLR+JFS5qMyKglDufoSE0/mzdodsajVS3a8Qpchqq6ZOGsKf3AqXwDacuoB/xsReIFrP2IrhOomwG1aDkdz4hnHtFqS3uAJlmxNANJfsFxb/EDQ+xFGDkgvRyD4r64ZzCGH515PL0K0MsQ4YUMjiBaCESxpStr5rMQdR7CraUyc477O7CGJFVE6gmEFUl+jRU13cEnmPsk5wVDrSk3A6ddTLs/4s0LVKMg6TifhQxpzQc/esn//H/2n/LT8w/41a/+jPt3v6IuCvyoo3SqiEXMZ7Mlq9Gjsx4ffvKcH33yHKUk7q/2ryV7ARalYnwCztIZRgRo3UA7sitqrvOAWT4ndP6vukfEHp7yqExFYizHpqALUqLWqQ16mjDClD2e0YyRT7E7McgBm0ac+1CZE2/uR7r97RSdNMtqQve+ioE0rMnzBOkFGBtOYNGhdVIeSzRcU9l7RBiSzjw846HLhG40mORIoRdoKfCCLUYs0E1CMHZ0vsRLHXzhsR7rsR7r3796HCg81mP999eVnvPicuRWtPxVf8sfyI/whk8Yq5qr9RJ1eMPdMeXnnqXdCxbXO86aM7blgJCGMbZUeUscZHi94nCqKURP1ylENnB5Jnhan/G2vecNJ1ZccNldkCwr8tbSxwfydzHzlwFREXC7aImdUvo40vzgwGqXoAbLR36MzE6URHz/0+8z+6ik/brEBu/gdsUXf1mR/9GJ3WXF3sG6X3RcVEtG/2FKVHgYHbA9p8sNetVTGYu/HVCnijHKeZp9n0Ed+NLc0+8E6VOYeTFN9wlN3DKLYhQvOaqe7ey3fHQ6YxuPROUlo9zzk8LnG1MRv3mCPd/x7nnCP76bcWM6NucB20OBHcxE4Ze5T2UbAi/AG0eUg4Bbt8BdksYJw+nA16eeUGY8Cz3uHbxN1Zz3kq5reFt22HcZvnfCyBMxz4iiBZ05oJ3i+tmALjWz8pbb0SDqb5gNCvHdnPuyJ1/2NF1Hfmypu4DfzN/yp+lT9ObAcG45D0ZObsNd7Hj38xobfUKaScqyJ/McJ8xQUSBOR4LyEm2PU0rcYvmELLpnPB2Zdx6qUBiZoFchoXFK4AgheuaVoO069OIOcdZj6xVznbDqQ8Y8YZN8gTxqTJ+xT0+s4p/SDt+wXvZ0Bw15hUqeT73k7IWY1LqbX1sWsXsWzylcH/nScex6LoJLxitLXXSM+4FVe0a3LLArj7MxnFQT/vOW47ojPEVk2w7uMszdQJ8dXSwdrd9g3+akycCffO9HfJ69ZXFwnLgMvTKkTcCuf6Bxz+Xqt+zfrBA/eM3x/9DwX9yXxF1BVcUczhqCUKHDbzj9FnRTczoK+iTmnDmZcKpzjelgZERFGpxi3S33ZT+x/pTxEEGN8U5s9jWfj/fw5IGsi5h/O3C+fqAfrvlONOzOMpR9xblxg7SOr9YN4uEccSH5X2Q/ZP5D/3c3TLgOJL9+9xu+ua0oTY52lNaoB5vRewek0ZhiSaEaduc3zJcajEY58ryXc+wlXtvT2BIVtCzziLNFNB28oRqZ2ZZQdZweXHSek7CXxNYg1ZKZTBF3LtVB8Dw9w+wHql1AMU9YWoUvduy3Z2i/Iagj3spqshHooWc/KnY6wh8qugvo/BDdHjGlpdcds/SMUVhkv8cEMZUbLLiJQxdO6glhBJ5LFRgsg6oJlM+T2XNkN/B2Z3m3j6grN/UcsQwIxzXQR/fbGZ0dQHyIp2LeUdJ9nmDzmKA+IC6uYfMWTzvpvWEIZuhdQeTN6ayLrByQwseTc0bRYUYPo12T2CDrgd6zU6yNm+jKXExS984Ietm7rJ5psBHnI0HqhhSSmZeSyOsJqNg5JUWuyMOY7NBx7AyyH6ntBf7BgTZidOij4gwRD6RZwqaGi6zm6Vyzf+eRuHzaaMXD2w7bviFOBWK8QNWCIepRcU91o0l3gvxsjfU9cmGmwVHde8zkGel5ykYdGQpF6jx1gztkBity5gvNPPEZqx6ZJpSla5pDXNCCySPipkdFbvbm1BB7xtkPOPMr4vkVm/5X3J5WdCen8+mwg8bLQ2LfSc5S5mc/4D/5T/4Z/+TT72H0nj//oub1AcJVTPbjK/6Dj8/49PyclICff3tklIYffXRJlkQ0dTelJCgH3dQjwzBi/BGj3HQ9As+fQEPKWW+amm6+JEtnXJ4t2Ddv8F1qR+RsCw1j20zWCxwIU3WT1y4zgjsHIh1ChBlQfUjdHfGSkGFoaYaM/rDF1BqdC2T6Xh0RuUSSOCeVMSqQEym5bw2Hu5rd/R4R+OAHtHiknWZsLL1SmGSP6gasv8DrHPtipDcBgbseC/j8/hWffPjR47PWYz3WY/17W38XBgqPFofH+tusKKqJxchhG/DsLpwWddnqmtvst6RDhLeYU/sdf/m1a74TPp21eF5D7/U8FAFB0jLvLaU/0HlLfH9GLjVp41FVkipwTfLIk/gc4yCFbcedGplLyYvPMl43jlfW06165onAO8K7RuPFiheHM/aq4jxYEuqI+3PBR06Wr37BP/qP5vzLZofn7Ld7ny+12zLf8PKZz2UZckwE3aFjuDPs/HICy+MlzEfBcy9B5pa78Z6+b5BjPy3qRuOR5HPeHb9F+AviOOIYDWi9g+qMJnaLUM3HQUK4tBPX7N0Q8uGTiDv/nvjb9dTfvNAr/rN3v+ZfXEWc3zasBslr+RmrbCQJDHrXQh6gjKAzPbWuicJsWmhV/ZHv3jX8+o2l+LznxT+6J/5szrHyCXY3jA4U7vt45xLlNv5jj39YoFw6xFCTXFvuu450qTleRtg3A37/Ej4qaG9O5B8UiPGnBPnnfLUH9eOvWWz+iKYJubvM6dp3qOo5u4tv6XNN7+T33cfY5lu4bjCy5FQVE2eAxqMrt7TNjO0uYDPuePng1O4LrFtYlmAOIX6qqOdzxpsdkWOMxeco3ZClIcdDhXrR4bc1r4OcbnOEzMM/OZXLl5O9OHoR0R0LMvEpm12N90Qwq47c3zfMP3xO3t9Qxm/w7j5k//QWY9fMgpE2zDnEHrP9yPjmHmSJCq9QrSLtHSshol85q3IHv1jwrtNceIbmVFK1BelZgPTvWQ6X2CvFP46vUNpydYpRuVt7RwRexIO5pan0lLqwsiPK+gzfefyL9lva45Jg/YrTw6doz5sS7fwF6Dqiv2t4d57z/SufMupQssIh9xUOxDhO16ZyUZRRN8VD+ibGygGhA8SwmmD+cTvjGG4mBf2iPKMbzzju3/CBPNLFPjqUVA9iUkA/G58zSsvLMuB7f7Tjjffp726Y8E63/Pargd3XV+h0g80F/snHxk7SXiEHt/2NaXvBu0xyuRIkQYroNLFwGawdR1Ny6GICk5CmB1JRc35YUXlQ+z6tFohMkFsHT0xJ/BxFixAjVePRHBv0YUD4JwK5xnc+83g/NVjSHAiTkePR4fwsaSqn9IVjcyC2M7ILJ/MB2wkOLn9TjIh5Suf3OFmBGlbI0XLcHiaPvHCxH6NHaAz4hm7Ycaz3hNmS6+WM8TDy1X3D9psWcTiiRcagDH3vUg3aCZoi0wh0NU2UdN3RnQR+LxjtQHx6wzhI+j6AJkUVAUMm8NymuHCEznj6cDpZom01xSbq8gRWTZtnGeyxBIjgHKlbZHFAJQEkAaabo/1gSiWwxvEqOrB7TmND4WRGUUI47PHDGfPowMPOQf0k0pSIpiH8ICMtDcHsBV4fYFNN+66i7g745xnp0jLECnvoaMcH7raw5Jx4kROoBmXfe/gzX9HZntjdiLVgpy1tKalby9JrGbSkqx0sEhrZURwrqnbECyMWCO5sM8WzuAocfCbP8ZIT0m3/rYeqP+RoCkRruFjtwdNY0+KbnGO5pTYu9aCm7gWphKeX8yneVPYe17OEJLznf/2Lf8NvxyN/9MdzfvTBGWcvnnG1muMr+IvffM1Xtw/84NmTKTrURWmOk1rGPXTqyZCk3PvsZoN9S+/eZyFJwgQhI1Klps84j3yu1zmbt5Jx7FC9m5pmNOH9lNrgqRLjEhsGzcHBFkWH9hTamfDcDyKfETs/nRu2bCuioUbkijC3RCKc+AxeLBD+MA3iXFattSFNV3Bsa4o+JJ/HxGFNaueYYcNYurGCC0UK0SoG0ZOnhsbMGJs5cd7S1QXvasu8cITYx3qsx3qsf38sDv/d//+xHuux/j9X5hSbQ8rPMBQ3C45+hz+M5LFh790SXoYsSssPraJmpNz5yDDG71K8YM/tLqaPDMl8pLj+ioXnc3Y6p0wEvRlpHvbc5h1PFx/SbD3KB3j5vMPep5yea87PDqgq46glja/4xgS8CAr09weeHla821T013CZnSPvYTgdaWXKz57Af50Jyj6bYOMcDX+x75C/zPjp9YqfOSttoFmGA4mfUrRuy1uTdBGb/gHPc4pfiZIJvbR0/ZHOpar5NefXMYHKp6Vp1AZoOZ/6hcOgOfMCssHnoATzwlmzb3iV9ZzfnjMPYu4XDbtmxwfjNey7CdD9m+4W5XtYniBX93RmhjCGk67pmhY/Cieaf9dXRHHK0YNN33DoNzz5zvJUDFOf9Vc3NVErpj7I+j2jiMEpkNVreuGz9uNpALJ9DWF0JP3uQ6JWclzfYbOeqyymbQWZ7qjkBfpiR/CrD9n96S+Zf3VFurGU1TM2+4Ire8Gz2R0liiLZYCvD8HVCaVaIeIHyNJ1q6DYdItgy2iP9w8iX+gKr3evZEa3WJP4a8d0t/flX1FWC7c2k9Iiad4gXKVnxHLF7TbZa4o1qgk/uxiVSaY4fvWF9/IeMdxuC7Ecch3d485DgLRSf1SzjJ4yrB7zfRlx9+n20N3LBFXfDK/bbc3TuEYh33PoCz9l6g5gktUinxJ64nCPNb+AvHfOsf8BPfe4CMK4/OM9JbxdkZzmXT526WzBTHkf33lxcE0YJm90D4ibCO4tRYqSstlxeLPjlQ8XwyxPHPiQbB+L2E7StETJhtL+FLqdxtvm4ZtO95tgsuDysGc53hPESNQagnRnfkUCdmyNFOqgpztKupiUuDC49kpXrpaqEfhVyWEs+8BbMzxtWi4yoL/ny5KO8G7SY88JkdJ/9ln/81Q8YTxfMt47P8DsaJnjXV9y8/Q1xcJgi6Hrn83G0+fpEWDibQ4LnJezchn8Pz+/2XF6eozLFYOPpAJSnYZIMBesA3wtpRs2b4BZpYxItSHyBzTxSp3aoPXZ1hwkE60GSRhVDO3JfSYLMg9lI2Ara4IDwLL7UDHlPuF9wvRrZ9z4quMGWKTLoEL5iV3ksB49AX+CHR2wrkMYNO4NJSh6rkVA4EqvAVC2jp9GiRHcO0hfSqiVxuETpkPvynq2pp9xZPxBYNeB+VVunDGM2DVhGB8vbaOzxLd6TS/r6RMAGjxnbN2/pFzGrXYq9sJhdzzAEeHWD9kvGJEc7nmzfEHtOTeC2x5JB9wgvJ/SuMNJgpEa4xl7N8ERIqKJJ1jIUFUakdJGlzZwDyaOrFbbtCdfa0WGoTIOQIfW4IQgiwtCggiW+LjAmpfe2+LFFFj3rq3NUsqUpGwYV0U7Ri27Q0uPSDoOxZhHOyIVHtBjYNksOVUVTDESNey89HoaO7X2Fp85RZwH7ykEkB/RQoXTE0KYoryMNWjzpRnIjQ2wmMKVjUQRu665TtLPP+D1F+zXrQJMkMxZZN8VcnmYBXX9HIQxmbEFl6O5IGMxZpTFFE7E/veV/9X/8l/zv3yz4OPL5n/7kB8zyhCjwEEpP1OFdUfD55w8EPbxcOyijnEAnLt3VnVptnb1BTPBI45IalIOiuEhHQ2tPGCGIwhxvKBHu50vPiRZ3NA89RTcS+gPHyuCJmNCxDXqnTirQQcaoIqxuiWROG41Yl1IiDtzvoTw5gExNFkaEUTapHFyyh3TRkCbEuoFWu8dzg7a6pR7c9aJZOaXJKkdUPcXBUumEVnbT4CZ2CEqznVIznKcxjBoCEfHu4P4Qi4jczeqxHuuxHuvfv/q7MEh4VCU81t92PQkWxLmhDhuWS8nTs5c87N5xefZiWqhU9ojJFC9tQBFVfFEvGfc79LIg0Wt0c8SGHXGwZCWeYVOPo4XgMBC4/uDYUZ8cNPBEE3p0vsIfPZYvF+zMjm4IWSaSCxnz3XzLp8eRj55/xL9JvmR3m9B5FfK7d7x74uMLy9fHCuY98YVl/b2A8f+0YLAb4h9/x/jVFX/xZUfxz9/yH159SHMlSM0T5kOMlBVlXVGFFXXVYA8uNluwSDOyMGZzKPh2v5s4VqmIpg1wVcPbek8Vb1gVH1GNIWd2z7h6iicNv432rA4pyW3ArMv5ZvmO9mD4i+WaJK75+CSxYkbQX7G0LZvjAy/yFfOza243bsHplpJnBOGWyAEEm2jyJmafEgABAABJREFUyn+8HHjnKy7PNPN0SVXGXPgnTsE1hV+RSJekcUG4zLi2LaWzS/gFy7rn6+ENp5sZwVnCRXwkXIS8LXZ0v1xyPi8oPmt59vWRr5/N6d9t6PZ/SXT7hEYLTltLXr+Z+rBiWfKca16ZDbOgo3KQ9yGiE25RW2K9nu7McfCuCB5G1MWJ8IMGVbbUXw/MspL52ZraFlTeDv1uxli3NH2Jn3kE5xmJ1XhbjdBQXpxxNa/ZmQ+IzDvUm5LmFxEmKVCloPwPv0X95T/BRP96ilIP+pFEpgz7ChLpxC/049K129h7QSO+I1ZPmS0vsHbPLumxMqBxy+M4o9x4HL645VD4dGHM5VqQbA2HB4NZLxGrNZ9eeTwkHc8XK5T12LeaF8sz8mQxnQ2tTwzeiaCLWQRzivWOquq4+auapi54oU/USUztWYY0JMg6RLScEvLSJKQcXWxjR9H0tFHPqAyq7glcUqKxCC0YfceS81BSYRwQ1MVGqpFedvRFTXLQdLHm1vWXgxsxPLCKVrwuv+NSheRry1eJR24zrnZgyyXjesPbm5GA7Hc3TPjpD/6A/83dz8loaM58dBCRrXqWiyuaTcJtVTJfR3yczxnwuC8DQu+elTxDoVFqxMYBkRinjaoIY7phoBx68mhkiVMxOFK/2/kqGloqc5wmV0bv8JXCWy6ZdRZlah5aS1PWUHtw3vMsTKmc3KdtiHTD7a1l7lk3Q+Wm2BOPM2wQMYQrVBug5gv8ZMPQuFgNHznG9LFH72mMy1NUPkoH08DHTaqk1yJkTCwTzNhTFJZuF6Dse9k9hdtUu9xaN8X0sDHYoaQ/ZbQXGv9uR1JrxllEnmWI5geYWcHQFKjTEjG/IyxmmGxNKApMIxjlAeO8RM5H37qoj5QgrFGqmSwOUq4nuIYyJX0Lo/sZqxPdoBjGAE+PWKE4FRobtIQmpjOWKAmxoaOAyklFMPhO7lJz/mJARGcc3sDiwsO07TR5lFJNMTfuJtKcJPUQo4OSNLH4ImA7+JSm50lXEVycYbOY1MUPZh3GOACMJHSQPx9C4xH5IV7g40eazEmZSp/yOOIlEeF8ThgOE8E2PLrDINBxSD03mJ3jSSwnQ4lHQRSWCH/ObOaj+3AaAgjnMlHJxK4wpzdoFwA7k5gzS/HhGWf6mp8+P+dsfUl8vmCm7ORFc9qewU2khwEr3YCp5yKVZGcJqyjEtI72ICdehUMEWa0xjqwqnFhEoLWZPnslA6xxOb/95BUrdY+UBs/3WYURv2xGlN/RGsHQG3Q0YMb3h96GCaovqbsQM/i07rNNnD2jQxWW+q3hTXlPErth15HIEyySGE8IjB6JohmJVGzqiv0IbS8xY06QZaQrhQolRXeagItS1O9ptUffzZOppIepDuRPoim2yWkIVaII/Ix6fPibPoc81mM91mP9XgwN/tu//12wNjzWY/2+VHU4IMOQcBby5UwzGxusaGnKgsXsmiCdQbGZttBB7rq+hsYkROWKReZsqTk+S5dbR19pNmmDijVdqfn8YUR/6/F8KUnSgrQYCEXIvdHU8++Ibp+zyhQPi4azTnClzihebtkcN4ij4svjjo+GPd1yyc/H13z6NJ6i2GdoLrjmP34m+d9GO5oPJVlzPTV1/hV0dx3Lpw3rxYLupuZYO/Che9atSPoY4WLgq4CamiGtSMecd4eC33zXcLmcMz8TDGacQO1hN+N0vGYjPEbvjq+CkiB6g5e75iwhTCTt+p6bXlE8+NSHa8IPbvjsfs3r2S0vihX91Svi/Ut+4d8wO3zAdeazTFPq+5GgO5CbnHqo6Lcaz9T4DLx47uPHaz66OMNH0Dq1a9ryRVHR1D6BKInaW5rzlCBekxUrpLcjGs/x8cnlNyRxQpZc4+8UVdLTq+eoxT2Hqx7xcOs826g/mPFh3fP56y02/YTjhYthvyIsYkp5i4ocRDNCXg6cn665+fwBKwT6exr1lVNn19hAkbUe8q2i1i7pPCC9XpAufYp710fESL9gnrnkjAShT3jyGcU7zSK8p86u0LOe9n5BZ/esj/e8Cj3SIadzoP/jiPm5ZPij/4b03ySIqzsSL6YbDyw8OM27SX3tlpTjokcIRXJU2HcF7yJN/sxHl2tOw4nNV4pht6OWOXGY8vzjkuVPFpxMwOv/8sSw8vn0fM4HScrFRwuuoznNUKPrgkWSMEsX07lxvAbXN0Yzj9Ppgdsn38F3IT//+cD2qyP5x4K+XCGeVGyuO5q/nOOfbihUhCe8yRLtb1z62grlJYzRyHw4Q1T6fd/hyurJcu33LnHQdx0Klg5Bw6hOvBkGvisNS9uzHEMu45husmnvWKQRq+BsUjg/j57RmS2eWfD2AX41fsNLu0A/+e3vbpjwXz28ZswkYggg37O88Hj6ImH99ClVdeKqT/GiNcrzMfVbhneKWp6TDhbUDbWMCMIFq3lDvi4ZrU8/emSexvPFFAvpYu5NA7WLmvQqPP/EGCwRQ4jvZO5ZQSIieuWRnEoelE/bGvJtwbulRHpLVODorzVKj0h/yUO7m2Q3vpBETgWB2/h3BAwEbtgQC7TycFoW31qMjBFhDt0G6xbP0YI4cdATiRYhqa8IJnuCN3mYtAMmdoZxSBzKZTqk/ixEqIi6zPHXI97CKQ5i50CgKTf4NiGb7UkrnzHfUx7C6T0IZOKSCDFG07cVia+noYt1F1DufgZLImtUMid0ioSgRsYeZj5DDR7i1DEUJcMoEYHriDtsL9G1k4X5tN3IWAvC0OPCMtkxlG2n9zdcajIZEKgDb8cN3bsr8rOcOFliHAOiLAnXhnaYTV4lPTiqa04Q16ixom0U2kqicKQaLX1bk2WO8eBRt/XkMRPjSLYWzGc9eSadSolYxQxRiEp39NLdIDVmHGls99fMDYtbwCfG51i0VN1I55WcRzHuLy0UY9VSW8fwEISVZR1FXJ/dYLw1fW94Mn/CP/vJp/zkZz9mvrpmOUsJ/A5TDWyKDduiJZeKTPkI5SCa3nS9PHl5gQpjWtwhdddpMNkYHFHXKRScOsGdZeWOkW1BeNPwybkgXGzLMAyosaUoTsTpjEUSkUcHjiWQhmBPk62FzDE5Rp56PkffpzgU02uKlY/NOvJQUR0D2uIth7t3GHdNzuYc04GkHTjzcgjmdGE73VSKbcfD6TgBbKSRBC7XmRzbWLzOxw9DvNAFYTb44xFtXbzqEpI7tPvZIjcXUayjBZvR0N8kf4NHkMd6rMd6rN+/ehwkPNZj/bvX4c2c/uwNkfoZn+Y1Nn/Nmfcpm9M9+VCBs0vOasb9iG0Ulx/d45UJ3/zilm/ehSzSBvI5RTVylvRcdwleoqibnmjbsr2Npmj2t2HDmKz48ElNEHrEQ86DPrJ7N5IvXYS5YBM2xJuMr3YF/dUEredfNhv+B+mMmd9x0V5wJ95xeteQKJ/FpxlXHz/w5c2W7uEz4s92DsxGU13wxbcDH9qeY76dmlKv9zhLFxNLzRMFq1yQdYJojPC8mGyRojcbahcrLwQbz3Wp7hm0Ik469quCbGPY3j5hwQMmbVn0ktE4Lpnja33Hqv+Y5OKes3cpr85bmmM+tX/55iXHTKBvNF8lLd9lv+WJSogizXdnd+T6BdmdRyl32N5jVAF55Nq4mChIWGcJD4VmVWg+HS75kobSnshVysIGpO1AF8yndLlns4j5n+7ZKEV4c81W+3C5Ja6f0rkY8r2z2s7Zpa/4IJ9NW/ay6GBxh58p9ncB0eWJpB55CGeMnWX+TUn5A0P5QjMePMZXHoEDRKZqSjPrVInOfbLmjHEfEMx7wiybOjLHiVOVU1b3jBfgu5SPty3NtsBfWvb7W/QJwuEJD/bnGHPF5htB8A8TzpI1Q33i9nuGF+WC/eYMaTecZx/gy4Hd04b21YokPWD3A2YWM+4eWBRz1PNnVDvFePuWwTV9nqV4faT6KzVx9+RTj+RPUlb/KOL6XPH8oPin4Zyvi5K7UdEt7jB+BuuK+D7Az89Joxm+H9APPUoIvCjn2DkrfkZ4tLz5AnacePajgUDN+Uq4RIY95ktNmhyJyhpbeDRzjTe6oUpLEIx0F9WUeOG5hTgG63pY+9eW60BP3L6xd2kHIFQ4xUiGNDwPCz5ipHgbYucGnR3oZordkBBfZwxFz23RsiHAu7nn3O84ExkHaXly/SGR9/x3N0zYffXn/OBPQ1Q7Ry4kwVNJMLuiDhTC+sxmhg45edTDeUCleqrbnvToocIB3zXhuZnI/65Z7xrXK9ZT8zN2s2m7n+cBpaxpbEEoAvLgOYEc6cZwoo/6o2uGQS9j9HBCFCG9VNhTwLHxiNR3NNEa27otfE0Qr1haweYYTZaB2EWs9C7uz9I7kJ+C0KassoxGONbBHqs7YhnQK0snWrw2ZLASmboMW0tsM0arKY+GZuvW4B2DDtHjdtqYuyQIL7AIGRBHFhWFJFk3yWvU0WDrkJO+IcGt6UeaLkD4NUMpqGyNbQ8TVV94HkOTo5IDIjZ4QUjktsdqNg1EfCfXCSH0Df5MgY7p/YiTB2bfTWkCrvE1foR2ea6hIywECAe1FArtojAHSVm4CEw3vDFUeo7q9iiecrQ9tCcyJzeTPkEsycYMM4Pj8Uhx1FRByOWq5YkKqPtLdKgpuwOanqFb4ew6sd9O4hE3TU38kFUcErvNulMkDHpKQXBQyywJaO0wQQNb4zEiiNKMKby3CEmHGWJdsSldbKVC9xYdujQPF43TE5iW3kE3bQUmIvU91i8jNrcPiHyN/0RxFipWi5DRN9SdZmhqRG+IUFSNSw1x0JuAwLE7fMUn52vmeUY7DJzqdlI5uEmgxMPzFdIMWKUQDjwjBMrFghimXFknPTJKTQMi9yXh4jAdd8GpXE4PMTlHAj/E9mqCKVadxPXz8VhPE9fAPyeMWrRxX7Ytu82B4+jsFDMXaEE7HJjVOSLPqIVLZ2inG19pjBsRuJAmtG3xUkvmKdpmoN73SCuIVglm1k/WiF76jC5KUt9StyFVcySQhlinZFLTJKfJxvFYj/VYj/V3uf6uKhEeLQ6P9ftQK9kTzFJ6+Y4Le8XrHSzdc+Ro6MaBgyk4S68ontyh3/UsZcY45Gyqnpu6ZuHgzg6GN9bYdUwQpHjvNOakyYzHfhlzijr6tGaZzDDBwMZarusBJTvSsGOVL6iPLgZwxnb4AlV7ZEPIPSU3wzWv9pIyjvn1UPPJbMYvbxQ7e8M/8H7A/+iP79j+XxWH+lvaTT5ZJqJxxy9e+ches/w4Yh5foPuOQjeTRfRURtPzkLNKdyZkVD0vn2bc3F7ym3f3zErBR/GKvS2Z8Gqjj62h6K6w/nZa4ITbnmH0KXXA8/Iz3iXfUucnbDbS3if02QNX7y75an7P/D7hrPPYrAS33o5uV3Nql1yOHna7cA+IkzxftLAL1lRdx1KdJgvG0eyxbnHXbJGiJM9iFoWktSGdPvKmcFaIA+FqnJqf/VygRMTP1FO+q1OKuMRfXpM9zBm3rxjrkc1+QDjY4lDzk1Txf+Zr/OXHHH9TsDpzA4F3jPMZh31L+7rmvu4Zft6RfpRiyxy7UMh1QB76jK80bSjxLs4gaZG9gyym4ECGWjNUHlHcc/XkmiryKHaVcylPTDpTJ9CukWqPvlekzyT3dxl6KXlxCJlfPMXnML3W8mwBX95RLg94N8/IXAqDWx+LkkA7+0pGXjjV8JxONzwZ1lRhgzmtGR9qaiFpdy7GvkD4KdcfdnzvH1quP36ObFL26Q3NT0fmbxecvRp4yZymaRBbxaU3nyzjwrfs1VvawefcEeCsg+WHbE87Hl7NOMWviB9OlPEl+7Mbqt8+Z/9ihP9qjva+wZ6uCD/JiNo7hlpO9mOlPWbdjHW1mHpQdyW4gABfBlPK3ClyyYSatLLowE7YAKfstt6MPtlziDuGjeFusCzlkjgdEQ8d9+8O3NaGmR8gZwuCVz7+Dz2EGXkmzklkQjD8v3OG/rv179wlvGhjrv+45d7ENHbt5pQM/Uh139KdCvzZSGdTzuYwpgkitdTOMz94sBL42YjDw7fbkLgBP7IYb5gsDZ7n/EoxSZEy9IokcoMBSzSpAFJE7TzdapJDObn5KSgnBkCaNAyJz9ubDu7vCYId/blg1fds2zkiqSGwHEvB2N1izSUDb6fBhj9taj0ufJ/QlowyRNYBJmyo1cZlceB7MfR6imiJg5E8yPF7yW1xN21+26abmAGeSBltgVQZgbwgli2SdLqYY5swyOr9ATcRWvuMxQMnMswoaZRAig6hJZY90o9xOMNh3KC9Bk+NeI4FGkGU+uBgi3QkszmBLwmiDh0a2rKbIhxlJAjW+ZRW4bIsR+kxGg2dmW7GYZ6jvBl1vSNaRMTS0A/dewtHHDC4prYxqKxiHJ9z2O+dNwE/DGisi2sZOV8t8ZsTtXDNcsZ8FXGsBU3VTU11FnmMTq3Qw9AOSKtJQkmewDxRhNGMwZcU+sjYHwlR9NZ3Pg08BxBEkvgOfqLoeo+6HhhcdGbksx5iyr6bvGxekiBVg05d0+2ma46l4AYoAckA22AkmDsbQ8fnf/aat3+55+rTSz45z7h++gxfqGnAFIQ+g6/pteaoNbFtmEcLwsBD+ZZcRUTKo2gLTi5OVGu0cQ+lbqwhMAwo5YRuPkiNNAFGtvjSfbaCduim+EihG0LHsRh75D5HxHdYN1F2uaKRu2EEDGPEQEoaG/q1RuwSToeKd5uCvvJJVU4Q1ETxjPVqQZRJmmaYLCRq1OjaWR56/LifXp9K3BekYtSaSgs6q5i3PsHowKhzkoWDfDq+QkjnbBdzSb+peYhSFkEw2VBK6a7Jx3qsx3qsv9v13zbmfxeHCo/1WH+b9auw4eO/Ulz+iVNfalJ7zjC2JFFEpzULByK0A0/ygWae8Av5wJlp+dGzhPyiRR9jyg0khSKZO55UhO4aTsdwirJbXISsVz6z85JOOfJ/wKBLtFvwZBCWCTe7E9oKqqimGnxOFy0fFin907f8Sf0TvvZ3fLRo+K4RXDczLtfB9LzWFjUffvySP14L/tX/7i3NfcPYxaSnI553zq+/sfzI71lff4mxKcK4p27LWjqpuES3hsGc6Lsl6+SaD2LDwdwRWcc6e2+8XUYedaVYNi4NrWOTjaTlE/K+YddLyo/A/7ojn6/4fPmGz7YvCZXmk7uYYrDsVEV5/QXL+p9zzB/4/h0c24hyCBntiYv4DKua6Tk88zzX2hD1Hv6122EpZKF4MAP0Cr1oUb5h3sx4SErUqiduF4Qyoj5sseELPl5VLticzdsY5Zlp4Ui2onnulps72u5Tzrt3xA/n8MMHPF8ySz+kfrdleJsSvujp311w6k/YWU4mzoiD15iLJU2bMTzs0UmJVy6YW48mOjKYHD9UDKZnkBYVx9TVgC0fMFUGTwXRlYZ3LQ+3G5rRx1v7U6z9fFyz13qKkU+8iNm6wJOCII0Ztj1FsOZpfc39T76m+40g8hIOxRHpktL+7SU2OtD5F+i8IVDOvuGhZyu2kVOvC64dx88XvP0yRuRzzv/5E7oHifC/YTl0GNuxFRrlj8hBsQxj9DPHxLsiGw2Zd03kktwcs0C7mE1FVPXYhcVXAcGmpuqbiSPhUtuKmaTaSrhoyYoOUc44ZAnjaclhWfNCrEmJqWduIBTQaYnXuF7FpckFqMFnHAeMcFB48KtgOqfa9KggnBaszqCj7IyuzGhbxWxmeRrO+MH5FU/WOa/6r6nDjrVaE3uSWQSHmYO395znC27ffYtuPufZJ+//7N/JMOFsdk6VbNkMhqz30eOCk3ZefJdv7+Ahl1jXTOKIphWOcV9KnzujOHcE1zDkuCm52+6JYlhdq2n6qPxsAnUc6x1Gu2iVBplHjJFPa+9p+wWd5zb+c0xfIpSHsBXGWxHkHXPMFIe4MyWnzTmWG1QXUzGymBn8fqDUirrYUIwKT564ODtnGWiqxlK1FcavWGRzVDxDtBbrtvp6jZQRjXEpnu4hxMf3fKrDyJffjdzt3WuWGGei1wME4RTzqEKPJE2m+BIR5KS6pB7g2FvM0SloxBTdZ4ybeM5AHabonLHyic86ymLEDg9YY6Y0CDcRnarUdGNJEkQkc6d6cNRR10FarPPpVP1Ee5WT1WCBDEZ016JlOYEhRZshVU60SLHdlvokyMKBwKkRghDSjqusmyRQjvK/KY8k/one9vT9Er8U2IUhjwUvnpxzFAlfnHyMHJGJm6lIqq5iKBfTNdCO97R1wtgYrIzpg4BWunlBSR44OVhMMDpQizfdECKlqY2emBlS+khrsGZLoDxUMhDakCh1fjawY46XOsiOmZpdL5rR9gGj4x04W0grieYxzpRl9wFNWXJ7rCldvMuvvuR8lvNP/tln/PFHHzCmKbkXkAaB6+fxtJiGH1maEkfv+RhVX08KgdgPJ95DObhrp5r4Cp4McBMQB8MZ9DjlKbtLwhFWfSUZrUE7u4Ye6QPJLPam5IeiCsgT9991FhmDbySdXFDwJTIISUJLV3vUes/92we2+xOjpwg85SAeyHk/RVK2tY923AbPebWcNSR2CZAMI4zCsRgGcDae3qCcpEFY2v7AWHWMvkI1HoNskLMly+jIoUiQoaOSSgZbTwMqxbO/wSPIYz3WYz3W71f9XRkqPKoSHuv3pVws4U6FXDZ7Kt8niWaYdCATOY2Tg1vJ0HYk7RUsdkSqwnQeTz7IWeszvvuVQ77VNL1PeVdPwG+z8CFNiIUhfFZyFTpGlINDn9BxSSAWHKIGv1a8PTWoXnD0SqyDR3vXlN6OsL8k7q6pv3ci+I2gaDSroeM37+DHTyxheCD0PqDpOn76w4D8n1zyn/9ngrK74VVz5NqkvBseEMEVImg4d8pr/xIzBBziHUqOrLxkgpe3nWtOZ4TBjMCe46uGjXHP0S6S+0Q7U4T3EcfnB56/fUK06nm7wr1qkq3P588rvncH6cs5t+0DPz494du8Iz0euDrM6NUWY1qWrlcZM3Q2Mj8ysRtax2CoNYd738lEmCdHcM/v5YxSuoVdRx4HtH5M3l7gDx6nUfGCc87zcx5cBHg5oI6XaC9GzA22s5T7mqMaOEV6yigTacC2zPCGB8wWxqsbzvKn9I3CfL8lucson/mU4zecjueTKmV+VjH8oKP9hSBXHrqy9IuS9gDdTYOfhmSLoyNLIKV1OA1GZ1M2ZmLPmUONDiqiIOP02lLd7bEHOD8/Q17V07ApOnkM+SXt/kSZJbjZhwpDulhwUL+lOZxxFb4h3s0Z8i1zq2m8c/qz3yI/n+M/Cei6CisSSl/iO85AC4eVW+4pWn9G3TqFfc/6Ys73//EHbPcdw+cdddPh/k3mjagxdd8cRIFkJc+J/ZQsCqaFnlMJ1GJPF+7xhgvuwweCseO+vOM3W7e0vaXdh7zKSg4nD/0P3hKMFvlU47812M07ZH5OcvnFZFn3Hdz94hLf7Ci7lG1R0ZqUBcmEgnf6hEmqLCSBY/w523XoEyn3PjsWnOsDHWMiZNj5xFeSRSjQnGhLxbEY2B6v+OS8ox0SxK6kdemBo+Ahv6frLvjo6oq+3f3uhgn6zLK/ixn0fvoAxOgOVEvo+eilwnfNx0WGbiv6ygUb9njnln4ICRbuRWm2W4/dmwHPIfLFSPTSI8lmrOKeM9fyji5hwG2XCzwTYccU7QYMvp42vIGTYRgXYzhjxMUSDhO7wDEMwpnh7m4k7AQ6FIRnJzq5mrzueSjoXHRjPUwRKQ+di1IcUbGEOCPzV5BpTNBP9MxWD9O00bEQXFqClyvSMET1llc3Ba++rahPLVJ2WNtP7AQrHcBEkcwgVCEi7N2xoW3tdAg910iPCjv2mCRirHb4ZyGzKuXgkiruHdQvxrqhg/BxFiJTtojEQyoYew+tHMhSEboGVFaTJcNtxocup+v7vwZuWLAu49UgpMRTjk4bIXQ2HYbRQSvddM+6NIVuisMJnOBhIfBClzXaMltJhjdn5EEwSfZf104+tISxIrALrFGMaTDFZvpRTCBcBI2iVTOaxtA3JVeBzz4IpyQF349oooY8cikFGZvjSKSPhMJN8VKU3yCsnn5e0VsG41gOHrmfoolpnBKlHBmso6I6+8Mw+eACzDSs6Bgm5UovDIljdIQNxJJYjpz6jk55tFbgBzWnb468XaaY3iOZn6GUGzacOPgDWZSQBfE0sIqyaJrEOp+X68wdcLFXPr4PizAglR5VV1N0Ld2oSKwDYbpEj2ACMroG3jgLjkuiwAlcGoI4Yz6rUW5YVpWEnmL03aswE3y0lzWHZiQXOTjGhMu3PWhKp8xw2caDxps3CN+fUkic/aFxIUwuJrN3h9QxJtRkTbFWTKBI33M01xYtNKHLxxQGTEUtNH3T4ZtzEA1poolSQdB7mJk38UH8oGfT9pwlm7/pc8hjPdZjPdbvXf1dGSo81mP9bdenK0WbLLlrXrMKKj6cP0VJySgdy+rAqJyLeyCplkTzHR+mGbUKYB1w7rajZxt+/bbkdtdNhP98jLj0Q/KXEuWYYKFB7sGGimV0xigHtmXPvRlo7kf2u4aL8zlFO5L7S2r35OcrbiL3Tz/gbfpfcPb8D93id+JPbaOQ33LkH0TP2GQFs42zCT/wT//kj/G/eMd/frvl5hvFmCiyIGRz6PlimxNHMemiQfmKWRkjxiNJEhEkKdYtvVo9WRryWJLEkkZYEgeI1yGpqejniplJJtVvFjjVbU+jehZ1zO5ymCIx0+2K1hbsaDloy7UIOBULnsYOHN/xbOuaRTfUaCZrbaR8qrGfbLi6N3RlxV4GjKLFbzzKfkAvRxaBmhQLLlnP9QJp2rCQASEDe1nRqBB9Dulx4PBtRmcK2rrChB26sGR3KdomrIOOIfM5dc5KHfOymPPtk44Pu5a3ecSTZkM3rNle2ylqUqg5Z+nIQxKT6oLR+a2XDh7YTaDAfi0Q/QVJKQi7gbLxp3yAjJ66CRitSyLzaI41p02JiAaWz8+Jr3P6iz3efYy5CIjrI3Xk039VIrwZZu5iDyX9fo81Sw5+Td47tYhG5fEUx6gyD3HulnoBzdYiP7iju/XpXrT42yv0bxao+o5ivqCVarIK0LU8by3zMGY7LsiPNWdu0xkpTpkh6XrCMiO0I77fE0ZLatMyyJLMC9FSk8U5x6Hg25tX3By/5dWpZRWtuXcqgewbxuADksIlzm0Ygoy0s9jYgf8rnndzupkTmWTTcndY7OjfXCCdkll7+O7cmYHBkfcdfM5B1Z1S2vUcwtKrA8J3qvZoSgN582bP3DYcopHwTPLEKI6nOzIriY8HdmeW/tDSbXckeTall5RvGniaThGip+53mObwVPq0cuTGSFoHeahLEmoCs6APQ2pToR3wIdSoLp2iI+Ws5jzzmDkv/31D7UARrnF1UvUCqs4QehoR+Q6Jj3T0ee0O7cCZbzg5yKFLTqg0lSqndAFpUrrBQ5vT+0ZycF4h91DgBpx7umZAzwRZfokvY0ZPkHsuAjHF9xp6qyjLAj2ecakd5WHkWDTTpCpVCj+wDKFxS+dJli49MU2eQieBKS3324L90VkWnBghneB7vmeRZiSMHDnfR4kEFZb4DXThGh11U7ZtVWzw3GEfPaTMMA5qmM2QnY9MOsZGE4wxo1B42Z5Kn9D9E7TXYUImpcPQjfQuJlK4fFt3A7O0xmUzurfeQf2ODO7X2wVSeuj2OOnYPdXTuIuvFfiRxDFbqsFwHBvScMCzz6mNQXj9BPu4PDunsyei0WcufZpjQ24Upte83e6pXDRiU6P9S4SIifyebEjZmROB6JhF7mAaDrZEjiFi1FMcohsm7LcWr3KH1g0BdsSR+xJStMNfDxRCQSAsURzheIC2nk9SnsOuRy1Hzpgx2IGmldROTjQGBF2PVO8TEpRoXCws4SIizHyG0UEsJUFd4gcxzz/9iJ989CGrdUxz3HLqKkLp0kU6PDShSWhLxz/okFLgpjm+OwROhKL19OssPmkUk4UhrbGcXGyp6cnNSOquicRj6DoGF2njLBBSTl9S4fk5f/Bpz79qiokZQet+JpdxO3B30vSVU55YOtVRDy375kBV9lM0qWibKZXDRB66WTrCCp03UAgL/YA/SjzrMXaOUuu+oJNJRuZYGY4rEyaawfPo6xxvXjAeKvomYowH+qJDJuGUmiLzkbpxgxOLloq+/O+fSj7WYz3WY/1drcehwmM91v/3erJac6wbfnO3Zm4G1rM9Xp9MkdhuyWWsYbCG+4eBuRDk0ZzyYo+/T+jUhtnHHdGXMa13Ip9Lnl9J4rWh8I/UGJJTQjYMtAIGJwu/t7w5PtDVCcUhZpfGmLGenvWqPMJ6BnEbcrg6gXfH5cMlJu0I24y7YEMShcT7jmB+zTy+4zRPGDdnCBXw2Z8m/D/+1YrNLyO2J4W/kqRJxeng8Vf+hu/NljyJ5vT5yNgZhsbgBy6pLaUpeozcc/lUM5/PnOiT3uuo6paljakilwY2TJv/o46JXZocJyJvxvVOsZuNnN0NyNinFPB0p9n2AX5QME/OGK5Kkm+dthsuRkUfB4h2QN9EDM8kL78X8G7M2b7pWNmB+CKcVOAuQcwwOiwfrbBTzH2aeHihRgyShe9j3XMpPaFX4g0BJ6upZUxmfewXkoM+Mr+e0V4ILpnz4NIX+pb7doOp17zsnvEa92dtEX7CjVeSdRax8Pl+nHL1PclCxvwy7cj7JV6zm/on68dYaTlbe6zNQFc8EC4sqyyhPA4chSYwisRZ0C8T+iGhccbhfU+i59ReRddXqPhE3IW0D67/OKHi5zRjS2TnmOREWEY0hIRPtxT6E7wPXiPvrzHzmqJagHiNqgRdfYm9M8i4RlZuiRnSmxrrrNZZw65q+MufW7rOx9yUnK9C1Ff+ZK0+iyTesWR+koS+IE4yJ1TAt44zIInEbEr3aIItDzf3/Pq7Dv1tMy0ldx+luKBF44YEwwZ9P2c+e8F2iPDylGB4B5sDTbQgm2UcRkW4/Q6jeqKsR65HAvdZG/dsDkOgJyWyEhL3kO9GCqNjC1Z6mjHItOG+OPKqLLiYDVQmpPck4ehRO37gMLJQDeU7n1j2EAUMTg1eC5Z+Mv357eAgpBe/u2HC2++cRBvy3vmlWuZBS9HpycOSOsCHrAiHevKpKCeXcb7sOGI1c5M7OLlm/YmayJbjQeD7/iQJz3xN5MWc2nbatLsbkrvIazRlv3UtGwwdrWu4+4FWW2r98N6LP4QIb4f154RDQHbZExeGuhFuMY0ybtv+Hso3thFx7giYmjCJUXFAqNyAoaWxNUEVTHaGbBmRx+E0TTSRP90k3XTRNaeHY8tx50j7DsLnGjSJL6PpglJnDXKK3PMQUcfQKfxYMQ80kQh452IHhSNvOp+L206vadotzkRmhxgRGbpDi3ES985N9EJssMa6n8s0iFQTNO8l64ODcXRykqk3nWtuC4SLEDE+ox9NdE9vGNCji2NJEI3BeAXGU+jQgR8laSg4dz6t0dCokUtHo7T1pCrJ5z7zIGFn3M1JsGpTHopbpPKITTnFdio33WhC2vBIEzjYo8KzEb2zwHiaU+sOTEOcrDFlQFe1dE4FEQ/EqRukvffxN51gHJPpc5d9RxRmWOmBu3l4LeiaXJ0R5B73xZw46ZmNMaVT4o/gZwM6jmm2FbkxFNbBgDKSU8titmQvW4JY4JUV/VHCWvGzPzrn+sUSYwbuDzfsa8ETP6Y4bqmaepoE2jFhuUo4e5bjx9k0NPKkO6ryfRTjX2+zrNGTsmOtAkLtY4aORo+kRk03FJy3LQonu8ZoB/w458dPL/jz44H6t3v8+Dhlw8ay5KhdJq6g0QOR4zKMkrubA4fjjmDwkb5B2tF9fIhkZHRfuqO7Y3TQOxjL+yNd1CHGb1kkapLHOSeGU4G4ieXEcAhdYGpEoS0maCZCcTcKZD0yzPWUwOIGIHZsCLuQMXayh8d6rMd6rH+/6/dpqPBocXis36eS24HyoxPZ2xnNNwNf6Tvm0Tmzc5glcx7Ut3j9HG0atruQ3AbM506SXuN1AfXaMP9Q8zJY8cGZx9lZgHske6gHHszIVeNSpga6o6XY9LSVx0YPBOPA0T2DLAekCDimmmQs8Y8GE/ZE784Znu6n/iBvGzZdgmhHPkicRaDluy9aXgZzrudr2mrOna4Jnob84CeC3bceh80t24uYyKlDWztFq1+GDU+fd4jEKX89Wve8qUeM3KE8yWKZkluBU5b3zQGajrm8oIsGPGcd6BbM+4bDy+2kiFiLlDxIp6WakSc60bFx3DhZsDyGeI2hfuI26r3DCJL4MaG1BF5OkCiOmwWlNTy9Ulx9dE3fFzT7t0TbgJXDjV06VayhtSOtUzBjCa1HFmWo0IFnB2auH6giRHKCWGDDiIvB/bfvCDLLTM/dFITLcKTPrvnAxXNeZ4hjybEayf7S5+4ney7TDB1cTUu+df81ee7YGRV16XGMOy6jANvsSIIQeYwYl24skLJegVjuuXtIpsWmW+zZxYpQHkmM5CJWPD2bsd2XbHb3lJuAPolYrRPsqsdkD2hfYQ5uORghwrcE9RLTfkXrerHOZ5wtGH75G7he0esd8+We5ugz7hXDVcFldI4Zjuh0RN5f4mdf04sNUgUM0kPMBWkMkZ/w3f2e0zcls95QXy25/SIhMB6rcEbrpVys3eDBLRXnWLcod7w1Jeiib2jSnP7rgXefH/jmQbDSAls/QUcnopcZtHOascPuW+rnkHoRt/Y1HAWV7x7na6Rdo6lYCEE3OB6hS3yw73kJbsmnG7pUT3Zvv7UETjbt+B6Ds2IE2G5AOAv1EDAMNUevIB4vuHa9mWfpHUNNQZzO2dwfsN5A7t632pCOjkmxIFLx1Des5+e/u2HC/+3Pv+bsTJEnCjW/Ri4rzOhTlE7Mb0kdaFCoCTDhshO06ondH+8UDUIRrpyco2e8F/hoMuGTSEPk7Pqej2tba3+YgC6tAzvS4zuKamTI3GDhBJVwkiE7ycJPbqM6jCSRxU9HN8pERopLm/DlfcXurmD1oSb1MryZxvO8aTMcCEd/nE1r5mAe4msHOcwwvVMEWDpjWTmBuDdSK4kaJP4QTvF5u1PPsXS+dDeFjacDLaWTnccs5imzs4RxW4DnT152oyQJrgGvJ49/nKa0XUvhjBp9Sefi+/Jg4hG0qaKvLMoPJm7EUPeI6BwtDZ6fMboIwVGj1haR+litGIeGXrqYTYM/urxbTde5yD+J04tZ65ISVqi4wRM1UeZSNwSj8/W4d6Czk78sdRGESfNeldBnzOM5qgHZpnC2Y94v6FczjuUOIULiYIbnBdiziMoBaJxtQjmRTUMmR8pOU4sBk6fkfkQvWir3XqpkUqkkS0fHrTAiIKrUBFhstSawijh4by1Rykn1PYwJpsxi6bck3hkzB4t0KosuYNQlcbacfGvHELxuwDeW0Vxghw2yGSfOgUl72p0bXASsf3jBT753jp8kWDPiD+mkDqi9hu3hwM3tjtp95q3kxcWK0S5IZjOybE6YxoRBQDgdWjGxDnrtrkaDkoLc99EqwDQlx4cD0vNI05QwjAhcOshxmJQ5aZbz/Cqi+C6hinqGXYBMSwJPTkOVuu6IfcHp/sBxd6B3RGBnbQkde8S99xFGBZMdRwzDJMOTNsCLl2hhGUeBHeP3ZEX3zy5iVLgYI4MV6QSGFM7O40vqsSJzU81YM5w0JrLoKkXHd8hhTaS305l4rMd6rMf6+1K/T0OFx3qs34f6btDY+xKuLPEvQ747NjwZDdHcWZFhGZ/TFjO84ETvYgA3AlMm9EsXa55yS014qflpmnOeOsO7mKLgpYOgD4puJ7mRDV1SMTc+TbbAhpLW18SOZRXXGCsZ5xFV5XzuFrWM6RsP60fEuoWNReaSXd6Syoh0mPPFcM/+Zs7HM8tlltOdtpSt5tMXC8Kf1fyLXwsOXUe5bUk9Qzj4FMuBu8WeWGb4jpcQW0w/sD+VRLlhGTumVUDj1NKDJXbPZJ6i8EvsZJPeTM/5YR0Ru93YoCY+1nezA+HQk0dn1POa9V5QnPtcDD6293mwDekrl1i2wBPDlKKQyhn7KKXrAj5+dsnL7z9nXRREZ5KH/T27rmTuGABmyeiWlqaa+HMmGVlmc6QX0VNRhCOHSpMQ0jUx8brjOk859y65KW7RXkKeXE/Z5lfRgH/suIoLhu/mvF70fJgHvLqrmCVwakL8bUqyzPFljrkVvBlbBscu+9SSbd4n4DkruUvKU+uO1FsjbMluaCj7JVdBzmo2R0nD0hEUVETrjRwbxx8L0IGk1C7hriJpArxoiVAp4aJHNh7MU+zzEvVv5hzHm2mocXj6Lem/zmiDiPXYIIYlgznS9DPmokb3C64uznhoCo6bE+Gdj4g1NvLwUvde6UnNG6/g9OBRfNUQuuhPlVLfW+7KHd35yPV5Rh8r8jBC+93E+OhLRRR5KJ3Q7jtuXu9oNzMi/5axT9hfF1zJkuDCo9qBPYyk3pK6qVmxp9y5/jYkezrjeXDgIg05KhfbESHGnJfPfK6DjNopMLr4/TK1c2wEB110vAvN0Qi0lqwC1wOOFFbSjpa0LjnQcxSCZ7nFzz2MGPAThxMwU9KEF8hpiJLlgiDwp1QKZyfyAqekd2bt39EwYTzsualnWAcqTDOyMJkavqx9jfHCyWvdNXqKesRz4wR/it1zlnO3kXevvK7M5EHPYtfYh2QqInSwvVYSjxE6cJMSb1IvzFVHb3MqYSYgnGMQdJ1yIQvo3kVhuHhBZ49Y0R4rOpdVm/jI3IP9SNcHiKGjClzeZ8bcHXYHJ8xitHN2uWV6dMC46Vek6dtqShUwR49bXDqAmYCFMQmxWk5+HqOPk6TJbYiNKdFdQa9aksuIJPVRWYx10v9unFgDnmrR0YpgsKyVYXQeltARQ2uCXUgxePQO0Ocn78EoKsEbNOX4gFbnk3VgcBMn7RQYI0PXTA33RPR0Mhf3wfhOxeDooR5d39GXbvs8YKIWYduJQ+HF8aSOMMJO8MfMZeO6qWqUMpxahlNPk2ni0WWV9thCsBt2MEYkXQBJz1wkGHPAfcSxkCyCGTqpqCsnBXKpDm5q25OKgt44JYeT+AtGZSZYpFOsODiiH0pipxYRFiEMkRsYdDVNPdLrltgbJ1inVAYtsglsaaKKunYNcoc1NU47oN2Nom8ZYge7dGRbTRF6+M1ApwvqwMdrR1ZPfeIi4o0aGLI5P/vBh1xcuKbbTffcSEWgR8v2dKIdR6zzS7mDEUn23YHj24JsF7KKlixWa5brJWEeIZWaBgju0DlBgLaOxzhgh5a+OPLLX39NYX2+/9FTvhcE1BaK484lhBJEKWdRTDm/w3PQooPgqGLSsGQnUk7FW5TWvHlTMWqPxHMTUIXwe6RMGYRH0Fj63jL27y0wYeCUHi5ip54ApZGJoFaTskWpHJG8Z2p0rY824/TF6Gw4cew5hieBkWivRtQR7WCp/QfmnrPV9OyLv9EzyGM91mM91t/J+n9VB/z/c7DwqEp4rN+3euO4f19CcAX6HwQskWyrmst3Cv1EsEguUNI5ek+kUcD9LpgSExxDrJo3WDWwmglSodF+TzkqtHLWBY+gbei7PTdFyTBLsBceZl1Mlge9sSREDFaxyQYWxZw67xGyxiuWqOWRzoGt/QWqhODFQOf3fD0qPs1jiosTp6PCe/fA+cpw5q8oi4rAS/jRz3KOs2v+67/4Bn+0BOGATA7cnHK6rxtePhVcXq0mdWc5bmiafuo/ZNJQNe3E8UpUihdZyrFAGAekFJQOzHhVk7Y5Ku1IS8nG7NDtwKgVp6XlvBJ4aUokIrbLluyoubvSXN1mPEQtgbE86BMbT7NcSnQ5J/MyvpelHAuBDGfI2ZcUoifeLvFjDz8K8dqBtmnp/Pfx8LEf03cN2kWiGygPil5VzCrFRVhx/ewF4xvDaWeJjilhdsfybMGtg67LgO3rAH7sc3kOv3qbQJPAtkZ4Dv83mwCVpVN+dx2IkldfLmnbczIqMmnZ6xTVCuTcsQYS8mpPlycsnkrW8wE5ppxmLamVDjgHL0Nu8kvGuiKsN6TBnCxJWVQxD7EGF7mebdG+ROcVg7ki++SeZCyoqxPLj/8h99ef4/3lgvFZT1BndB+5VAnYdiPR6gqr3uJ/4GwyF2hnB/cXJIHEm43QC0zfIP0l4bWT+MP8ScpQOzp8wNk8ZjVX4PhsnZzUK550fdyJfkhpN4Zqd+S701sO4xMUR+LhjJN9TehdEgmDFw/YCEQ+YnYteh4T1Qsqveej+Ir4gx4dW9p/G7LZHZkvLvjsWcx6FmGDDuvAjNIn0zG+06S4gcIUW28nu7d0+05lqEvL5r6lbDvCVUaSNbTekU0huW0KEi5ZBh1P/JDg+QV56AY2TtkfcuyOhFmASo9szf53N0xYzFb0o8+2CAjrO1QXMY4u0mWL5y3xxyWRg4FMWLzs/eY8cPF0TpbRTN4T2XvM5m7mJslnGfksJRCKum0ZWwcC7JlFPp7nE43JJMnuRUcrXASgJPUarEuF0CHJeMJbJHSjJGwFfevsDIqji+bosileRJiMiWXoDmsJ3XhAOsigM5s4SMlR4o1i2gR7usaokLGd0TjvizAsM1hkHlHgsa0rDk1L64Yeg4MfNphO0aeKPMvxFt57QKCbvvktcaZJdE/mgClNNIFIDpnCnEJIDqg0RdmEsrzH8AHBEYKFe2KpGNxYwyaYfo/xIvJVMFlHytZSVgrb1RgxInKfwA0Jpmga55UC67soRneRB2in4nBQQBkQuUM41FNCwDK1XKZu8hczPw0cKpc46dMUJ+I0p6haak+QJc5tMGNc9g4fwHx+hqy2WKnQ/UjRlNPn4rtYTfE+vcMaQVnaySqi0hLjO5l/Qj44WEhPGzi+gp0AkFKPDP0U34CnDXowNG6CmwQTu2C0EAf7SQEjm5jT9oSRHSp1kJweM0b0Y0E5rAm0A44o2t4jjE6IYIEvE1LZUWwqhq1m/odz/uSzJ6SzGdbNao9H3uxObMuDO3cO20EQKlwCp4uobEZDeeopyyOFrNgfC3bHLWfPnnF55iRIhh7nm/KJ3CegXfJDz+b2yL/9yzuOXsT5LKTOUu7bnsPujmgc+N7VC56lS15n36Lf1pSNoLsfGGc1+6PHcag47jqOlTd5uIJZg4o85OjUOBVNp5D+OKkexlEyDhF+7E+pHrJRiECg4gEH9uiqkj5MJtWOg9wI5bgjoNoSM0j6oZ/CHqa4JcfUMAFd09C1NZX9mmY38jBM/onHeqzHeqy/t/WoVnisv8+VDjFJGk0LOPkf5XzsxXz51Z7bN3v85gmNfmCVLwgcb8mxpvwe3yqS1qNbHHjuwNIhGLcw8060Lpmqkci92xwPNL5PFcTI1GMTCUYXVmA0vrOu+i66XFLlguEhY2w3KNGS5kdUqBCHnl2Zcr22+F3Asoy4O+vJcnhYWGZtw2mf8dvxnh+srljGCTfJnlRc8P1Fz40f0P3Cw3YCNezoHja8PcwnlWcg20libq1ToDoLt0v08hmCktPUdPqTfdpx0+bWqQrOGVTCGH9DL3ZYmXO7FnRtyQflGjM27GXP81ryMDdctwnfqWpSGF8MLgPTUgZ71k4ZbDLuVyXrIuYy1Rw2b/iLNw/82S+PnIpb8rWLOUy4Vy2Ft+GFWqIShekk9cnyJqiYzXoKCgIPZr7ivnGqkBpxuKKZNdPmef3kjIE3U2+2l5JPspThvOerbcftheSZca8zwk8s4+0V5/2G5lnPs7sIdaXYvrzFf7tGe3uK3eAaJ1TvlNLOhz+g7xU2qiceHLHPMuunRZl7Xk+8EBX7zD2XmBdwfV4zTyTfvBsY/BW+miMjOaX5efUMrX2WMfRjwOnbHatPSlyu32wVM6s+m5a7XebiQ2fMnm0JzYL8+wr1VY++z9iXHd9LIurzSx6ShnYzRyUaR0Kz/UgYaEq/p21qkkvB+TLGtz5dJJi5FLrYp3DLZjsgoiOzYY0aE+rDkTebPT1vUQdNNVSU8SsqFZI9b3j6bcReXfBJUbF0wMkk5Hh8mOz2uVlzjGtH3afbjpz94QLfWtaxx/XZgvyZ4uk6ps4H1naGPygGF+bnlqFusWzeL0FTl97mOVafoXMpDxufaj/QBD4vz1JePnEK8oDTQzf1VHY+cloYPg2u0Ek4LWnP4itUEFHEG+I4mVQtbmn5u1Mm+JKqHzl7EfHpi4GHsMU7uRi8JcpboV3zqJopj9U4IEvk4BYSpX3EaEiddzxU+Jlh5uJMI+fnkXienjz7JQNxb0kdaFCCY+D7gSK1I13xHu6SBXqSo0vhbh7OKwI9W0SuyMqIwuWVjqNL5UO2DUZdklFzXw/szYmZAwzqCDNOuD9MdTlFL4bT9iGf4BNGOBtGSBIwRV6G8Xtgybf7Ld887GlcJKDtMMZBINUUzTj4HoOLiRxLArlC5Ckq6hGdRlYDXWvoe0WUR1R7gTRzegfHLA2VI/RXD3hhhOduiiIlsgJRlUjf4mchVy+Cqbn9rhWYIaH1O+LI4AmNdT4o5fz1AtszSYbc+2O6eEpI8BgZ2y21dIAZj7Lo2DmLiZfRiM4FeU7Dn/6vp3F+dkGjDNLLpomjU5aIMkN7O1QvSf10+iyKZs+xlKi4oO+dR8sdyIYxiBDDkYNoyAqD8pzM3iIdJ8Ik03TZDMWkppBaYUyPsCNROGC8gN4BKHUwDUmqviToa5RTl7jrYHBS/5542BJn59hlj99YtPuCGSSBs7o4GZQ3OFQB8dINvkLK3YbjUfM//pNzPvr+S8J0jq7uuXuz5WZTofvaxWXQ+m4S6xQzFl87/UPEInRpGu/Bk8fSDR4KXAKj141TLItTW6yXC5Tvfp102TAMXcXxBPMP13zvajUxFI7HPYeyxpM7Pjq/5vk84ds05y+++o7dDhJTT7Tepja0VU+5VQyuie8O2JlFuGmsTRAeNHXDMOuRsxR7lOi+Rbuf2cUqec7C4+igLdZ9obnrdBywTqkzAUbd+cmmSKexO7K/dTdsj76vqDs33LFU3T192LAv9JRSUnlOwfFYj/VYj/VYj/VYfx9rIXx+mK35N7yjuPeIPrPET4Lp2el4OlInS/KVZBkv6IaSWdRgR4tnLbPKJ/POaTCU0ZFRedRVT19VlF1DOWq6U0AvPXLHROB9BKIWJ+ZnZ5zkyDyJiRtD69K/TiORH+A9rTmM1+SbnsEWNPkZmoGlXtB3JWU/nxZhovSpvJBfVy3W7vlsfo5YNvSHPcmF4k9+uubntzXb707YMZpg1TYfOIwjr749UjytuTrLCNPlBKFUJ3Duz8CPSF1jaiuSTtE4MLh7VmZOVqYspWFUJaMOCY3vUAW4lat/PBJG14i64C5piW2A6/a9MmAf3LHSHmEvuPZmzFcVHHyeporXh5/zV/9ywRe7DU/7ll0XsowFe2Eoh4az+Xuml+NpVSbgtBmpuxMitax1wlIImqwjwiNXlkPlUTiFtVWcRsnyrOFQL3hTjORhz3Js2XwWkdSGUxFy7aX4VvIQzog5TktIXyheLgO2D4oLe8HimaCMC+LG47uTh+eP6KNLH1PYQBHNl8hB0N5o7jvDxdIyjxShs2MYR6PzSa1FFgMEGfgVRedTFpJw0ZLGPnF8gb4/4BmfM6W5Pcyn2MOrTcC7PEC+XaLmivz2HJulXIqA2gH+XZreeOTZ/IrSLiYLrwpSQlNxeNfTJAPigwDhW+Jlz8xbMLc5dR0h5ICMLPftSGYteQS78v11p8NbHn5d8O62YT3rECJg342cPzfMgyWN15OsxRSdWnc980VMO1Y0tUJ8mpOWLdcLQ7aO0b8ZWN5kLFNBd9azSiPupUfj4umd1WjwXW7D1Ou5WBFtR+pREns+yjPTAt4B1zGa13dH3h5G4jyc3rdUzemKgUiOJHFKugooPMv+GDJrWzpdIecOTyA4W17TDC3jKcZr7e8wGvIwcvJb/oc/WvCPfnzNt13Pv97taY9z3Aq5HIppihYYlxcKKobUTRcbR0Nlimx00Yq+o12GBi8qGNzUr52TW4UeO4IE0jijHLvpz5MOVujiDLuGbhxpxoiiGyl79V6WbSGVMS2CcN5S9m5TPTKEiuJuS3l+RLSecz0w8wXrxZLAUWJdQ2VDIsvkGwlCjdVnWM85MgZCNUzwulmWoryIutLsj9X7zXhTIAPtgi8Zxp5gdLQM6PYdofIIVEvfuIwIy9hYitMWHlzsik94bWEZcvIbmj2YNkRmK+Sxxy401rg3bkZ87qacAzKfUSvnuVqgspEgqfELyfwyZXEhKB46tvcd2knBWoMtHFLUxQ32k3phUuxHEiVGaFIGk9CPDcOoSURP3Wm8XpCJnlY0BL7H2LsDI5i5oU0fUAUjyg0mhJ2a7il9YnAIRpcY4KIfDWXdMI4+S09PMSJX65K7SQWR8CLLCZTmwdkYHP9BaCLpLCxOHRKhXKDJ4NQoESJQkwzM3aR7FVA143s44cINGwxBNCASn8Cr8HQO3mliW8iZJR0lVZGzjEcGMcPaESVdtMuMoF/iPw/4J598xGp5To9i+1Dw+nZLeRoJgoBOQFG3aHfYY6dOcIqDkUWomPsZInSBCYZ9I7m5v6euH6ahighnLFdzsicrnsYLd0FNEM/rT+e8/IPnnF+d828fjoSjJfFDumFkX1dc53NEYrnrHV/UxYwKVGOw0tlZCvomweBPdgun0HETyCRUSC9G95q2HDkGZhrWSTfAcGkVibNujIi2nfgazqoj8ogo8ImEZLCl+96ffr1KQpRjM5wpZkHKbV1THwy6OjK07n8gHfE2BH98P/V8rMd6rMf6+16PCoXH+vtYNj/QlzOy2PD2rma/1KjsgiefrTn+skc8SNq4Zr08nyIjy76hqgZkYIlqMcWVe4HBSyyyThjacWqCH7oFe1uRLmpkG00gvD5uJz4VXopQBpM17B9iGBqMcAwtifQSwkqgRTxxxbLFLfV3C4pPf8Pzm0vibiQwA7NOkQ0xzXxE9RG/3uwJsoQL10C4aO9DzkfhksOHhtt2z3HwSHqf0CUpyJbX+5EdbiEaMLsIGGZHPCMxgc9TMSd2BPy2naLXpc7wVc2Z7Tm1CXMn81c9TwqHr3JRjiMPyxBRdLwrM7pwi/V9ZlFEHFv2Yz9t4pO+pXUqXRfQpkN8GUz9yakqmLdPeLaYI04J23c9xaKjGyRdKNh7hmwIqVzKmeqn6L+kdmt8OzGyhAyYZzXzIKA8NdzuYq4vttMSU48Kv494vpC8K1wMpeR7+XKyn4fVzAWGMSemS77mt18/54eLlH49sIp71oclpeshrHstAWN2YJFk2CDmDp9B7GAQEwB+nmZ4veb+1GD6kSgYCDPn/e8IymHibRQmI8o91llDFEbsd4ptL5GqRKQOVO9AFCMEF6S3I/6PBhdoR2nvUdpt3ARXUcNVtUDPfdSpJ1BrEv/9Jj+epZiiwStSYqWJbI7ZdwzSEDQBqyohn8cT/DJ3z+6pA1yO05DB2etd/lxbCLqd5k6+xtoN91+4tASFNw4USUwTK65ejJz1Pr8tNMMPfT6+bRjTnl4J6ruO7MmSbCGxD1sic86z2RnlteRNcUPRX7E7NQSe4PjG50//1OfjMZ2sNG4x6ODvbpjgOzSAUQjpufaPymvw/ZHudOC3r99yuzeo5y27BM4PKdL1iiFkecQqWJN3bqizI3A29ESgPBeOIInbM/bjnspFLzpAw+9smFBHXDyX/PD8glW+ZpYKjH/P/129YizeQtki1SVB4NE7absDK2LQxwo5BATWorWdYi2SsEVlmmGUtGWAClxEpGE2CwgSiTi6ZtoBTk7U1oWdWOzgIhBbVOejQucfCunlwCJ6ysyr2Y4D+VJRtClpX7PXNcVOEwcJi7kk3roYDUtTl2ROquW7SD/XEjsmgURaB1Y0eNKS+hGzKCZJ5phGcNgeODyU9LWPVMuJnaCrhrGRKPc+lANy4ZFMkZBMkYm94zCWHvWpJ3RxFm7Dbj3SIGRbNRT3BlXn5M8EwxunbDiQeuMUnTiaJbPrARMP1C7GpEzAniZSZ5RoXl7GqEuPvhGot5qxGBjdv7fvf79QA77fooSL+vMJZEzQOzq/fO+zsu1k1ZAnfwI8OrbGYHeMfYz2a5YO0eJiUtQM1ZXI8AFbS0ab0rcDwiUkyIgkk9RtTBwMFPaBTZkxS0KerJ5ORN/b+2GKCpLhOF38nYtE7QSRn1GMBYPpcWaf3qVGCFAOKCJ6tNB0ShH7ikDMiJ0sQ1oCR2AdV1P6x8CeoUzw1Ql/nHGeuChMTSgrMI7w6uI9BZ5LVZil/OTlkutFzqANg654c/fAZlNRVRYnABCRo6AaHLbX3TSMiyB1B35wXAeL527EoSIzmkKP7KsO0/a048Dr+xPrcofM16RZShQs+Ac/C7m8XnJbNXy32bPuuomPULQ9t9s7FlGACD1+9qcfIO92fLPpMS6Oshmpa41VDZ7z8MUOfqIQKp7Iq05a5YUSv8nQmwAbavw4YRw92q3jKBT4qiMNE8IA8gWkMw9fOzClm3tZxDROcRuDkCiBT64i5t6Kt/eWd/2R4ylBBA5E0zi4L8KBHB/rsR7rsR7r/+dDhUdewmP9PtZ843EMGvp0ydMuxm/uebOfIz4aEDNDerrjeAqnpYeLBg+CeIpc75w0YLCc+h3zeUjqhRNx/l1juMl76mOMForxU4P//2Tvz3pty9LzTOwZs+/nand72ogTXWaSmUkWJaq1ZBuusguGr8q+MurCgO3/5TtfGTAKRqGkUqkkkSyRIpOZzIzuNHGa3a529u2Y0xjz1GUBEsAUIEr7C8RFRpOxm7XXnuMb7/s8bxyaXHJrJ6yDGFOsKLtbQjNgrHtas0SWK0SgQNzqdL3kaVvy/rGuLlMn6r+xHTFEy9Ef8aqCdeWSzwZc+zgtHsZR45fJG/4Le4mnTGBJRx6WzCLB88cxh0NC/l7S36nKtqRvFfPK5WXfcJZ0hE+t6cJNUxc3nUovKGikxG41nEoB+HJGXTHIBqrewOxcXMNAKBi44mpZSu0ecGtmXCQtobZkNRp8iI/4G51FG1EONY1jKMw36cZjlUGlzhDaEvf5wOPG5oPXYq90qrqnTDI6z2OjvGOOQZ+qdG1LbEpMU9Cpyypb9fpVdH6GIwR7xUDrddKq5zwKWCqo5J2yJvi4atEiHCxp8NgfkFaLaza8PCjLGgRpSiMNouWAbS9o0ltOFhKZhPRaz75ckA0ty37EGV3suGNWqltwDU90yCZB813WyxnnnkQokOGo9PUjTWUyd1ycF+fo44jTjEiv5uBrGMWKMd5R3NVopUbV2ZSzhNCLsdS/f7JgEVZcmjqR5mAFc7x1yaY04InCMTiqO027cknT7VQTtgcbJyxpQwUcB/3eZhZGnPQGuV7gBJKZ25Crv9cLzKGlVBp6tRwZDgyZZH/T0xYDTTBwjCB1U2ZOhbBGUlHihjn0MaLXGY2E+7wi0zsc95xFm7JvDGLDZ2X29C8Sros9WT7n6kMPmUncHFjYzzHnNrqpLumVrKCfzHzqQjZUrATRM0iBYyk3ac2b65q379RrZsA8UzB8m2aj9PI2lm0RBSFyaHEci7NnAbMwBvctolRw/45KqzFqg2HsuLpSRo7f0jKhW7X8nSfPmIcxFfpEBH2Bx1/JmkQdXAK1KUlphYurVVhqm7DVoDSneoP6AnhixB1sRnugtUx8EU4/jMVYES4NXM+mVccdqyfoHcZOUBU5pqJKGhqB3tNa6iDUczwa02FeWhmdOZJWLjY5s4X6gc1phjXNIUAqsEloUzstdTpOPAQ5dHjhOIH3NKE2bup2P2eum4SeSRCE2HaApnuTieAmLbjZtx8BF6bNqHR7pBi+hhmrfnpF4J0yU4diLSYy++mQ2ipoYK20HiH9cE+7E5itTV8adGoDR0pQW2ixRyf3OLqK6Su2g8HyExVXP5CODUVfYlf95BX1ojV6ZFCNSjHzMYI/Kijl0KM5DXqnI0alvlxOBgFHV5F/E2E5GBYIM2CQctKoqGVAo3tUlcbY78gPS1xfYowqEaA2VD22OkQPNYOhmBAW201J6/TTx2qrjk154FC2U4fH9jXKoUNqIWtlH/BLWrOgc0w8S/X91UG2n7astuFOnX31OFYbDXnV4ykqbqAcqiriVU9mh5E5huZSDeqQbE9K0FptjP0tQ6MWSSbnCoxh+FT6HenoTlpGTHfq7G03RwgEv/OjNZarUcuaJjtwc59zVNvipvj4fVXPg12Dbiseg4JnKkihp4Ab02tAdbvU2k+BJfVBgSrd6YewbHWKbiB9u+Vre89ytmQ2m/Pk0Rkz3+bl9R5vaGj0kfxY01UdN+Mdp5bJI3PO2e9fUmyu2f/JFdflEXlI6ROTwelxjWxKjiiiscomtAoiIRUwUm0OA6zORo+7KY6lPMRdIhBtN5lDdNvHjnwiT8cw6omOO4wGut6jzJu6gp/isWkbDGPg8XpEqzyqmeD+QzIlJdQ2eRSqFvSghnyYh3mYh/lfmoekwsP8pzDppkNb2bwzG56jc+2pg27O6low00wKSjaHjmZ4w4uzFxiaiRGWNImKuSuweE+eG4i+w9d7jF6j0iTiWUMg1OFITmBoLWmmy7ouukUQM8zFVKk2xQmyq+ikgWUVzI2BzpyhlQWNuZ+A77O4YXjlEEYj111OefSIvIAizIhTk8Rv6PyRbgO7Y4x3viXqbO7HcdKzf7HqKd2QP68k+02GdqvkbcpWkXCde2R1xCeRyeVMZ0wGjuSkvZwSBLGmsx17Nv2OIQ4wk5HUzdVVLDN9he1p7JKB5UZw75UEdoloQoqhmjgPx0XPWatx9DOC3sKzleWuwrsyqMsOewbVrONGbgkPOt55gjuLOL4d6XOTXj1Ha3tS10NTcMvGpRy1SU9vK0340NOOJcNwMtWyVfLgwm2nurZiZ1m2xtGp6LceUhccy4bNvUp9jzyaFWzTiJt7i4VQn39Cc61zkJJRXFLOGh7jUWc+nXzDMVvhUYGoprOK69vEc5M87+kUv65tcGONWCUfpMSuRhrhklQCuy9xvQ3oDtvUpioOFKqyr+L9ppwA9LvDiKHE9X2C8cTG2Zwin/2Kc/1nsNhwFi3ItBZNujyea/gWXGUCA52zuOVlq5EIHcsY6JVq0U5wLyuyxKWvNRYLVf+e0v4Ylk02WiS5gdmODHpJGNucOjrbbc3dRp0jBKbfMSrrY7tmFhd4qm5yPSezNshZj/+u413loDU6UeTinZssAxt1zDC/MnnWQO6M9NlAe7Spu5Ti6CNuK9Y/ifC8AN3RP17A1hW6UABTtcxWtX0lI1ALIHXlPHLYD/zlt5KX70s+ewbnYsmnVUBlthxMycKKJp7e0Pe4jqrl21MyvJIDVMVkomu1ZjJO/JCVVE3321smLE8Nfv67F7gzByk6ir3kV9dvkQdBMFvQzFWUv0FqHbaUNDsVuzewDJ/QLagVosQYGeRAqWyZSvpgqASCqnYoSr2J2RsYRsdRNFPEWzNdBiPHDy3OTJ+Uio0Y8Gv1DTiSyI8uzRz1BtVTGSaL2CAgxHLmHH5oJpcmqrNjO9iFAiHoSgyLM5qM6s2oVdrHboKQKOqsrymVn1Iq+pM5oRpqDvlIlllTxGocMtSX1ZiFRIGDPesJfBuhrH+qk26YaMYSc6hJ6yNkBrkJ2VF14gPC5opSb/HdiFy7RisEzgl4mVrG6FgRnJ7YrC/dKQqU9HcYmmTpqiWOMj6E5PWOPvfQpIXptRiWSkeEUwJEGzVl4ETv1OHXZAx7NF/H9HyMoaFsc1pZ4lgxg6n6QkuM7hZdzqi6ESsdqfW9woximxly9FC6gM5RCQ5JN/TsDyaBW7LQB8whRFYbRnvB45lF2tdIDojaIrLiyTYhKh8hFZn34wZO9cOiWG22DUTToGsRQ9Wgj+rrqzE0Dl2fMgyCvi1wgwZNLzE7g0ZpbzQLWVrIek8d+pQ0CAWMKD0KFMzRJlwXU/3k7tgS+TEXJ2eY+pJRgR4HRRX2aB4/YbP9QKnME7KlyeTEpvAcHctVKk7oO0EpBvSxwZImclQLE4kmDOLIwm5G7LrhqJYKbY+eFNiGxrL0KS2lFm25CL1pe3g7HCgsm7RMOVQN69V6WsS8vanJrg7URcPY3GBOW+8OPfAZc0VE7tDVImbaaOuUiiCstXiRwFzM8GYNhkrZuDptauNoNlZgTURX9ZZ4MKDMK/S6ZwxctFHiWD2W29LmA/dtgScbdo2Da+V4fkWeapiRO72p9IZKxTzMwzzMwzzMv8+lwkMq4WH+Q503F3t+Fj9D3Oc0o0vTrHgc5Rj72WSu2iq9+aElPRgsggzMgeJ4pKuVrcykblve3Vds9hWfPNWYzyNWnTslCFovp7ptcFqJ7Vc0WojWiklZreLb2V2BSAwWlo/0Mox9TxP7xF3BUQGybkKsuMG70qj0kbqxON2umNFyp5hPrUlu2gTC4kN9j1Ou+bX7HUapPgeLfTFOKnoztjg/6VF1/T+6srm6yojXFTN1GRc2XOk3JFdKf+lhqbqobhJlDm5dkBsd2eCTiZhOH/BMg9rKcZOAwmrJ6oqxU/XsOX4gWB9CEtdjHFs2aTnVKDoxTuYvBRwM1WWwYzML5hxmN5P5zHVbiq1Bm9vMg9lUKx5MneZEMF/cM6Y7jvcrAi9idBIGxyCyZwxmTyZzZDvSJjuGVnEHRh7NdUoGbpI9tqsxxBH6MaczatqkZ99ouEd4tjIpRojfntL96C8IL2YUr20qccSevSdcmSRbm85saNOSuEwJ7ZGdMVCZO6w+YGPkbEuwi3Ayop34QFJzM7TMZiNp53K/65lZNW4s0XJlbVcXearyYTCKCns9EucWR1ex8U6Zsee5rwxkDbtxBnbCuWcwpmqxY7GQW2S8JshrDA4clA2tkuRvaqyuZN/EdEHNiesR6AO+rrM72ujCwdAHzpR10DLYthrWqNiBYqoUm0i2mc2rdz6yzljNJG9tGzvK8NOMYFCXkHPefxg4XemYg1p9FAyRxDpEuIOG3TY8/nJgcX/CXz3b0X1bcHNf03BKlTY0yZZuZ0+cM/fyKcZCTv9eVau4sOLj6Vi9NtkXSqtRFAVczSH1d7y8vuPq1X5iNDiOzjxvaC0Pe27w2PaJ7JCqLoncOZ7jqw0ElWwohjMsWeFYITLvuL69I5EdP/ts+dtbJvzBo0+4eHaC4eqIWvDNu7f883/9nvLQMfuyx/CmO2dsb0AqEMlNzRA2hJaPP9qkVcOuTvEUoT8KsHpBqyAjtoNuj5Rty7HOcTQVi4K6HjGVsUB16vt4UpT0VcbQqli+wSL2qdIamQXYpuAkbmicGbEV4WkeKA7COBBJg7a/wxY2/VISmB2W5jFIl0G5Y8tyshzYplJGwlAq36iNYZuoFMnmrmd/kyDzEm3Qp+i7lDVOqDO7dDCMEVtpGfOWvesTCoHnDtjeiMgkoe6gBSrOb6NXOkFZUXYGkbJNVAHC0DCUR9WZUboa7swmfhwjwhG7jIiW4I0RCxsS9R1X0I6+mzgVql+vIk3WpLZU8X11oz5iGMWkztRQTAPlDFHwF3XL3zK27aQ0VKDAamgw+ntMZVcoHQ7NLVbgU1QerT1yog7RKuYlaoxxNmkN7bjE2ynYR40zFuiRzaK1KU2HWozYauNpQzVWpF1MNAiqUUWEWrJCLWlrekcwFZyEoBE6pl7hmAogA+MwYhvqYUxHt2dTR0q31A29g3BMVEBAGwRG5iD1o9rqkNV7zDaa4D3+ZOyIcFyL3RFqoVgLsN8euZ8dWMwjPHPGT5+HfHHS8/WHkNt0S3m751ZI2kptJ0scxyd2W0ZhUouP/SQxDlNETgwaWtuSGi2G+nuGyg0oOGWIp6mva8WH61f0+whTbZkMF8eNeLJeUBoat+9aml5gM/BDsuV//Fc37D/cMqpQnSYw3GHSdI6uQdGP9GU9dZw0s8LxP8JQrNHCCDuF2EBbLnHHHKE3KDWDihn6XodpGFSuQdmNJE3PrFcK4oFOHJhhTZpSa6jZZj1rXdAoN7FWTRpJshDPtOgm26tKyTzMwzzMwzzMv20ekgoP8x/jnApnOjQ+Lwe2iXpsVonHdIryy7Zhe9rSDyVNPiPYpzwORkShmFrqAsvhvuzZ5OV0cFH2tbpSdQgDo5fs1XNX68LQo27rwtkJ0YWi35fo16p6OuB0VwyXHqYpsTY2eRnQXWTM9yHWbkZkbam0hLZckwYZp/0CY1Hi1kpfdcJo5XSzgadfzzjaFX2YcHWIsc0NQXiKOM7om5Le2PH0wuL+UvBXu5zsNgXhMngubbHjblPzXS2Z/bhj4ftEpZguhVIzQDod6z7gkDVT8tOofXJdLVL6qTIaq/ON0IiaxzgrCVcOudbjaCNVK3DtAb9zODg1TdphzjUuH/kcbjWKsuPk6E+XmblT0CYxM1fp5dUlvmR16lO8Vt8bBa9XjLp+SluMKpJvjQzqsnAIKRQIsbyZgOhKF9hlLeXYTQuXOPDZzzKyo47ebXjqXPBdUnCQM5Z2SRKU9JaFF+V06TmG1Ij0jMfZjK9HHddWl3oxs6GjVBWEfkBW7XR2uSsOjPeSfqaU6hK99clLQdbVymJO0yn4d4ZsBQszQEssXFfV4Guu2g45mmhjwqX+iFdBQX+3Y/W5oD2UOPMe7YPDZug53eik+j16H1OPIxkNxc6a7GZdWPHrtEOYJSeU6O0S35RonU9QDMRBgxwcktwjDErWgTZBz9uyRO0qPMeiudF5vyt5nyYkNzYny56DVU56STHvQWvJ6SlvUwph82HW8jvNE/yzW5LDltY85WqTkGQ9b3Yuf1CVXP/6lHL3PeVVTfXMwzgoJlxNl1e4Jys+/8pkdlYwVvPpAro1BkYxTIll1RGXhkQX2sdwQjdw3Cs2XsXlhcV8FjC3g8msMshGHbIUOADfjfGCENO0P1Ym6oFI3WYrNMnQsT1uaNyBny9Pkf8O2LR/52XCl188wrTmDGPCdnvLn738gd3bknGXkrfKeznSnguenZzhGcpTqaFrH3s2XedTHFL2aU5hRax1B2fsMS2IHW86EOe1Ug32NCryYiuGgIlpGyyEArVk3GYGaVWiOyPNkEAbE7QZhd4xtwQzO6LrdCLbIlOxe8tkcWqw6gbeJSO7TJ1PR57PelrHoCwVq7/CDdqpd6MNJpro0J1+io90dNR5xYeblPuDUkGWDEqJqGAXKuJv15hehTACOKptY09ptfjGyNi39O2IVBUGt2WhC06erOmTkCqyccsttpvj9apiMKPbJ4yeQxDbRCcRujXSayEEDZ5zSqhbU3rDMxwiJIZtoRmCptS5qkbs1ZZRpUWOI4Om4loC0zLQDAl9OdUtyg50UWAMNsJfTEkKoTkMjWJfKKCNpN/3HPyOwFmBe0/TRJi+hNpFbwS50aBZLTPPoNZtKs1k7tXoS5/tQS2ZJIbrMI46QWyyq1uKUsE+xik2H+gWka/OuyqCBaPSfvYjbVHRVO1Exl3M5tiBSidIWql8xAZjMcOYICM1hlB1D0Fv6MTjDFtXqk+ll1SMGUGoYDERyNQjT7JpoZJVJX/0y19zOOz55PFzovMzokU80U1/7F7yvPTZqtiRb3K1y2jajrLRsfUR3xcsdZ12sFFJq6ZRqZkO0bekKk3immjKMiFUP+2U3lZXU5Dd55QqVbNw0bSBH+qeE90g8CyWnsn35R39lU69yykPKZ3skPKOvlK1F4G0RgwFUhTGVF3AVOtqH002E0vCsCW91HD7DnNsyctx+uXs+j7uQsd0e4SmajoCmXRYqg6jjBmHAc82cJVxxBgItZrD5oglY1wt4dg3NIrQq/XUvUDYEl35dR/mYR7mYR7m33kelgoP8x/TXAzwq+6W0yGi+axC00o2rs5jdfjS95iJRbU0qY0dmzTg3PXoDAeGBH0s6Yce11MgdMU686gKjcAoOAlGutRmlyiFfMaoagy2UqBrtIpldl+hX+iEPhT2wEddmzKxdRx8gbNt+XxYkFVw7++xtKcUwXv0WrBRl1tdQBvfYat6caE02h7e/IrPjCe8TU2+7gR/63yGCHbs1NmsP2NxkvHz/wLGaMU3f1SwzxL6q6foo+rJb3jzrY/tuvz4Uj3fpySOhaJ492Y32Rq01sYSNbIsEYseM3eny0ll/bKLD5j1OW8WbwjsR5i9hhMeyK2YrhS0cYd+YzKMJrvu5iM8sXCYD+PE7VqYivO1Z1eoh2nBuBiYofgQLoOz4GQtkU491XdVKKNxJX7rErQW+1Etc0xCpZVQ16fCZWFN0DSK9z7WZy5aMDDfX4BZoTc18awgMzxOR0H/6AibpwyP37COG2LfYKGtKJUWU7vHH2x2Cgju+3TNPU1eUCnQfNYgjHEC2hd9g1F0eJ2DdHPKMaO9MulsgQzUMU2x7wZKJydwY/rOwtgX9EVB+QG2ZynjzUhz/R7xNOYbBUq8jdl3O1anHt/95UD5wkHXbjkJAnhj8SoZEVNd+sBY6mRZQ+DO0eIeK9f4sC/QXwhcBSoXOTuViC5H5qoa0oVs6x5kRtAFk8nk5W3LoG8J5hZFuKLsHaSVkxsVuvTR2o66inGe16wGk8Pg8MmgKhQm30cz6uhmqmDc/dMNfx6VvB0rKs1nfugp5l+zdC/pnDW6ozE7OeXLz1wi/wRR2VP9fLTbKU2tS3XOtlj28ykRJ/UWxdtPigFh1fzkcuDpUmBM5yS10BrUS2YyB9rBRzOghTMZ3xR9odOVWsCk3SucgM2Xl0/oBpvfvP/Xv71lQnRiTAfaNq35zat7rj58wBAhg59T3qmfo5YwXhIo2KLqAkUeuto+WQOHoibLcobWZVCR+b02ETVzP5lAhZ76JHt96saXWo85eiyinpoDjqF4AyObqvy4qRlUZFxyGJVbNKO3WnJlRpjbeO4ljVlSlgLXlCy9AH92oLmzyFS6QAEJ1idIUaGbFi4FiGHyliqYo4+BGwTqIplqLLmut9yk28koYDghoi8Zugot0nGXcyxf3XwfaQ0TW3exxA5jcGjzkuYO8r4k7Qz8vMA6tyZnrWFvwTMRuc+FsjsUM+4WYNoaru0QPAo4GS0Gw8d3HJZKlSk8pKYRJcdJF9kK1fEXaKYgkBLDj6hNi7HckrVqsxaDFkzgw49rtUK5FxgMD0PBMXHpZInWtVOP3tCUbkOyjGJaVeDRcpRLQOUSunqk6rop7q/ewFR+YwwU9LElrUJ6w+PE0jloPYVabIw1Bx0WYo7V99QSrMEgPtOZLzs8pfVUgAKtw8Gio6EaQLN9zhY+0UynEAN9aVInu8l9Wqr6Saf4mC19p001B/UxKprv3NG47xwGUU8bUbG0aYuWY6oqLhqeZtJ2BdVRsh3uKHYa+mHH2cWax4uYdRQR+iv8cE50dsL59p5vrg/Uu4S2kZiGouIKrOkwL1BhKUUQULf4bauSHgr6oLa/LZ5T4+o6niLDRhH1/kiyGznTG/Q+49dlx3kgmAUBSXvkqjdor3L0uEVkLULaU93DMEM6L6WrfXSZThUglWuyUG8GOpbv4CplpVS9J2OCTeqNRxBZxHOBbTb0g4OoTWSf0tITRtqkPZWljikDNMvCDjMiq+PdvuRkMZ/sHMmNRBYmtgLhKPREP9C6DzWHh3mYh3mYf59LhYeKw8P8hzyLF2eUroqRu/RnB7KbAFl7eOuBD7og/mZNUSvvQY3m2BzCBst26NMVg7kjMC1C28MNqukSZqwNxmZk1g08lTqJ3ZGoi7DWYuw7kg+CETldCKmHrsqN4JCiBQ5O9PF5fvX9M94Gf8SPzhYcx4FF8Yjy/IpH+YguHXovR29CaFM6IfEzk7rOES9d7n6S0fYeci/Z2fesY6mit5SVxDXh3Ov4w5+36MMj/uJPP3B8/xrr1MLUW9IkQHxtsGtqHj/Zk0UxuvDw057UUzd1Ma1ZEckIt9AnRkEbKh29TuINeKPEL5ccoy3x9gw9SBm3BhsdDp7OOvUx4hrtRnC932Nbi8nOps60uWgINZelHyHNj7fiseGg1Qa90j6KYeKulalN2jaY1oH5MMPwPCJqlh7U5WwC2wuVyHYNToZzfvXNHcX2yIufWAyzg4o/8NI58kkU4G46UkPSFiFD0yHSmJlXEJzaiENArt8xIyA3W6S2J7AF78cC0bmsIp/yrkB2HUMwo5fFdDlmOOqir+eoLoODCrNWF40+dq2sD1DNE8z9yM0hpfzQYZ7WNNUl39SHj5X10FVPxKS6pHilXqADF2HOGz3hrPl97PGO/bzAvm64OnqIe4lxXiFyg747JR9bSqMiGzpG2XKzd4mDBY3McZRJrXfZNCnSMHD0NfbBIcsEH45qQZLjhuDOBOZJzbGVyKzHfReTlLsJxui5p5zMSj596fDN8p5DZvH4WUCuUtXzjC59we7VL3h/FGRc4z/+iuVnLonRoLc27qCj+ZKf/E7EEzfEqdRCSsOeFPAuhczppJxg6mpxpM4nji/ZKsmDrCZl6MkiZBloYFx8NFloOa4b44o50ugV8YNIvSrGGq3TpvT9EQWBEFyszillxffvttPl5W9tmaDgfUOrDu41b7cjTWEwqm59WKHpEi/wWD1y0cN26vBo6i3AbUhlz301MNg6rlC6vgTNFVTT1q6amAezViNy/UkHqGL6EklT9hybj132QCxpwmFSd5hDPEXQpXmkXp8wFtmkQdnVJf7CoNzfT4T99Nri9PM1TT3ijYrkejmBYezBQtOUxqWlnQ7IioWQ4dgRPiG2DNDVrf/QcrWX3OwFYysxFC9AaWh0HWflYsUhutviN2q7xrSha3ufQ7KFomO/A7sv0LwVjfqB2XQURYo2pIzCpmzUi8Hi8SLhC3dG5wvS5cjMV9CQgL5P2LUeZ6MCWI6omkwQdLSOS5N/1OzoXs5C9bJ0n7trGDUXW6pkhEatolOFAjKqRaQ99c4sW2AqHkVTUg4NsjkS+Gs8Y0lX7el8h0j9cxLy0qabNTiVMzmB667AkmJaquAJLkfJoXTZ1RLHy1hYKhGiYWk9WdszdClt/9HIoKmvnVRLIE+1K6ZfEF0j8U0T2/eVj5NaCjQvpKbkkCRUqYAcpPICrztkrdgL6UR3HdxzhOYzBkdK/KknVBZHTDPCVN9ZIbhP3zIq521koN5yeimm1Inv1vQb9RpOeBsJvjg5YbF8zHw1Y3n2mNPlmsF/zXvNwlH1Aq3h0NYTW0BVUtRWb2hHml4pLAv6zqcuDCLfnaizo+jZWikjCjZTcX2VUruCWTgjuZfsP9zgipjIrXn+mYe/1CkvPI7vBer0bsz0CbJSFz2DJTAsc3LzqtefVhg4c41gMSMMA3rlq7QaLLPDVvpHX59AQWUmsBoXQ6tpap227Rj8Cs2ZTSBUZVEZsxbDN6bFhjwYdNuKTJPkTY/uux9rKL1Bl9WIBzXkwzzMwzzMX2sekgoP8zd5LuNTnnWP4Kt3rG4DUqHz+jyiPv8Vj8wVy6zlV6KdqshJILBXBz6vL7j+dqTsFQBaccV6tPlIqswMvYmrqpQ1Ux35Qri0VkStarXlYeKAOdqK2K9pInXUsGg9Sat3LFDqScU9uyZC59hVnHRnbGVGRcHzxuO1CU8Sl7YvOdg9F0cXo5K02YjuONymPU44YDUN19kOSxNcLkLeRSlJpaGlDutlyx/8XkRZfMLXr17RHe8Z2hnjukHLd7z5EBJbj9FNyW6xY7GNWNUDldXQOTahqsTKGsOY8X62Y62gjPHIxTASXMds3Xo6N1jWGfZYcKX0fR9c7GVN2o4Y+gwVegh9Ha1TzLORUtnajBhLadYdC2cI0Gp1AaouFg380WCoNHLDpW4TmjLjrpaEY4Gjf4y110bJoM4n8jAlUHXP52yeczykJPcLDMMjQ2eluhlpw1VRsDyNpmr5+flIV6xpPtmhgg7ucUQELbXJdKEYdhqBkBzMJ9w5H1j0JmbkIfOWsmgp+xJ5plG6PW19xCxy8uMa6foEIqNwVKXBZ3Z0WYXqmRna+WS3Jyw3yL1N7ueMvc3+UKIXKyrtFeefOuT3FdYTde7bYdUu16qy+66gfNuwTxuCck8YPSN8onHQ3yOuz7FiZdkziXuX+qbB0h3O3Abd6OCwwJ6rC+eC+67gVt9T1xpeL+l1nWPg4jo3jPUcu14ji4KmVya8GU+9lp8YlxyNjrUzsPjcxbRztGRk/nbkbpNirU84FhVOGWA3PblTEdnPESSMRYSpGfzssbp2dWgSiWiV6U2b0tiyUoUXQUePpWk4rs7ow+urijpPeBKqOH7EfeFhrPIJDq/g+Lpbo6UabSUxe5PKLhnEwKCq3IOgS5rprH/MB666A66qXtvz394y4e4Aflvx/eZbdtsaJR3VpXoBmQQzl/HMw12FmM2GqvYIHBvLjNnnJabZMcYRMlWmgFKRCRA4GMKm6zzavJ1o/o3Z4M8LAk+SZop3qLgFPbWvEIsmtjPDd8RENk00iR8EnDEjdxuyNkEUNXdHc7JAqAjP27t3FPsCp8k5PY1oh4BM73F6dYBtpgN6q40MlY2lRXhhhK5MDP3Idl+TvKmQe4Gh+jp1QqM0GbGHG7p4gYoRmXidj7ooNyy1CTUpunuafTWRVG/2I+G8xAtKrN5Vp32yPKKYMv4dVtcy6ibn3pFRiwm0cIqXt6JgXysg3wHdtQgV0EWYuMqf2PZoTYsx6lhWjyxGrt/lfHh7QEH31ddnMJRHxmdQXwdDR3c9nKl+oBy9+vT1H1ELhxi9T1GIAnU4dfsaVY4ZvYuJwqqgfkNvsFOKxVq98c6pRItVGUhXJ3RUV04qhgp6U2Gp/62gg9Ucx0umakJrjGjSpj8O3HVwtHVWUTjZDVpREShqqOqUDQKf+iPwMLHIswR7VIueHT5zRkPSB9BUkrE64gwzdNUwyUdcW6CbPoWTTowK34w5986mnlYQCQQRdC26ExKtaobcZne7oXh/5E/fvJsqHetHJ/z+l2tenCw4Pz/jNAwgSdgXBzb7A3f3NXU2TtCd3hhoRwtXVwf2lqQpqRQYSKlFO0nbKMVNPrlapVQ3/xVX/YBV+PzV91v67IZwLvjPHJPPLtfEvlAWHkxh0ot7NGFNEbquKxiGHumqakuB5IRutNFVr9AcsYIUx2DSsY5Njaoj5rX6/lisnR5pFlSlxK0UjDOcmBOa1tKo6KCmuLYLrMBh5h+4K6/IspGhD3CtGFn9wGh62NEZ9f6h5vAwD/MwD/Pva6nwkEp4mP/QJ1dt/d2Gd1HI/H5GGHzP3+siTo4XvIxjzEUwPZvm+kgiex4fBuy2Rdg9eZpRl0o5rfHYU2lkDdvoCcOeqjfJq47ANXhsBLwueqKhR3cLCs0gHKpJbTicHTnpnlAmOUJ26KZNeyJ5ejijLiWlYp9ho6cHCvOSNk6pFDRbOzI/qNyxRaaMc27OubFCPR7PlynVvcNNNdJXBm6/IwjekYwLjP4RVa204zX/6Kc6UnvMy29t9Wis0F8M85H9JuVXxT3P9TnhYmBvJdMNcqHVxKlOPRh0lTFd5px+8Ogtm8vc5mpe4JeXHFSkvXUZNwFC05l3H9PE2lgqjLwqwBPo3mSjK+oCo7PZHiTt0NN7KafqJl9olHvwLQ1r1mE2CqIApTp7KGZaH1P0NeMhowl1urLAEiohoiG1mrFaUGhHzPMY8T4mba/5NDphs/Fp5/+Cs+/+ETer91DEBP3XGO6SE99APzH54d8ocF+BnvbTOVAdKW0j5Mo6Uh9NZuWCQUj63qZZzrBKi+imwN1ZpK2CEgbMoop9WtEUC4xljal1hAps7nlo1oAXVqwNn23aY60yNHPBUV2Wrd5hJD7ZTsOfOfTiiKaN+EFEdf8aaRvovUupx3T1libcoDfOdHvv6Qfk20u+0G28sKB1PFwvovxwD92BQ3VGNxM8WlRobwLubjM65x6zy8mJkYGv/GqMVDjoxHLOXZ1QU2MZOvNTjaU6E5sayac6z544WIPgXSf55uDAXcjbww1rb4XXu7iX5VQvObYGJ5okUrVt/Yh2umBY1sj6nKFR1r0W2fR0bcuAMvhZOMqaYmhT9eGglbz8oWJ3M7KMbbTExRMB/Wqk1RIcVlPavK4rqrrCUryEpsNQqX0NDtmOvDxg7nve3t4ynp3y4nygNU9+e8uE1wWcHO755ZsN6U1Cb1g0vTdRNP1FgDersdsjRXLA8pUn1Jv6SeWxx+oThC4nKr7qYw/9gKt5WJHST2S0XYcxmNiaja0O9boD1h15YlKUPr1ZTH/N0BxysSMvdNptg9V07NZPMdgzb04mAubY3qM7PkFvc8gOJMmMx3HA0xncDyeo4FTbwNDYtF2C7kosO2DhW8wWpjIMcnWo+LPvr7l6lzJ2FiLoaeyWXlFGlx7RIkIfGtpMpRbUD6aL6FXvqMBSTlvVP6qVW9RivginN9fuoFHs79HCJUGrVJomjaKLtgN5ccA3Wk7qGVZjoQUdoTvnYvDB32PYDrW0qGtJ2UuyQ0OWH7HslvaYsb1NaPYtpqbBysVWTISmY2g3mFGIP7dVi4FS8RGEgeNo9FPf38WUKZ5p45ohVmiR1Eeuq461LxnlOYV+jdIBNKFFr7UYSs0j5tNWLzAesVCqzDylVLURp0G0yrNb00uH0XCp2mT6JWHqLjJPaVRFw9fxzJhWbeKGBiXJVN97XTaU+jDdsGNp1HsV7DcIrB6PE4rCQVjtZG6w1cGYFdLJJnuBbiq7hU5tDliUeErN47RYQsOIBLXmTP3/JjUh/J835IONkZWMV6/5o9/8wPV1wN///FOen7xgefEI+/IZF7la6uzZ7jpevT1ys99TNBWyyjGUbUR2WGNNoAUUKO9wO3Eg8lQytxxO1g73iUVTdKRVRZurZk2G3p7yRy/veXO1YVRpkKDAVx3D8QQUBPGgYzrxxJIYug3aqF7/xvS6LTK1ENjgChfDi9A0lSQYIC0J6jmBpqG5pQobTmBIXdFtDR1XH+iDXrlHaZuBrfsex7OI3Gu+TkOorzDNFUOnttYGQp8xKpOD9m/XwjzMwzzMwzzMv/s8JBUe5m/SvOEDj/wQ7/vDpDLflxpv2294Mr9gfB0j/YbT8pwLYbHPrsh6l3Y0lCuPNlEmA53RsUhapWQHPRa4oUnYldPhWxguz3WbtoqnZ/IyFviyY38bUw4l0m05UyY3N+XKGXl6HLkOBe1mRWv0VGXPk8AgrEs06fN5uWNv6KB7SH+HnS+4i44smzVluSQSR6LDkkOZYXYNN6reW53zuVxw6ntIR2efNxy8Dec/lvy92Ccx1hz/bIdRdjSFOQEmN02Cfj3ys7XB5fyErquwKp92ENiDJLdVbVQBDXsUcasNQio/YVbd89WbS46rhPvjgKW3PB48NssK7UY9r4ppUdA6DeNW0iYjy0gn0TIcQ2B7ij+QTTD7zgtpRUfKHst3WY9z9FpdIkGo/kx9RrVYkdV0o98Ik0CTSNtiWxgI8Y54jKZLruw4Y9994GKwuZcveN++J1TKQr/kfV6j6xbhF5KgekzovuQ2U0skh1P7MZ25m855RKpCLjjrdIhjru8zkuYaXQsJTs6ns0RTbrAVHDKwERcLwtokmteTdaw6NgSzHmNm4n+qw196VO49wp3T9yZefjfF9vsY5C9TVl9dE97+Pp+Ur0kLjZeOz+zEJOh02kDw6sRmrmmYzk8Q6QE92OB7z5k9aVjN5xzyDQUxoRGwFxqaYxCeq4O7xvc/3HOVXHPujYz2jP5MifJUFVtjdaxY9XPSxiI+2nCuOH1K+94wEw23aU3qmvz5/iVfpi/wdQ0v7/mNuuB9fGR91PkQ7z7yNGoXTVWYBex7kzLL+Nt/63Oe6c9xWp/BVlV/g7pWFfQB2/EYYpU2N9C1cbLabYqW5r6g+0EjX55SXIacXGislie4jU/T11ijqsELHNtFDi1Vq84y5pRob7qcpj6QVjbSgmhM2W107Nn2t7dM8Iua9Jiye29R7bdTfH8YUmSl0TzV8ZQ3NvXQiPDUF9yRbPdHdvuc0GqxvBB9TGjGBM+a4xg6hmEQL1YEwkEUHdWQTTT/Jh8oVTTIN9H7e2SmevOH6Ua1TyOGukWqmkSqbAYVRV/S2AHGrOfcWVPVPoofGvUxp480hs7mqs0mOF0+bY80pKUostG0VbKDAScWjEY1ZSaO+z23twlVVeJqI10t6DOPUZkXvAot3FBJn7pUVgKHXn3V9wc8EWI6GaY/YquO+7CkGxJKdag35sgTD02UmJbG4vIRDBX1QVD2AQs9xA0lnql0Hz5j5LFcShKxxibAGQyOsqKoU9JW6XUkWlLQ7iqSfc+o3jODaIpv6XoF3oDhXhJGIaFzYCh67M4GW70ROTS6ha8XOJbJzNc5OXUo1eexHWnLRmEe6YWJH9uEreBeGNOt+9L3UeGZJltRqM2v0lGaEScKIEFGoh3I+pZ2r9GqGBNiYgu0QzexF1ALj6ycEgMtNm1rThE3ibIJaMh+mDZtM/eEY1hSJwaNUgT1LaFTMugObbggFg6D5+Em92B7WHLg0nVJhmqKubnODM33GaqOfnQZ7T2OfoYQI9vjPX3tgOPjBqNa4nJyVXDzC8k/ufsV67Mbvvr8Kz5/8YLlbEV8FhItSsKlhXtb8t3LnFp9h8eROlfQE4e+kfRWQ6jb3B9Lftju+OTJE56ezZFqQfXqBw7HyYeKES+5OE257X3e36pERoLpzrEUbEUIyqN6TZXoSxNXAT1Lj663GfSU0FELRBtGAz0X9EfI3Z4hKFjYkiCcM6rFna6RbVRNpEHOTHSnYenEWJpPYnU0amEgXCxF5g1PaL6/RktiTGkyBFvaoUUUH4EuWhb8dZ9DHuZhHuZhHuZ/YR5SCQ/zN2HCW1VtTbkrdCy9I3KVacrivdiS/QDm4zua0mRftKwUK03WDIZiDFhYnw7/czTcwlRx6loQWMOUtrUIWDsuiSnJ65FY2AzOFQQ2q3ZGGpYcipbT+wuuizt8z+T+/A3m/iviHwR+peEEEmGnJJ6LW64RyT39pWIUCOqFwLl26BzBaX/G2MywzZQxG/iOEo2WAmd6Vv82/UDRLvh8UbHwG9qlTZOuaTc2nzwx+c/zO/7Jdx2vMg3zaE4mOsV3+PBXO7yLJc8ixcDqOTksab0WLS1wgpGzzqD2PbxR482l5LNfWMiVYBUIDgoAbzr4mk6oeSRsML01+nHgihp9leLmp9T9kaz1cF0TT9PJhx5fD6f3j/a0nurVMnHpXRPd1FgaPoeiIldB6KChkhVBbuKtBXe8Y3ul83QRsvZKDrdLbnfvCPxzisMZbvcL+sWcM2/BXy7ecra9QC5SvvzRFziGRF7lXEuXeD1HVzXl0aILtnSbhjDq8fdP+KH7wEslOkxVzWFglatEQYevHSbjQBU21OKM8dpnble43hYjGantFe4yIpntCKoUq/EoXANbGBTpiMEOIQr08sek7i+wn7g4pk1vOFyrZ/StUjGWpLMQM9R5NI587+gkjqoNHAiNCC8vKZ0M+ojrg6qAP2KuzmNLezqHhvGePg34+i9z9ruUQTc5BA7B45AoaamsHcZPoHwd8evSxGlK/CDnNHR5Lg/sFTQ/a9nkOV93wWSN+M3JgXM6Np2J73g0N+e8OflXGLc/ZjN/yRJ1JjSox4r8vYKkP+UfPHuKY6pq+Egh30K7QB99PE9VY+xJ3W6YHcJOsEuT9m6kf10RtQOtX/DaG/HnMx4rl+QoEFKjlRWWMhbqLXXZc8j2RMOCps7psoEmO5DJT/HnR/pxz9u/eEr4091vb5kwqxpeypymVRRXD6Gc9apD7kdETk2fqvtlC2t9hmtVdGnBMT8omQDFGGCJBtGvsESO1anj3obYWfLcm2E5JYnU0ZXz06o5DAPdEDJ2LZq68XfUF0FwUFHuo8XarAn9iDLLp96IHahEgqJ1NujxEoYDTZpz1w68iJ7R9BV1MaMZKmTtMl/r6GY2Hag7RsLAYD44GGPMvr7n9i5lSAwsQ1kUFGUfFP3E1UeCwEUzLYbew18bLGc941ggb6F9VRGdh5wsa6zhowImI8OMz5lV8cRYaJTeUhOMzg2hon6eLuD+W7LxFJkdeDp/xrEbkRXMZi6eJskyB1FVGJY+HfyNRuDMTO7qkKP0GPp79GDAmHkTHEZZD3p12BY62dixKyT6ppjiN6a3mJA2jl9jqLhMsCQdd2hZSzGaRE5E2A7c9+APN5yO52TrGusuRXdWWG6PP21cdVL1cdo7ukL9AnEJNaX3HEkVnbYb0Sxt2ri1ssU2DVxl6hANRWlStNaknJRaM0XUsrrHdDpifaQ3Uqpy4NjUkzFiUZuURcnRU+DMlnPHwdcHSk0ghUdrJizCJ8RaNy1bqszGSjsKL6GqDTzhIzr1hmDQKcVoI0g7C1tpXNqAVpeYpzqL3qVoDe5uj9zJP+Pr/Xt+evGEZ0+fcr6IOVs7DMNHveLeaRjKhlKlZBKNQkE99Z5uMBCZx+VpwI+eL3i0iiivcr6rG46bGikka8shnvXcbUoMDNbRij7ycZoNpqZTzCx0I0PXBoRZMDr99DGbwzhtSlulhjQEBApa2hMUUv0eoY8VMyGf4EaBZuP5PfszG9WF0PyeZDiy6M9wsKllS1GUk17SUgFAYVHrautcM3Q3CF1F80rGwsN0HmoOD/MwD/MwD/Mw/6mOXZk0zYrleoPfmHznbPjUfsZNmhOtb5GVw8rpcUTP2IaEqk5bDUSR4MJ8pMhVjElOaoyIhYGrksrNQK/o/5iMO3UpVrGMXQrHxjRNThyBW/dE22fUdkm+WTLGFc++X04XidE+RHsy8NK54entE2qzQtz3NNGaRlacKZXfcUYWVWj9AAoyN7vB6nwaQ+OkW3DU7wiGlF3V4eULXufX7I86f+fZGcZjBRssuOsT4n7G7zzSSP+BZPffe5OqcFgfGeoEdj7vf53QbFs++5k32d7SxUAxHyjLktODNyViN0PG86tLjuE9tkoJeCecVfsp6VD6gmwQ6Lc1bdRiDC4sUoLCn9KrlytVIzjDEDXzY02r9PODwFPpW2HRK7bCVDnWabxySoV0TczQphTRgbaZMxcWou3xq5gkF+RWix2mFM3v0hgVc61CzjfUZkR+MFgHBj/74gW/+c2Bz2LB6oUCr49cvdTxFi9Jy5hwXeDlLrtkYP8anMdvOFSX3F2d04Tfoi+hOzewv424MFV8/44Cj0gusZ2K+mQzXR6XMsTbKlZbjTOrWeYewy7m5ljT6T3LzqLRYiyrpV6l3Hx3TeSfYp3EfOafYV7suG5GhrhG/ErQvwm5X2d4vs4hTXANHX8IqWcF3vgIw6xok4HWKrkMJIdaUBxblsYlzpjw5v0txzd7Bhkzht6UtPDsAens6OSAqJYfuQOqVuLWECZYUcf7RmN7MFk9Mkn2Nq40MfcbLBHwdZYRBoJPVkf+1bfRpMF09wbn4wJhGsifFfTfXFD2b/nR6hTTBc3VJluiVT9DaiOmoU/MPDW92VOaG3ShQAABybbluJPE5prnZzre2uWyek6plPDdDkuq20h181xR+29JyhPawuft3Su6Q8ndXcD5E5/5LKPeatxvHL5fwP/t809+e8uEH95t2A4VpZYxBgHdfUsTmPhnSkRfctLEGKsCzbLpNVUx2JHXNV1vUR4rtCUEpo5pi8nBWSk439hy6BrutylpVvI0viSUYjqE56VFkiTkosJp7Ul/cdYKqtjBn50iiwNeNafXBWbj0Zsqwu/QbHv8YM2guvG9ou83VK4ichZ0+wg3GIhsddOtERoO+WBjShXj8DDtnvS+4jZTWkeJrQ7lskF2A9IbsU9dtJkPZsRiaUwcAj/WMIob3r20uNsJ4nZLpDru7YC0G86M4SONX7OUBwGp1xTeBUN7xd06ZF4I/OUpyShZODGvv7/hm+31dNuvkhOzVTDxEmpbI1LWCymoLBfWGqtOo9sV5IWkU9DK/DD5ZpXyQ4EKq/6G5jBijS6a8OlapWRRqpgB3V7SKA6E7NHTljsFu1Exe3fAkYrqeeTte3XYVUYMizhQ/c6cbWOgm/W0KPBHDXt0OdqSfDjSHDNEayrnJJanYlsDZtswqE2z7mC5DtqYkWQJ0rGn/lyTwPao3gF7nq4NvCl2ZZPXHZ6MsYwOQ+k33SNGe4JrKCesw264QkFh2/YFj0yD3KrZvN/TmTVFM5/0jsMmpM2+I7A+xwkvOBZHBqU+Meacn7Tkw4b7o0pp6MzmA4w5cliwsCI8mbP9/hX/zYc7Ptnd8HvPn3KxOCV0Y7789MmkmxzLGn92x9XbAV+RUYeGvA8YzIxL5xHhPKbsO8r7jPutMkMIzhVA8dzkOo3orbc4hxhhHOmrhMyMseUFM/cNuuVyLELqpEUzc7TxnN7eUjc5hiexjTnO6BHOQbYtclA/yt6keIlGcIKQdtayaCzsUYFGNW7zimZiOegQaNhKh1qO6OYNlgFZ02NoA8P2Ev2Ri2w3aMMJnv/0r/cU8jAP8zAP8zAP8zB/Y8daRMzVDW/uE4Y2L3KNxpK4twPj2iCftVhSMZcGZObh+KrWWZOMI+1e58TXaY2SrAuQuBhRSegLdHXGV5dewiDJlpz7gpOwR7Qav9Jyxgj8McXpbidCfq4fme1O0M5G0pMSq7RZ5b/DJvgl6+F0qhXIvmJexvhKXY6Fb5REls5tmWOZHrPGI++P+I6OvqvY6TZmY6M7AlnrfP3+gN1+4O+OOjNnZDfqVIct+4XGp3/rOf8g7fnLf3HH9r3GYrGmDQ9UtwM/7HNc8SnB79wgW411ElEaBjtLAccL8O7Q8wuK8wFnr3FdW1jRNZq4JK0bcrckrp5z97hk/p1KF1hUTz7WVRf3Nvvn17idTXI3ch8LFmp503mY2wrbNNEWHm1dU1cKsC4ItOOkCByaC8SooS3bKa2h6hkXQY+pC7TDY+b+LYPv8si45H7+Cu3bJa9vTFZWwY+++pQ3Jzn3+cDfXX3Bd9/9mqYWrIyQ2Bx4N9SIJCZpSzRP8u7GmM4VInzH7+oe83JP+csFt5nNZ3HCSbvkbWPQGQOuYxHLS0zZcbBz6kppO0ZkrLCaygJoURx8xtlxqul28Q7j9hK2A+gKsv4cb7Fn5pzy2iqIO5M36WuMT5/xoou5/5DyjW3Sjjo/HleYpymbYcV5s8Agow3u2WuCi85EGD4DG7ZlQ3VMaasU+8LFzBPMpymz5x9thcfhDPlew75usU8zbENOTA/f8flsPMMNOvamTpOXPPI0LHHg3W2Ped/wxbMRex1y1yzAu+Z0+JzbVciZ7zFbatg3Ok7jUodP+exzh4UboJeCXOb4vo8iNXS9Yt4NE5POrFUX4BJTr0lQtQxJ7I9EQUO69NlYOVbxBqc6ZVTGBwXI0wQNI722wpcGXV1z+207nRtVyrpWCfxcozgcuZr/iP/6/xRxMVv+9pYJ37z/YXKCqsNi0yUMY0uve1TNEZEt0f0VsXWP1dr0ObRVNVFMA9UZEksCcyDyMkrVo+ptlrqt8G8MyUBzMGirjqvsmnhmEwUargypFaBR0f+FxDYltbsg1lrOZwXbeMGVURO0CaPuYQsLw3OoK0lY31LMdBbbGb2V4eoGrhNSyBZhOFS1YBSK+y/RfXBmEZ2v4h0dm+uOtpYfoZG6ZGgdhq1kqEcMlTHPdTpX6TOUpaBl1tc01yUffpkhUzFtCqUQOHGFKUPM4YS8PKLbAZavceLNuXdHAvM5T4wY8eTIzY3HmGR893ZL8qanOObYdsfb0WD8zMUPWzyzIRtV1ynDtsUE4su8AqIat3IA1YUaqZSuUelCbGWN8LCaAKuuEVZBbwdUZTUtC3plJfBHjC6ftprCsGmO6bTcWSluwThjdFre3mxY+gFrazYdLss6wG0CBqNE+Dqz2kF31eIkY1CQv0qi9f4EVXFdyBNnui3XRwfd1EkyHSqTwFScBEV3NZBpRTQHrQ3Z9Yo0K7F9iVl3aMOIriA03ogZlGhVza6xaRpb2VDJ2i2+7xAcC7YbJUG08Nb5FAM6JjWii8kjELKkTXW6c2XtaTD2PdnOpJUSX5lGdB+972i7PXWv41geM0uw6Abq7275bz/cEC59fvToS3588oIncwGrCttfsT5NMNQbX/GWlz/0CNvj6SczWnfkcNVwdb/HSEvMZzH/4Hfn6LrJv/nhgHZ7SjCPud2/Rqo4oJkw831qzeCQe9RpT5HrE/PAdlsG4aM1JcKd4Wo+lhszKmaFvsVVaR6rohE2tVIrlUr8Y+KJkdBvaXoVoQsZjAazSulVR0qHfoynNxHXvcFSb3zxHH0uKWsNUhsj6LAu3v11n0Me5mEe5mEe5mEe5m/oOOq5w3RptITaiXHbnGO6Y9fF0Jg8+r7m2q4QhoXl7HDUJVjpsq0Depljag2lZrOXt8zSU+rApotbVkWIyApmKobtu/RGQ9rbLDyLoBmRPxikwQ2ZkIRSqc7PSZ07rOOc4ccbrGPATJr4wzkrlaj9xENUI4fR5zA0zM5yrENO31s4gY1+1IkebbGbkCxzOTqqhiuI+ggliO/dnKKEf/5v9qQHnz/8Q4/Qn2EVO4WzwhfP+cOfNXCo+SffXLGxLIztHK9Zkl/c86bq6fY1/4ebC8xHDsW5Q/aNwyG6RmjnxDcC15pxb/waI/0ptXtBLCVFWFNFOfm3zzk7SJrzkWwoeLRzyOYVb7QTkvKK2dgztAGx4izYPYMjKYsdXblAU6DKvkA4LqY/YCvDWOYRCx3DTdjUNfNxzTB4OFaCNByy1zqPAp/ts4yDucWP5lirmktr4K28Y35wOV0/I/v0e7q9wX/zJxa//0JZ3BQfLKbKNfLuBq1qkW1GPnNZvC/p1pfMP5kxI8V4dUQb7lhoIdGjOXlTYrcZTatR5A2ha6G1DbbXYa+eoDUpVdVy627Z6AfOLA9D/xRdceesPQYxduVyYsypH418/80d/Mbml3+45ZA8Z3b6knF4gXWq4b8bef48JApiUgX27Aoev3C4u8moiwjdGlGYNr2oqceBTa1A6mfY4hKzv6UJFHPMwi000kLw4eaAbrWYj074bB2ztpRIYEAOHX2RUqridOMj9o/Jgy2JAvF/ekF0fE3WPeJQpbRXKUan0jwuMjUZ3IRCu5jYZ7ftgGYZPF5ewDhQNzVJrM6fHUvdokghz1rquptsHpaXo6mL+sHhxB35+c9NDNtisbjA1gyy8oAYBa4dYtkWwh04akfSzZHDdz1335VYs5qiznmq1aSVz3d7SXyS8P/8x5+Sxg3Xev7bWyZsDwuiVmLrGZ2mbrBH5nOXJ6fxdCDTZYk/evhjTWI7pKqXFAzo0QK7UD18k8xWB3TV7XEpLfihKqbYuzI2dEeTnewoe5t2MJDynqSyGDPlk1GFrR6hxVRdzuHDnseag9NlSFtnoeClQlCMb4jdS6S7msAn0txhKYrpsMQORoRvMQw6rSjRdB9LjkSuSxB5eFZPovSNiYZs2ilBoCCFTSsZ9AHdDGnVa0TBKnKNUh3e9gONIujfdVRNwywWnK0ucV2dtjZpy55Kn2Oc5JzO7pHOklunJEwNhCcmJkOWt7TGHd2wZPubDHnsMIRJVaX8+rWJLhqsoMOeSc7OY0ZvZHNvoh1S+r2KLnWY6mNRag8h0JXSQbkshDYtGDQFPpxZCH1HmasD5hp9NXA2HilFQ9mr+A60tqpBCMKyJhWnnDkG64sTdscGMegc6hG7V+kCj+pQoGu3GM2CnaVsFiOxYdIYgqovoNCRagnjKi7CQFOoJIqSWTRoYsDwtan2oOkahglLwyY0Bsoq4Wqj2AwjQh9puoHVoic+cRGDj2xUlSamlDlWO0INwawk1cFRSRcnJxti7NFksRjJm4p2WLA5bvFlSNuWGI2PdRwp0oIhn7HwRvRoQAwjxjhMukxrVNWRnlSM05bQ8wcqMfLu1RX3rza89l7zyfMlj5+fofsmF5fPOAsWjNrPOFl9Q3kUfPLkBEzJP3uVsDE1Fp7Bo59GfPrFOdou4U/eW+hrm6FUMNAzdJFgDA5Hz+AidNgmJYYhMWbqY1Ovg5JB0xiFgxf4WMKfOCWjrv76wNAa5MeMoanRZyaybhkria57FHbLqKkl0oBnzGgHl2qCceYICsz+ESvXID8f+fK8/AjkuRoZ7m1CzWK5bv56TyEP8zAP8zAP8zAP8zd29D6nkBWGYZEfqyl67XQ+7kIy2DV66FEVH6jv15jhmswQbBcZ2vWBc6OidRx2t3u6TuMQmmiJuvQa2LNlm3e0TTxZwOyowWlDDMfiP1865OORP8svafprKi0jmH+J8F7zdHfKvPqUss2YzRxeN9fkw5L+UctP9xf8y+ENQdxi3bmMjo2mIObnkii32QQBTXMgLwbyzGSjbSfd/VPTwbEc7Nomdwb+uPlA+XXAz04sIscl1VJwf2A1W/Lk77l86sV88+dK6y3pZzlLy+O413n3/yn5lf+GR/94wfZpQHXS85/tLsjSe/R5RbVNIXqCv/5/c+DHqAfBH8k1V3uLcXmFq7SXQ8GriyV5Ahe5gj8eKW9NSnXbHPkYQqc/FhSqZl7HbKsOS7/HlwucwSU6GdFci3rcMXQNgR+xMmaUZY3VSKpR0LcpV2bDwRk4OwpeRUe+un6ONCS+1/Iqn1FsUpaXBs/vnvLf/sUrfrh5w9/9W0ssz+bt+5w3dUg9tjwb4JicwOrA1vYx64FMlgQtLC8FrfOIzaBTq5qLPxANIfu9x+tNwVl7y+PAIfNXbIYNxhvwpc8x6IhXM5zdI/onJafM2PrXWK8dBifCtTrclzWlFnCMR+wffJ49ytH+wuBP3QPOT+DvP5b8lXNO80FHrJZYQ0Kvbud3A1+scsLFCtux+KZSRrwS2WynBU+fxbS1husMaK3DNh9phytwLfRI48lPMj4dLtjnA7028jiaUTXVlHq/7/Zk85ZjeU9ZezjHe3a/ZxL+WU2shWzbmJNnDs7/NDI+71mftewe3yC+N9HDSx6trKmWvssOhJ7HSR1NHLy8G2hbST806JpaEI3YYo5BSq1VpNjkRoDrz9kODn4rwTzDsjUl9kM47VTbz152XF/npNsOR0HdjIBT2+FoVnzzK5svP435R//7iK4ZyalY1B9+e8uE509qjNYj2F3xTX6CES744nmBjDxca2RI97jGJbYpQO64jC384QnNKGi6nlTdnGvKpOChaTqWMTAU47R16Zp6InTKwZ9cl12zoasEWmcg9R6sjk6uCcwMSwi23chrsyS0FFUzwowMzMwj7/yJCbDtMqhvmMcuY3dC0vv0tkTLMirbwKXBYsR3NCJfI1Rky87gT7c1r48jsjMwbBvakbZPGOYVXqDjeh/Bd0Mt0IXCB5p4rYHsg4msOZsluKacDALO45Dy7TXSDPHkCXXucBwGZnXPQR841vf0uzl9dkTXXApVG6l1NE2iFzreMmQUPW9uJUb/A/pMLW1GTHPL7m7g/X3H7sMRM7MwzAFpgj5oDK4N+gxDNmh2AkE+dYa86oQ+yRjICQYD3ZaMg4WmrWiGDb4hcSMTo4nJUpM0OEIy/0hTVf0iDjTq0JoW1DOXC/uSodXZ7itiy8VYjFRmOcXp265mm7WEuoajliGmRyt1Slq8sCXUHExHqSlhdAVVqJOVIZquQCLbSWsziAXasEX9LHzzdYoXWVyetMTC4tzRyWXCsfeJYhN723NwR8LTS4Kxpsg69v0dnnNCUzY0zQdm3TnB4ogpTlgEkkxzkUeJrpVIoaOoAEIZD4wQnYGkakhlSmnZiCHErQcWmEgirj9seHf9ltP3Fzx5uuTk2VN8PyS0bJ6dPWc81+hGaLOKYBhYDbD6ao7rWRSZw5vDNd399qNydN2hDxWu5qApZYxbYHc6gRPRNDVmPNBXPl2eTLwO1ZNrhwHd7Sj1FuU3UhGutkjg2GCFPt6sxdN1DkVHkiZTJWUd6lNdwrBMDOmQkU8VDCveoQ0WfmyxcFq+fLKk6TNe1h43QY5OiN0v/pqPIQ/zMA/zMA/zMA/zN3WuDq+JowuaciTbfMfGPptulPOywmsGftCuMINTZH1NNSbc7i9oHTj9Mue8WDH2BqEwuIgqlo9TjnJGIUPmPuRhTSkkF7bHMjRQgfNGpvwgLdanF/jpB8pyhGZkqV8R3Lt0J/dEzhdc94K1Lvhy/DG5fSTc+hSynnhs8xuN4xAjnH+JJn7C2RXYy5qdlmGqSm5pYrdL9KqE454k37L/SkOcK+DkSPt6zbc3A83yjs/PWvrZKcawQM6vcGyTLy41Xr25pT4uaL0tfT5HWiatOfJHMuWTX7h8/mKHrj1lM/RUxORdiubl7MOAy+s/QEQNs9FjZ46QGuTGnl4aBMJm9oPF3XiHqc+4vu+Zn7wnTTQcbSAPVfq2ZZZIPA9m6vPxFpgXOqI5cDiOGI6BbnQ0fYvWSmbO2XQh2VrFpATU6fh8obEZ9xyTL5hrOd/mFpv1b/g74Y95XApS/cDrDzueWB7JXxz4ye+P3H1Z4F6ZzLuUtXhDd3VG0+ypT2xOHIvKuiHLgmkB9G3ucRwjni8HhBgomhx/MKeFiBtnrL0Ky1qzWZdk2Q8s+lNSw6Rst6xP1UWiQSpH5rKk73Nmim2mIJRjygcSHu1NxsClP01Yvgm5bVrExTPiqmC1T+nPn2DeGgwLSXX3PaFv8O4mwl2FKG684xtsio7tr3MalZAYXzBOSd0DrROSJS5OtqWvPZrhgkUw8KyJOftmpDhvsXY2CljRRCpdrVEoTog5p+hqXpgxm5Ml5WKLd/s5wvlz9JsV1UVD/9pA+/2WL4cZ60bw4U/ntE3GZePzh78HM1eBGkNMy1ZcRuzC/chqECPxYo5AMfC2FJpSc6ozn8WXpzpHZ5xYf1lzj+24LE+UOVDpJXcU2Vua68949e43mHo3pZGxUigj7vsD36QOP/8dn7//v224d55hNCVPmx2vfxPC3/otLRPCas8b3SGnoLALgtNPsOY6o+4jyh2D6TPqOYfqwK4+Ye5F2GFBZEZkmkbX3uIRUAmbRi/xFaFSzCnVrXWX0SrOYuDh2C1ZzuSXtcceQ47Ug87S6zidm5O305c277ctddbhR3foyTOIJeEQUXevsPoTAvmcQsuYC4PO2iMHj4UeYSxH7MGlzCVmEOBjI7OcX2+3/PrljjRv0Pe3IDUGOUPXPIKFhqcqDnoA4YB7PhC6S/TcRNcy7FRCKCEIkbZPW2e4xQ2bXuKNW/quw5o9ZSGOiMNjvLlg00mE8s8eXKqwnTQglrlFmOfUuor9hBiPBSKzaJOWkg3fvxI0WYomB7SkJTjY6K2FtmhQ7yampTSLCX3Wga5hxw5O7BFbI4FrT9+j+7Sk6Q3aExenaTDrjN6N0ZXVYQDn5ITS+GZiWtxu94g85LPnOyzHRB8b5BjhCrWJltClOCsFEelR8RGnMRjjQQUGMPwZhjBoywyhf+yizTwTp5vRq5qCoxIVOr7uUslbqvSOII7xw5AiG+mmm3N7SkT0yZF0H6GPFvoyYBZKBiOf3mTs1qdof6APPkPvHbx1hysMDgeduWvjrzvG9jHpzqLKByozRdv5tNVAaBVYpsW+0CYqr+MOoN4Y2mHiPviGOSlxAsfH0CVCfd2dmjAcabtg+gH95s+u+fPvbvj2xXf8/PITVmGMHgpuu4ZdccddJzC6gW42p6wNjq//kmFvTV9Hoh4nsbBth3iVMMQar9/3vIl7RFPjz8EaI4qm5rob6buaODQ4tXtw9hi+D43OsZF42FhhTB44lKrWYwqihUCPa4xBZ2VHCDGnM9TvY4nsfexxgUsJWo61zNFvXG6OEVZcc75ymJVfsavL6ef0YR7mYR7mYR7mYf7TnD61SS5bhrQid8/4qa5Cxi1L12W32TDYp6xtm+x+zZ0neTrfE4wr5mKF2ygzWUnwCIwiJlea7Bg8c2Asc9pjS5+NOIuR2A6my5XssEOOBlI0PPvUQexWZAI29wlXpyEX0mYcM9ZaTyEbaqNklD2H8ho7D5l1K3ben5L1L1i3v8fb8JqL4YL3swS92nLRn/Ib+z21IRCqunxlkXY286uUZSy4bj0SeYt25/LDBvouwJEGc/kOeYB6WXPpz/lf/+1L/qc/Ldm/7+m0dwzzAkvqUwf/5WFP/mcv8P6Pb5gFv4d8+x4iyUGzebIXbKz9ZKNDnHDrvOaz6oKifMqoF9zNXrHoTri5tfDbjrvMpH28JnE87CZnbQ5Tzfa+0ZDOwEpp5ROd0d+huz2zZkVTFaS+hiseY+olfVtgOC2XsUbdLvneveUyX4K6RPurW4z+MWfBhtndI779cc/86yWGX/FoueAuf0/3mc7fs56ifd1P9Wzf8/nSmPNWP/CDPGBpZ1jvHOaGRvOoY2ks+bDO6P64oLI1nEfNVHl2rAg3a7i7zSdmRmx61AcDp2tZahrOiUdSt3xmRdDDr0OT1M45y1VtY8FVcIe2d/DOA5ZvDd6aI3bxnPLRHen/kHDydyz8D1viL5aYusk+vuNsY/N0fUYmBt72Byrh8hk291nF9YeRVbcmdT7gzKH0VQV6wPYazAxGeULnteirb+itC3bZJ8T+lmVTYpz2NFnN2+89Ts2WwTSJVCUnkDB4CK1mV614H/8VF99/xv7zO1Ztx3XyCP35L/H0kCGO6NY91l1I+b6gVAaLpiI/NPjRR+Wkq5gerTFV6NEiOt2CboWrHuoHyTCMhDN/+nOUylE3YnpK41qyv3a4yzTuryPyb/aMi6f49g29q6HvNbapy/WzGf+7P6j5/OTHmK3Foq1J44Lbt0v+1Ye3/D/4LS0T3pshh9v3tPunnH+RY583U6R+UTkcTPVDZuL3Lr+63VOImifeDK+fU2sH3ncd2SbA81Iq1VEfAgZSxv4lrRHQCwunkxiaQvw15IrsP1q4CwXkWzKvd3RVTeaeEg4+m+YVm43ASt+SmGeEvdLcXeNiTtH10N7SRg6iFZThyJCFiDKlCsS0EasxsE88Zq5FXyd89+uWP/86YXN8j61uezVB3fp0YgTDIcDDcwRaGOHGAfGiw7UEbXlkn3Q4o4LYjRx+qNFWKZrZIt7Z03+3VZ9UkBGOCrIX4Jk5TmUTqF56t+Qg3jH86QlYNVE8o3FPcc17TL9mbY5Uiy2pGeAOS8Ymn0CORmtT8BbTtRFqUYPaPqrPXpvUH6Nro/WSIdMYtB7zNCZQB0s/AREwdhae5jJ6lar2kJQ9ohPcax2BnrMUBjd7QdeZWMuEvOo4s19gBc/ZaYKgPFC0LkejQxt1MtUSal0iTtD6W0zPxhh9tv2ebZYQahFCRe3V0iHREG2DK0IWsTalTQp7oIwGGl1FbgKEuKVQ7t5Sx4xLtDjGHgr0vUll39BmcyzPwbQ8Ak0tUE7oyyt0P2ZMbWiU3kWiN6+wjCf41YJWP6Idi8m4sFtvqRoX2+tpWw99cNHrjiJruGpL7MpgFff4noOtKW3PR4BLVioV6ohx4mHPVI2gZr4MsIqS7//sjl/+5Y6Li+d8+bRnZVgYiUSUI89PIl7t75lVgoPZTHUS55EJ6RUiOGOsG7aZRawL5ucjRt2Rmx2aMPDdBZ2ZTjUc9Utgvlwgl5L7tiMoY+aaxFOVhr6k0iviPmJV+wgcpOUTxzGOsl40krrJprqR0DtcR9KLDWPnEo5PaM1fIpWZwrrlYnZHEuj4hksfGWzbf3tf6mEe5mEe5mEe5mH+45wgf8Qft+85Twu0esVv4pxTZb8SB+pqxrp9x344YVxI4jrlNknYCZOleuxbHSluHJxhYJilmHJGmHtoQUORDpRHk9YXGLGLZugUMicONMq2J6kNnp4+QuvekukVTeJTy6dcnm14d/sOP7pAs+ccL254fhXy64ue53+p6pzqNv5L5mNMexPgpgI9KDFvTaz0kq3Ucbkg+WVKH2yZmy7mZz3P3FP6Y02x0NDUga3KJ6PcodKxXl6z83u0cM6l3dMuHD55XNCLnH9a1jQf7ElJLvUKMQyMxsj1q1/w+X/3Oc0/2vNituLlquWnbx+T6lfYhsuqn/PH4XdEusu2P2AHOen+GX1VcPwCzosz9u8aFnXK8uXAyi2ovYjbIiJyG06slqKH69OOceyJUo/gOKP1GqKFzcwIuT9uUfxHEQU0iUNXu/iaxs93K0rP5RkzXi9bNLukc2bsPm24/PMlY3/Dnx0u+IdfbSmyxQTTvzvb8pmYo/1kQ7ALySwH42DyWHxFO9i4XwSUVc1TsWRthzSZg77Y0YQrxljDVTaGzuB7BdSfX6B5x8kop6oGhgzYpw5J3jDIlja/g8VjnhkRRntK6u54XeoIO8JxQr6qNf7HocG4/YC59Pikdth/eUbxw9fc9p+zv3KZ9w1RHbFafsd3h+csZg3r7BN2v/sXyGRJ9zrCC2747nRONTO5VMD35oyneU8mM26WOtpY8KnseZr9HNe3keEHIj1j0a+o2x5NdsxNg7q1mbngt6pKY2IfDdy3DXfL1/zBdcy3j17xycuv+Bf/m2/50Z++oXn5U779oufkvuGHw5/yWfBf4g8DQaiAZi2tVbMKn+HgohuK8zdMKlVtMCabXCNrZCTQNA2Bqo2bFGZNqs7XihGYSYrrmiS5/ngmPCTTJa5QYPjCxmt1DlrFYJn8X37/Av90T33TcKxuqR61GG9c/vjlL/g7nzz7t74//DsvEzY//EDxYaR5WnN5tqB337H5EPGh1ZjNRuxAuUuvwVIO15bUyPEXKyJjzmV2x1t1IGsEVj4SWi35UbLNXcyuxZsJhllE29jE+oLYqiea/cVcMOhveZMJqmGFTO85LgQ3dxGBMjycfiCvLeqs4lR2dCcOLddUDTiWoMzU1e5iIsGO3SmGWU9O2MY+suIFnpGSJQOv3qYcdhJ9jBk7nUH3aUlpDymGrCkUZ0GPcesbdNNjKNYUaUJ5TBlSj2OmfKnDpLex93cqoIUeP0FTf6hmRDhiaXfT7f91qdMnHVawZOx+Qayons9yMGNa1yOWt+jhCi+SzM0ZUbTFTjyyfMTa3DFOHloL2Z+jGzkKOmChMXbVR0iI3ePOlDvXxW16fNUNKlquhbIJzFhGDXlzjxRfEfkFsoPYusNuT4jDfvrYsi6iDu/ovRijtyi4JCl3iOaGrHlBe9KhlTWeXGIpMCYZVRZjmrvJ9kBkEekHmg81MhkwogOxoaI6HqnpcCiU/zcnss1pm2aNOmZnsWtUWqjA8kKsrqSvDfrWYL0UeIaksgquEkFg1IRHg/MvlGViRSkT8vsZx7rgfF7TGCPt/cjNqMSLB+TwDZ6jcXI2J29NbBmhK2tI07CpKkzrBmEqTaWBNlxir1ukVyBsg9E2SVU0Ky9JE8XMGNCEcgdHmN7A6cIlsgxkM+LnPfrm1/xmcNGsAO804EvR0WZbqDN+vW1xxZJNc81MV0YFJXPp6a1+6rwp9sjZF2ck5R3drw2QPkZb4gYtgT2w/mTB0/UFnaXhNfVEmy2PLu3eox96Sv3IzmyRXYMRCEzf5bE3QzfsCQ5qVR29nSB6tXUdMVQdZpA07o6oXeMHW46HGdnJj7i7u0I4Ov24RtfFX/c55GEe5mEe5mEe5mH+hs7V6WsW+/d41o9wxiO/DgeO+wPXQ8ePY5t9teT7XUX0SMe6O8cQF7TmPRsZsMyVVlsgbzo23Z7ecjhVgkA75V4raX2TZyePOV3O2OcKuD1gOSGiy+jSLd/3R4SbMAsE9ztBcHHzMa3pfkU2vmQ1ePzk+ITCzAneRcRnITsOGP2MrsuoF7fE1ow2H7CUbt5e8oun/5rVuwi5TOmCNc9tD9/uWVQ6wZnP+Owtb3dnDF1LtdxM0HP3tclYVFBfqf8L6tzGMl5w+Xu3/Fxo/Jt/VqPdluheT16XWHZEUDt8/29KGm2F9Yc7Hr0/5e3sL/gkf8Gr+Hu87Tm/d3uBEWpohk8rPxCtNxQ3Hov3S4YryU7u+DZK+RGXWGbOTMEOs4F82XH1ecbsg2B9dcrrRwnvzQJ/YzA/3PHTJsQ8e0r2ruA6y1ldCJrS4mjnBD8t+N1iRZl/oHVUIiKi5xbndM5XhznZasN/9/IHzBcG1UYwW1jczB7xc/uW4v2MVdCzaxoaoXNd9phNw9PnYL+Z8cv6Av3Rd+z6mFVmsI/VNqohsDpmwcD9lcXuVc2qtfB8j/RFR+PGZDc1o5Gw2j2lC3vMWcQz32Kv7UndOVUfEOU59bHlb/+4403nIH54x91uYFj+Cq0/5/Ef9Njykt8kz8gP/wOe+7cR3cit9xnmQWncf8B3U9p/8rv86xdXPI96klWDne/p/Baj3LCoRu5XNvlblWbe4q5dqmLkEO2JLk8JRYXV6ahrNpWgaOU5aXFDPrvnk8UztnuL+SsP3d1y62csxGPya8FXn5S8/7TG+n85/PnvKrvdn/CPd/+Q7+cH5Oa/5lr893z57AKhr9EMk9NgTbc8EAwepmZhKt6cl9HWNmmq4bgjzmhSW8r4ZmA0BsHoqTvnCUB//3LLIb+l70rKY49AYn6q05c+deWxDRLWS5PnKx1dBBRXNqbX0p78K4bv/i7/31ev+D87z7lpit/eMuFDNtK3AucoONxsOVuGNFIwjH+O4Am5nvF+305gPNGc0UiP2/FAI1oSlU2iATknMRQ0sMBq/InaahgaY6qqDEd6swKzxzVGXDo+FEuqRLKp9zj9jNB3CfTXdOYzDs2Ri/FnoL3HD3XqpUe28RHjzbQZFJpgFpww5gOlWdGZ72lLnZlcc26v8d0Os1nztr5ll6o0Qo5mbel6FdiPcPQK3TforTl4KRoNbTPjcKNRbSuMVEN2LqLeUxwVaXbFQI87QqjbNJs3jP6Ck/wx3jKmHA2qo+TDqw+TXcI6XYN+iv/CRZNLhuYOf2tRRjHR3OMzx0cOA0frBMtpEUlDrz/GrXqsLqfWexpRoYsUowHRLxGhh2UPOEPNoCs/4BJMA69VHtgBlj6Jb2PaBuXxirqxMPSIIIjR2x1V5tDrV3jRikfdmrjSed/WhFnOrWdwsnhOXn+g+C7g8eWSulee2hJDWTdoSDuX86cRT501V92eKrmnVDTfQzm9hpyVgkKWGG6GaUiaxiBrbIqyg0EjEhrmoJIBAYXfMsgGU9qUpsFqccaF1/MhqWhyh7uuwR4NMvkBlN5yYeEaKtUhGUXJ4y9OYJOyrQXXG5erDOLbltpuOR32fLrwKbBoVarE/RxjKCnbAWdRI5qGqlCcAG0C1Sikpdmq1ERLb4cIXcNsS0xrQV31lKJCniy46LdEsSpOrScjiNyk/Kat8Fc5vumha2vK8muMpuXm9Bz9rkLz55yet6zjnOte43z0aByTeFlQHI/sjRZd6ljOnHhxhrsWuF7FEo3NWwWSHAjjll3RIQ4mehDQ9j5WUpE0BoYpWC2Ok4HE6WxEryNdZ7JPDJ36xHT8dqRwvWm7v9nV2N/3aAuHsV4ha8GzTx8AjA/zMA/zMA/zMP+pzhs9IawikrdzxIuOL69bvnn8Hu/bn3Dnf0t+vMA4u8Z6c0m32rIpGhzXZuZrjEZGLkeSejUxrcgP2I8Cns3nhNsAC4u46abnYMPUibUVeTvgxSZ9J3izsYlWkvU8xD3fIZVJDcmyLfmXbkh8c4+3PucXl+/4h/dP2N/dsn0Wot2+4UL/hJv1nhd3txzOZ9j5wKbJePLPe5pohm1LzqXG6tEdWh/hzHycWOfxLkLMC44/n1HteuSwQftizagAW4NgJz6jcHuM8Jc8aUN+/yc9UfGEf/ZPd1T2hsAzGbyApLxFexPwnfwBcXnH/2o50skVZVtgfTjFbRySuMKuVfc7xTdmVPOUU+uUcv8D7SOLR0Ji5S7b4js8/YxKZhijOR0avzrGnFoWb4wP9C87nHRFKhIsxUJoKuT918zcc5qZxV18oL3vEcmOp99+wW8aQVYfMGqN3tlTdw3/1fgZ/78nez77c5sz7xk338KfnL3jvxSfMnv1iuy/0nF4yfcfAp6FLX/3k9/hYhHwx395yxib+MGaRy//ArYvcBTb75MO7iS6GLDdDn0UPHUln/7M5hV7fnN9JNgsGGVGIO/49NxhKyp26j7+mON1FrlwOZQ17lvQP6n4fDYjswyy4K+ITnSWsxWhfsE/3x75v4sI/4XBN/WeR4vfpxwrpDZy4Rl8cV6ytx5zdTvn9PFbDr/acvz9n0/J6aVqe+QZ28TBkFd4h462clgNPlG9YNMIvr0qUAHx3/vsOc4J3CeC2shw6j11Izkbf4dtnUz2hMPZPyM4/hwrcrn8YUv/B3NeHl344CPXFo92BuMlvGeguC14fF7wo8VjlZvncv4MqZYXcseF84TK/Ja2v6CSBlZv4DQ6KrxQ2yWN7hH0GkLoFHZGoarLe4PkXUKZb7Dpyfc93X0FARjVguYwsndbnq8uufw8YVY/mwD30cyg7v6E+hc/ptUl/9e/93MO9zviXlkQfkvLhGWwoGlfcohzIucCo1/g6QUy/pyTMGS7vaa6tdjVFW33hk8WEVHcki0+pW0/0FVHyuOMEYMxFBSiRRthGZ3hBRpZUUw6OmvM0VNVNamp2j3HvUbXB/hLdcMt2XczXhevuDB8agFWGfHeeIv/0ibhwAvnEW4DSfWGku/JR4dIs3CiEq/PEIs1cRwwcxcc6juOb0uoRzSlVxwdjDGY/ntdk+FEDdEzh+BMuUPVFrLieByoFGegyOnzAlOMjP0pVtehBTltbnIbSMz9gKcN7Oa35OXI0uqwqoFYi9G8ivquxnxiYurqNnikKwOWZsZKfbOHNQdbELYSsRmIEwNpdtS+Tzfeo1seoa3YEQqYWFKbJo1ZTwdetQk1FJRQmKDIorqOEDNaCiK7m2JVVWvTdAX0F+j9jjBsGHyfoq/YbTtY2uiNhVARd1kyJjmnRk4qHrF2n5LxLfsmZKapg+0MbYy4ZsOwyRE9lJag2e+4O2zYF8p2opPoI2VeoyUQOgucSG0IS5rUwBgNhCPphpymLxnbAZFpRNoCz9pMMMxWaGhhwAstolrPOWoFaVbjiQXGUVIKVZs5cP9JgtWdE2GQxwtO/Hu8xYpff7+heCvAg0qHVLl7Bxvx/2fvT3psy9L0TOxZe+2+Of051t7WrzfhHuGRkYxMMpkkSyQKKknVSKgaSNBYEjTUTH9HcxYEcSBAYAlVosRMMhsyIqPz3m9j19rT775bewtru6CpBhmTVNoHxMzj2jWzc87d61vv+zx9g91laAdpbfT0qtDcYmRl0dJQtxlViza40jsd4cLACVzIc6rsQJI25F3D2DHwTpe4I4u+Bnea02V3OPYJSb6gCwps7z27/BRrcs3kmGDNXEpvw5uipY9XnI42dOl7Xo2muJ9EfPX1duBiNLJmd7vBWpRMLk84G49Yb2p2OibYCAyrZzEVXK5mzCfLwQByvRV4rs9Kx9wMxVb/bDsXX2j2hy5AhpRC+4sz2iCmLZ3hw/ZuvWN70TETC6zGYfXkkg+e/LAMepzHeZzHeZzHeZy/f/Nqf4oZmCSn79kVLW9upsT3p4x2KeUJBPrJ6eEjzLMdRdPxfOwzM0yyQ0thRUzbEmOesZMG+3sNWUzp39XDM2dkjhiPDKrapDcMEnFHrwn7+s++cVCaXVD8iOLyGjsWvKsET6Ip7tMFnx9qfvsy5mdxxk++H7M2e1KdHPjNf0p49oZdtyd823EYnxIVJkmb4rUF45NXfP++YukseUhq2pOSSAWk0T2e0WBYc56LMcFEkYcLku6UfLdm/WbPVX7KzlScpRZPj5/izh8woxP+6COHNq35N38jKa7PcU8tumaEO7MJv53xzb/O+PSfN/x0+orX/hvCdkQ/ekfTKkbBE7x2NJi7SOb0hqCdlizN+WDAmIgcvyzJ+x2hd0LtaTOeTe4a3EjBvWMgDIuyrnm3PtL5I+YTQRF3tGFE0MUstyYPCxvl1Nzfltjje36+PCFNWt7dvSKrFV/99Vf86fOAnWOyzyI+XF7xu68Cvl4qLuY1qy9DNu0cUz7wRih+YghmjuBH+Rnp67c4oxvS0ZxWs95e3w2wwnPxMc4HOafjjvVdx/fOA5NtgkoFz/2nzNWY95VL6n/E3lnjniSc5hrSmLPvxxy03vLhPUqccH4y49wbcZW3/PzuT/jq7Mi1kSDWOy5mBv/emnPhl4yKmHU/5l8EDt8bW3zl4K1O2DT/Pcebn+LP5mQnJcbO4NTYcatCnDag6grKyueYSbxJy2JicHjYc7i755Ozln98csrE0fw6l/BBIR5GCFfw8rmL3TzQtw6NF9N89XM2kcdKRhhLi0MW81N3wX+c/Yb08BlOnPD0dMJbdU3qnPOzy7+ir/+EP/jpKd7431GbH7IvCmL9+lHPOF5tsUYecuRTiALPDXAsFylMlJEg3ZxWmDy8q0jeXUN1Nxgrip1Jnzk0iU7um+wci41v8Q9/cs+HH9zT2R8SyQhlKL4rrvjF37wk7K558YHkv2++5FWu6Ol/f8uEYvsewpesRjZbT5H0Mc78gRk+mXFNOqsx77c4WkloVeSOiwx8Vuy4LRwe8hWWlTGxfMxeknYZKjLBT1C5Gg6aNQ2OY1JbBkXrYSsNd1mx228pr3YcwlcE9pQLNWG2uKOSgoc4w3ZWpI7C2uy4oeZ46Al9A3vc4JcBiycFgTqhMiuEfaA1TjALfaDu2R4lbVvTjHpoTUR5S9VZ1MLFWVmIGaT6/xf6jGcTvLOe/duc+9ea41BhTsJBfykOKbYzR5kPOLoyobUiM4+7+5zRwibvSiyrpdQqjwe9PGixREu2f4759D32iYuKbZS6oAy/JToueOsZlEpQlzmqjhkXBsrTEXqXQsYUjYvhj/HbCls1CFvQmxYq9oct2Uj2CN+hbDqkadI1BUFjE1kW+3BKKkrMouZBtUwNnyiy2B8dZr3EfrKmVS6fmhbNfEWa9rRbzXEw6KcXyKaiVBHazDuRHfd7i9d7TQ2N+G5bkNp60xPw8hTqrCN+yFBWNmhFx9aWoPNw2xHmpKAOM/rKQ8oTsuKIPGZYfU3ttWBecDJShFZD05hUboCXp/idJuhOabsdpm8RZFCOUorDlHChf48dvexRxhnTVvHiVcG1ajm0KQYWzYOLbUb07RU3cQnmmCAUeIUz3NaHcx2lGJEefUgrBtxiV6GOOVaRY80cMAX1wSQ0IbILdrE1JEYsBOPKwO9X2GIC3YZjkGFfBIx1OEM1dPNzwvAO1/5AE4lIvzTZfGOQnt1zs4DPziP6Zxekzh27BxvLGwFL8luP7zYbhICJ41CNLLq+oZ881QEmbouEoskQhWIShsOyQWUmndCgxwq7n7ItjoNOsvcMJmNtmLjAUO/pPe3YXDE585j0HsnY5PI842Shv/bjPM7jPM7jPM7j/H2cUdjz5ckt/Z//mOnlez6NvuJw/Dl/eflvuTRmlG6KtF7QV69ReU09HbGzbrgfjfH7MTrj2fYuH5YjzCLmdfaWXyuFkVm8H3ckrqepW9hyipgVeJ1WmHd0qxaXCy4voO0v+SZ8zx+kkvdNybfrOy6XJ5zliurB4tb38JwcZ3ZKsvol0faMvjOGisO771oeftpxKS0CEbHmdyyd41DDeHkW8vZKq/0ijERHum0ufQfPM7luC6q4J1Qu8+iC2U89gruC/m021IDr2RVV1iHPFmxWLX/ijpn2Pv+X/+6WJjUwnzjk7Yajd8eoWvHLf/WGD/5Xr3hh+qy9HLM7Y3zoKY2axu4RpktbF8Mhd/uHkvsvK8aJy0P+nlHzio3IiesY1yyQ3indN5Lee6CxtW1MUjzbE3k56kanZhsWlw5pfEVVxMhXZ8xvBaPrJddmzUz63BYjXpw2zOyEd+07pObYMaL3Wv7hPzS5+crFbL8g/m7F/azl7EvF5n+x4eT/seDLfMufffQLPmhHVK8g/eYJv3W32LbJz5/1vE8/oV9smXn3UFtsvxCku5QIFzeMeH5Sc8xy7r54YF8qeOripadUZsp4VfGBOCM9FkOVefrJirPpDGGZbA8lzfWR1xxYdTGr4iN+7YaMzJ5wL3n7vuREnLEtXvOXh0+YypaZbfHnv3nHcfZTjvdrEhnzT5+ukaOI3F3RfJEQ60vYcc04yJD+jFBqc1wLUcmL4BxnNuEwqim6ljLZUCmT48zCGjfMDReMBvugTYsK98OQ4O6WJLB5KCecdxLDb9k0M6bOt3TWhIfkc26P/4HPuwBV/Jzj+Bt23xS8ni340J1y4V4gbYft9t1gUZmEHlH4g+HBlD2B12IYPW0X0Wmu2rZH/i4hvroiG+1J1JxdHTEqCszE413ns/i54L/+5IyV+zO6phlqzLlzS7G2eLi+YeqteSVOqbOS1S7FDXUKXceYf0/LhGPrszQr3LGODVzSVxt8OUGOTfZ1SN0parMhECEYit43qEqfdQttsMbaS+KqZldshi/qmBEX9op5VPHQ9iSZg6Cg62YY0iWu9zrDgGnsKA1B44x4d33Hk6XHIa/Y7o7DQciJxoSuyWnYcXQTrvMHZtEMz11gW0umJ/fgSvbuFmsbcHGYY08tyqLg7bt7tk1Cr3UbtUEHlASUWUsoUvxigehsXFlj9R44LnR3JO07is7CaOdQ5xjda9reIesa6kxRjRZYzgZfA09uH6ikRXwI6WLoJwFN8jtCLsm/W+A8OeLJCxz/jpFzBvKvqdpXVE6GvwsgqpEXDTKZEI0s2mrHOjXIWgNDx8UcjeTQzMgQoRsx5QHTu8dajkj0B0KR4pqdtlxyfeyxnQ2hmDKVezx7StrpDpmH9CW2PWZ85pLWMfJuThcIWrXHrQ/IROD4HWs/p9wZhL1D71xjHc+wTkuci4DLUYEjdzjSHxIWjQxRBw0xqXEsH7eb0OYOYXekEyWqk1jSxjBtmjImsi1WzpjEbVG1jdRaiJHJeu2SGwnzxYFQ9mRCUR5CgpWHWRaYvqI1z7hwC9JbrRjK6H2H2Axw2z3CjXhhlcizc8Ybn/GTnpnvkmUH0psaJcCZ+YSNYJundE7NWBqYoqNzPWSfIJsYs/XIhctDb+IXkpNTj6Vv0WQmlC19c0DpZZqp2Fp6824xsfW222SZjMgXHW4xwywUN/uWyniBVWZYZwneckPjrWjqBvPoc10nhD8WummBMQ14ZcxQToXfKUQ5JhYOFOWg2rRDH9G+JzvGpIc5qrXprZwkuyK4C8Ef4zAm6UvaLqMrTXq3JEwbSjNDtGMsVaB2KfZqwqyLaJycspjyvVarPDh/2+eQx3mcx3mcx3mcx/k7On/5xYQPM0H6wa+pW4948pw0es0fbz7Am8D15IFI3vHR++d8J1vKg4Y4B4R1walSWE5PKTNa547NzKS40pc1B3ynwI8mfC8TjnuYWzMOccDTC/AdxXgW0XSCuu0GkNwMiTqfEd9fManmfCO+YM4pV+Id5+YpISdsrHteZVOuuGJqXJJ5R6InAvmu452aMx4XJE0A0yfYVcixXRPWitzegmEgjz2vk92g+I5KBg08wRUYJmWnSK2K9sMJRnPDdO9znD4nygRPbyfIYMYf/jOf/0jBu7/aw1+lBD91McWUtn7Lu8TgX35z4H/0x19g33/K0c45Hy9496OWp399jTN6gnGdIU4tuOuYODVX7/cI/wS1KliKjN/dJ8jkhA81oHKdknVr3NUE++mKc9khgik3T2DXeJh5yEUYUxvn3G5gJ2Lu3Y7m6GA0R8bTK741lpwuloj4fwKvf8FXyxvCu6f0u6/YnQd8wJ9Qu1ecfyH585M7zv/d5wThO/7R1Gbavuc4f8Hh37zjzIPMDJitKr63HHZxwcvEQFg5qb6ktXrqcEQjUmSQ4dohbZFwZ+952Btc3GWMP64Jlz6yHbPb9xTuhtVS17gnrC8PfLB7ybf7Lab3QFo849WTEb6tsN7c8ZfF57zZ/LcExX/B/Ue/ZGHmHO/23P+4QP67jlEwIfvqLwlWn5I8S7ny/xHYX5G9jyjOJIv7mLpfkVo2o6xCTlLCqeZ0BBw39sB4cKqQbFmxc450q5yFsaI7hlhZRG9W7LwjSWtyodMvL5dsjw+c+wbfxwcu3pwwDlqsj894+xdvOPvsCVG84lxDFZ9s+YAzRrOA3rzDqjp6AenhNen+gD9eEE4CZCDRLvs07GgcA6cZTn7UsSDbFazXCe6248QN+V51w7nElT3lqeLHn+a8+sMV56MxRmtQBAXmccH77B7ymIvFgrZbcCwz1nenzBYpTdfhfaeNfb8vNaQZUIT9D1uR6kgwjei9AKnj3ukD+kQ78l8OKoouPbK58skO3QAebFRPq6Yo3dnWwLmmp+9KNvKajsmgc5GaA1BI8iJjNnI5XZokiSIpTHxRY9u3eMvTATRRSkEjXLxqzPIyYBq+o071xu6AXbuMz++w1QmtU9FNn1CXGe3tgcadIswdo+InbNMH3t94lLuUyt9h5hHCiGiLGNuz4GKO+aGH7ZkYRoTAplIHEh3duXKp0nywR+hOTe0YA+2/SwMcR4I4Dn7dLj8gLxc47QxjtMOIx3SFPuguh1pH10jCQNL1ktHokmKS4qkL/Dqkkgnm2Bk678Ky8KVFpTbkrYPZbXGqmKQq6HTdwDFB7GnKMcIb400XzIIZbd6Q9TtMRwy9syaVtIeefd1yO/Y4G5uMZgq188h0uqHZ0e9XrIsjM7PCC2Oyg8OV+JppesLF2XiA0dhlSldtkdEJVdNSPwScWw7Zcknc58y88UAdPRQx7w8KVdfD7zgztF2zBV/zJkLqyiTQWh45pjQ8EiWQ0qBqHQKdtGj1RnWN4Qcsw4BRMCfVG0nTp1FbSLTmZkHb39P2R9bZHroxx+SAny1pqwd2rsTRWx37DBHUxLvXhOoJ0s9wrZbliwW7pCIz3nCobZLGRxxjjprJEOmWyBFfp0nGF3QY5JuO9ZuUUVhw5i9Yjm2SUHGkp6tD0qZgFpX4icuueU9pzxhZNrmskXclh+M9294Hb4d6/y2G8YpZarP1DZqmRGY+xSQniUtevLM5PROEFz/0oR4ajyYFYXfIck9hmti+g+X1iGKOMsaUVjnYG2x7RmvXHIWJpd8HXT28t6xuhG00lLWk0SkTO0BKm0rbQswJF4unGOIth/QDjPhbrq8V2cvD3/Y55HEe53Ee53Ee53H+js70MqaxUq7uawpnwqf9e9L+cwLvWworZLk+QzZf8lcfhdTXc172a+z4HDewuGU92K0uTic8iBm7XU7u1RR9QG3PUV3GqHpPoabk299iuB9wFxpM2h5xrm0OS3blEc+J2MY7+vSOpQn1cU2ymBAVBeH6jO+9hqX4Sy7cPyCva07qBfeyZSrGtEqzxGAW6mc/rQ6fIN86/Kb+FeF2QTMZ0+U5HB3sMOVuU+F9N8NaCeI2R6XFYNKSQmDImlJfOO1PuctsTu176jXczjvqkeRZ8Yz//A+X/Kuxwc2/vObwS4Pgo4bMmbK4c7j9q+/4K3/Ef3Vh4/aSTZuw+FLzF+ZYpkv+csp9/kBoXDLrS+TMG5gCeWJwOlnw/Omc+zvBu/iB78WafZlynvmcXPmsT0uEWTMtLUR9x0M8Q41dDCPlTVwSbF0sI2exvAHrkn4yYZoposAE9w3/IXjA+0WIWtVswp7x7SvOz64HQPy3ronxFw/Eccsv/9cpP+2fcNZ+zvFuwy4oOfMkH13O+CZOSV93pH1JM59hS4V571LZ+nz1QGoXeIYgSxS7wmRmjZDTkjKweRsoPgpmcOvgdl/hOAtmUUDZxnz/F/eIcc9D1mPLGapXbKs3vFGf8ZvknKX3DdnqT2n+akfxUYHc/yHtk3/P+ffnfO22yM139Msf4ySKZ7tnVOfvmBxL5uoFV4XEqd6jJmvmdxWpF5HPx3wifD4IAiy/YBwlHBflwEQ403BMKZgbNfmioE22eJpD58CkqrDcnu/fSUazM0znhgs5Q4R7Tl5XNE8ln9gL4kNM+ElOcp9zurGR7obo+QfM1AV5n1IXW379nc1i4fDy8gm+E1LHDX5oMpcVvdaCavab8cDvkmuyzGDntNzYJs96a6gZOZbAOYHVJ5es5pfUVjpUSU7VOU21o8p82nVCVWXkb21af0NbaifAEQef+s8V/6eJw//m97VMsE97lNfiHNVwyC245Un9FKNvoJlAHzK2O1TdDTfaU69ndAK28YKHjSZJZgMcT+qbfyFpypI4rRGmwrHtwc3ZVD1r2dJZObNYgzogEj3KDZhcLgmtljzx8PPvcIKfEjob3L7mIW142OaDEUD6Y0qlCN0a38oJjgk79xlmkAyaPzs4IXdi9t/vuL2vKHMToUWnTjdoIqtW2wRcpp6DrVy6JqZz4h9u/sue7FBSV/o/DzEOCZXq4IlDqzc8qeTQ3eF0E2wNkOGB3mkR7QN2HFGd3tMnO5x4gtSxdXkF8UeUQUNhfocfv6DueirjDrvxKJodvlViSpND52O7EjO38W2P0WjCpj5SFxVd6COnHpZRQGUQHwzK/JZw3uKMTVQeIiyBNGJUM2EkY2Q+onYKso2Ho20MhkFtRoTWgf1uD6GP1US4uk7xXv8sMtLNFc5shDHysMSSviyp8w037QhDtbjzEW1fcd99OdQvqE0ceUT4HW3rUdENYMy0NelLG9+MBtZDXZUD0KZLKw51Tdke8H0H/9RnppcX4kioFy6GST3uCUyboxlRarCn5aDhvINRQYzYHG+htmm9CkNeD3WZtweL57Mptmoxi0tqNcdQARduTzBLGI0FFh/ycH/gWKQ0vmCTSzzVMw1CpNUNsa3CBHO0IxynxLXk7XrDkQzPnSCkz9TyseaS0Osg7vDaiIMU3O5iHlTF8dDhmD3TvGOn0yTS5Oa4JakXRCsJxpZ9b/Mi8mnHFt7EZGcv2WhtatoMNZzeifHbE5SldIsE6oLvrkryY8tSBswsk9ZtcUY2jq7qlNr84VH3R8p8S0OL4dj0hT1sPcdbj8XI5cIe882TBxaaAFutOBkV7DOXYC4R+9O//ZPI4zzO4zzO4zzO4/ydnNbJSMyChXzG7eINb96dYcp/Szu+HJ4rZOgx7s94cqx5aDP8yQkT16Xa1thGin3qo5iwkBJpb/l1/kDVeLiTlGTUUhcvydKet8UNZ2rH8vaUO/+Hg/pFHeDWgvS+xYsivs23fDIOkLOej02DG245++AVRXvNdi+JnAwhbN48L3jyzuVX+ZYJZ7w6sXk7T1kcHYpsx8nHc368fUImOu68Lb2y2e9Cxn3DclKwie8QlUE39djFDua3E+ZTyfxJxnNjwoOZ8uXVhv5aIs9zCiaE3xhY/jvkH835T546/MXtj/j+X79Dp/hda05YPtBc2tz+2RP+8p98w/iPzlj+Yoac9rjr94ilyW15z2Q35tRQGMLn6uKe8v4Cs/ke0Shej210MLo6mvjjSxb2mEOc8rvshnFtcBbYmKaL7zj0uclNkw+ms1NhcogOuN052lpvWYqVaFGGy7G7p259Pq+es11NmEZ/Rvc/fIz/z67Yfp0z9+d4wZr27AOMy79k9PA5X3x65LS5IC4rfjJ2cBeS2qlQB5PeknhHlyKJyaTBnb8mED5npcv6JuC3ncHM1lrDnOVI8vz8BdnUZGaW9AUchU3kLolCgb6jvbpO+O0XPv/3m9/hOx6zy495NXtHfIyY0vDM/hXf5U/ps57g9Ht4+wEvLlvyt3+Eegk/Td7xV/2HSPPA+TOHc30Yvz3hpu8wwzvmh5D0WUaWFBzTE2bLiGCSs6kOjGQAZylH4SLTc2wnZzQzqWqIFdQ6wT62uM57Rk2PlbvEs4aqbZi4GRVzRlcOxawmXV4yf99g/vQFwe6vYfMSS77FY8nedkmKA05no08lTVvy2Utdazin1gaPKkZKc6jCj9UpspuhiEnvFNlXklKVPHsaImqH+CYmmrZ45waj81NW8zMsaeB1c5TyeG+94fa2Q1z9ml5oILuCk4qxP6XNJdVVz+svHf7DXcf/8b/85PcIYHwS0E8N7HqPb3rYTjQcSITWupg+abkjHI15Mp9yU4T0WUkUNjhKkbZ7WjvSmgSarMYwJK7d4Vva5lBT1lpuOGHs1lRlSlH3bAKbOokJTR+z6aljRedbHDclaVUxeXHPzMl4tw6gu+DElxjeEdlGLEdPyNsDba146ANGxs1gBFhNt8xmH7L57o6/uYop29cY/QSyKYVxpDv2yMqAcYu9aPHGHr0IMfwS6UqSQ0byUNDtc+pMv4Akpu6lmwWevaSXFZM+oPQsOnXEEZI+LyFY0pQFQWaQhZ9jNCmNqbkBn9H7LrYXUKY1mVyjrkZ4k1uOBBiRIr3XSwAXKwRbax/dkqPTUZcNzsjCdg0a5Qx1AqEROLZA2jlGKel3PnJkIT1F43qcWCGJkbI3Ba7cYUiDujlB2AVhVzISHWLlcx1HgK6XPGMxK9jejNnsO7iJeDWumNkRubCpRjmtE9CmR0gW1Js3OOcv4GhQz11828cTITs25E2Gbfg4Zo5PhxP6tHZPmxu0eUshFAzbyoZISaTTMwoq+rwlKXpeFy24MYs0pLEzrOl7EHMatcOytNZwy/ZmxV6/lswClRn4Z2fYGzUkIXbtlqoVVE5JVWu7SMpdHZFZFtHI5PkswI1Mkl823Kc2jZ3iGFtq6aEKiyqzwdFaSg9jKSkOHbSSJO2oZDyYJk40z2HmcDzUbGVFk48GwKJ0O4z3Pa6sCMcB4oXkM+cJll4Sac5EfE/p5gTpBc6sx+16jNbD7LRn90Dx0JC3DSfTGaG5RK8iNANDV2uKWCK2JUai2I/2mDpFk3vYbcp47GCZ1uArVhQEzmRQyuiKiT0vmBQXWBTkfUKSBMimQZU5fWzTGQZ03UB4zer93/Y55HEe53Ee53Ee53H+js7YaHhIJWdtj39cUOnDr5oTzeaYX+7JrC2/sB94sv6UwO74VfkGX4QsUoGMPHb+hgud+tW3tkZK1F5w1VTM2h3P+xX50zl5W3N8U5DcXBH2FZ+eRdi7kNf5A6I32HdHLmOP5+EMq4bpKkI6IZPRiuSwJWlfc1I8oxUNlbSZ3tnkScMiPiE6sai7hqfZCHM0ot4m7OstlbYufPzAaG9TpB3+h4WmhnO+GXFx4uP5EZ5s+G5/GPTerpXzTNPt1Yb6NiXZWNjSJH33HPnJgbmcEoY9F9unBNYn+D/9Nfe/npKte8x2x9WnFWfbFSfc8YuHK/7Zm+eIcclXwQN/+ODyfmrDZo6fLPndi9/w6hBQX3fk1RecByukG/Aqa8gakIsQVygm6x4/Tom3a4z2hOkyJByl5E1CHtjIOKTOTBbCor2KOPuJjWMZlHcdpU4tZyFVlNOkFs+t92AJsvoFz39icN8c8UYTkrzhpdfx7dmB+fE5xkTxaSK4vrjlA++M/f2KuH0gPxwpjYjlyRHzIiWwT1i/GxP6JvMnlr5h5qV8y9PMobWW5G0HXod7uuYkNbkrJPvMwZ3coLvOfeXwEB/p6zGftSCMA9N5jPv0jqT4mOwm4a7/msT8mJkP70RBNHcZn0w4yF9Qrv8F7f6eF6ch5+aO6yTEUSZXUwfT3bPsl7RPFPU8Jn07xz52TH8aczG3kdOGw36MeK3oNgFiukIFV6iyIZWXTIJ2eKZuEsF8VLOtBO+3oOwSv77hafCExtLnVm2c2LP3BS8DUNmYaXPNcXZBKQTz+095EAWz+JR9eqCLLRA1z06f4LoBWnKvO8/SkKQbgaueYGiVh93RoCibBjT/r85JxBbDFZRGy7qRfPT8hOn0ZLg89CMHw++JNzYi87Bub+muoPRicH3cfo7VFShXsL6eEec1/4f/7Qf86I91mf73tEyQy4p+47A99jSzgKUNBAGUp9j9NWZnU8ga0x8h4x1J3SDeZ8hOkVcOXRwP8WozCOmslLZXqH5Cl9m0Vk9gF9gaNO8vBzVkaNaslcvN5oCUDefOhGfTFf4LycO7TxmLlEpdoCwdyfdYTRPq/Jy9VXIwJZaoyEt9+xpjqhLfnHMSSDQo9b4xeH/rkGy0SaDFGIUYmUnt5LSVwNgpdm8qxChl9kwbF0yMTtHWLWKvBZ4VvrSpxwuUUSC6W4wOGld3/wWqqWiHmL6JGUxp1QHf6jnWFqpd04cHqJ6TmBucruZULGgqh3Jdo9odgRghVMMosUi6DmnkiL1JbkPhOtQ6EbA9kkiHIVTR3GBOoPUj6rzFbXtMc4Uh9NaqQmlVSZPjBy7+UtsPMurKZmFo2MuGWLn0mvBvj+jaYvCOFt0Sp9K+0iOyszDde9ylh7JmxJHCPGo7RkArc3LlU8iUWv8ZaDBnOtgNjCrHdCTNwaeqBFXZY/tLVFhwjHMOlVYOugSBwDI2qMLA8pa4XoeyApq2x9AqFFbIqKTJe45OwczymXBBajlDIsasfniNaSDiQjps+p5dUeElgk5oVkVLHznDImbhRuwOcuj0WdM1RacoyxPmTk8iGtzzEc+eKmQekCUVSWUO/lbHr2mLHAoIHJvLoBsgnyrQ23Y5OIXXvgnrknxX0Pclh6bDiSb42hYx0tWZJyhxYNaNyYwNhukyH1eU/hlW85piqsE3a9ZxMbAqjm8MKssjX++ZnM4xFhKk5mKUBF2E47jkdgmjCbaf0rVHyianlx2OYRIJm4nt0RiKzm6gnNI1AaY84tQVUW+iOoO6LZB9Q9tkfL9eajEqb+3vMSaf8PS04T4P/5aPIY/zOI/zOI/zOI/zd3V+V7c4LzOWv1rRG3AiFaUVYh9y3ny8ofvqYz42ply/+hvcL5+ziC8oxJrcdglHJ6THjru9jcwUhbFEPJ/xwSrj49Mx55FF9qLn5p1NG0+4rXu+qDaEtcWHRshtVSCLmnbqDmaEsTNnvb9HZRuycs94KRgFI/5B/CF/42951lzyMPmO5WFEpgnZ+rxhpRiVSdcJxE3GsfIxjRr73mLrTwdjly0Fy97D0PBy1+XurKCtevpDT9zGTEMb6dh8vxeMzRZ9hnO7jnRXkMiaz5/OGJ+41AsNzn6P8qZcXEj+638y4V/+2d9QxC5mUdH+kyvSw+ecv/b43Y+2XNQmq2RM6lio3/XY44B+vGV1eML/a/QtYy4JywlB1WA6FXFvkTSK0C8JVTtw6VjpUPqYJHngd78sePF8zORZhCNqnCIjalxGFyus8wQjzCAJaCcp7eGU9YstH94LDpbkb56YWIcc/3BEPp1RJyNU2HERwvrNCcvoPR/PHN7YcPwLeIpg8XSC/KDknQmzGw211zXzkrOJw03ic/C2fDgzCDrJfd2CdUowVbzd3PLdrqGcKoxcMo6nPFnAs9DFaDZY40t26xpnb/FwkRC7M07zip+fvqKzPdR2xLflayp5wT7ewfUL/JdfEF75bEd3BNFn1IevCIOI5iTgg0BxdzXmXl5heBs+ma2QtU1uv4O1xyFWrBaCF3IJucd9YXHcrkH5xFHA3Iv5cDQj6WrSJqYQDsKUw81+LhRTWTO7mFJYOdvMJ2HFiZ9jjApEPsbp3nI+esU32XveWDNEr6iOCfWrlPDdp7QvbjmZfoItrcGgYEuXPN4TeNMBuiilxFvo16lJV9ro+H7glDryguHaZMeWe820G035B38aDGl2PwoZ2WMICpzVAbU3Oez2HPJ7GlGTTFOmYUhjWHTlljS2+XdfeIyx+V/+715x8Yfzobrxe1sm1HFBcZ/QqQp7dYtTtQME5TIdExkRV3cN+e6Wb+OUPM5Ia5OmyjBtqEobxzAwNMBQulhCYrKn61razsR2s+HGVpaCKk0ocAntgNNIckw8JCWd2bH2Op5NLH6sAvo6H0ApnqN5Ai1ZaOApm07rL9QW24e5PWLbNvp4y0t5RqUBdEVMVW2wNVTRsGBi0BwPdPc1chww/hHIoKc2FSLOcZIJcmJQVClpXFAmmgGQ0Zkpaqw3Kh60KxqtiCxDmq7CrDVg8IhpPEf4BV7iUVgpSrS0bYWZhXhuR56PsM0j7c7Cri2yuifyHBy7x9iHjC0olf45CdKHnEI7Q1fTIX5vaPNEZ2LqJII1R1U9oiqw2iPSmYBrkpsPSH2obgOk6ZP0Pbbb4Gvdoemyb00msoJ2T9PM2O5zZouI01HPXdZTN9+xiSfYp3ucZI50BMk+p80VXu3QRS1ploMGE5JjMsFNayyty7VN1ocjd1p7mGiDREI96Snagm6b0XaSSlnY3XEAZNaGS1K19G3Owg+Y2Bl1OaLrtN3jDtE8Z9qakN3QryIs4WHUB0rrSKk+oLc12OcdqdZ8amqhVBQPJSJs8TtfmxzxJxJTZjRZSelKqmM9aFyy0yPvzZS6mWKZDSPRICIbS3qItESpDN8ea9fIAELJ2hYVtEhl8szxKdtu2KTuzQxTCEJ3TBCHTE7XlAeTY1/hn/vksXaNKL5vakzNUBg3rMwFdW+zN1qezFv6+hxO7ul2Hfu0JfkmxqRC+h2NrSi7GqoZW9vBTSpcJRhHPZah3aUes6YlcFxM0yITDRuRMTEFk9rmKCpMt8VqK3qR86BsHBRGrHkuEdZoyovPl0gr4zN+ytnix4QngkjppMrjPM7jPM7jPM7j/H2csXlFtP6APko5dgVPoxO00v7N9AarGpO+3NLehyzcAPvyFuv2KV8bY54/nzCeCpZvHQ73cCO9QaV+plFMlysys+a7q4IXsiDMO7a7HntvErgnXD2EVAJOG4PF85TIcjCkg2UYzEcTLCmH50AVj9GP8+tWkHtTNuUbXsRT7rqSqSHYulo36bAYdVidw8P4gfmxp9bp3L7ipBcYhYc7VZR+i9LKbaPgXCQ0Xom9XXDmzmk/f8/K87lNZ2wO32uNF05hsM9S3qe3XOY/5nRRcZ/cYvcrZJNQXnj8g3/6kt2s4t/8344Q65pvwyTQ3IKI3/7yjOqDX7IsnrL278i3bxDhGZG/gD7jD9vnqHce3bzFiiT51qaSLYdViTvastSVZblg5Dn86Pma24PF7c2MtX4MrhuKvsM4KubqOaXyeLLw6QzJt/E1Ydhg+gnePqORPrn1mjCPGBkp5UrS3DcU45xRHpL8TvLwxyXR1xHH7hrjbsZvi5rklwGWHdN6Oc/WE5xQawvv6AuPL5oMIy24HFsEk2AQDE5Mk2zbc6vuSB0DywzxrxXSUZReyfFugvkyYWSsePcFmI7FrEh5EfrYY4MiO6cVLl+875mdfs0ys/grlZGkZ9Tqmub9Bf18y7murux80uYrkBO+fbhmIs5xd7dEqwXT3iUqfcbjnqutB7cuE2vDeLSgiFrubt6y3raMnBnpyuXMbrnsHFKjRKaKaRfQODWlmdJ4DbI9wTB89pb2rkly1+VQtVjZFdvGYRxFtMn5kKwe7ZbsRndwe4l1cHlyqmhXDsEyIvJCmrZlc7jGM3S32mKkrW12O0DrA9fFHWWYlj7H6Hemou/hsGs4ph3TccPzmc+HT6fg9xwY00pBZEm6omV/33PIH1jvW9p7B/M8p6wa7NalvT3hX99d8+mfzPmvPj/n+Sf+kD5P0Be/v6dlgt8YIByqDnxMis4neZNgR9cswg45BZGEHGNFUUwHUqTR9AhRMV55tHb1g5fT0MC4PXFZU8Z6H9AOHIV9bA86O9+oqC2H+6ygrzoi1yRVBof7lrpp8E4Ft80WRxsXgi217tnLEiuf053UOLoS0Lv0VY3Qr9yuYFJPqC9swt7gIT3y7W1CXfsEUwZdYtqKYbPjP+lZLEfYnk3bNRD2tEIOh8YqLsjfxPTHDmF7tErQ5kdMOwa97awbdNHH8k6p2s1woy50JL5oqS2B5fmIFFx9kFUlYvz1cDPcV3PuypjlxMKqfdpDQmO4VF3PfZ3T9wGiEfitQbt4QpG8xzAFo9EMS9QoI6erDZpMUgxfy9ffCgZrFqGPo9MKVUavFMp0KURNMB0xlVOKpuC7h4rF1MbWnalaIve3nE5OcfuM/RpMo8TwZ/S3CaWxxYvmCDPk2EOTauygAtHgDYdxj1p5BOcRiHbgI1DpNl02ABd7U2HUBkYf6LIXjhBMozm16tmmKW2WE/oVppSo2kEGSvseEaaDoRI6r+FQ+9j7Cqf7AUZTzEMClQx0U+k5WP4a4hGu62EuAqrEQo62dJnDNquxzMOw0EpybWuokOqI39rc7SJCp0dVBXcpRKGFIxtCo2c8D/HGknd3GtTYYzYG09JEixveblKOaUwvJJ+GZ6w8i6ZsuHcVmWUQiYrtYUO1XyFsfcOf4NkGZhliK9j5MXY5I8mmdKuAswv1QzJltMG+WuKebIYP4W7kDGmHfVvguyaqz8lcn0q69Lpg1h5RfYtwptiuTaSDGp32Mxs/xNmqEqcwUXaFLnk4ckFddcTHEtcMWI4dnswnPHv+AU4QUvQlbmhiZgY3emH0OI/zOI/zOI/zOH8vR83G+NcLuuCGri75hfUNZ/YFdaJB5iN8793w3DxbL4hCn2vfxNpXtOkdee3hGhMWKwtlZHy/i2lGB+a2ojZSMqfGfjOijCWZsx6MW5ecYroxaXDP3XbGk/mcyA0p6py8lkwmHse8YO6dUHUdB2fHZ89/Rnj/mr8w/4yo/IOhejwyNTw75yBSnNzClRrw94xjv6GJ9+grQYGPPekpdzt6a4IpXbq+xurGtA8N9/KIfTLmvHuON1KMjJJvE8nXhcNB08D0pWnbcfXNW0bbBePLz4gcQb8vyM57erPhv/z5nxDl/57/9t8YmL+44+FpzHo5Rqx/xevZUz75NEUwQvQFbr7EbLcIze/aFpwvTb62t5yZEVYU4+pacySwxQI38UiCDM8fcdI+YdJJunXFrPd4NYq4KQq+KY7Ex/eM5xaecDH9J/TZ2ZAI7oMC9mrgdI1LnysjZ5qNic0N9XjNmTzjbnTLzS00/0NG4TuEXoRthPT+mrdlzGo9Rn5eYb5JSNIl1qJmPKn5g3BC7fR4+rwkuh9OnJbmq9mMU82P6LgMLbpxNfAvvuuP1EmBubukDSqeLjp6t8E9HbGy7QHSfsg/Yre90Vgy1HXMmf2S7vZLduu/oE9HhE+O3EUFH4x+xiffbvjVE0G0u8c/9/jyumQZPMext7p1z+ZocX25HWrj8sLmbK1Zdp0OACPufOxe8exjCyUc6kRj4Fpk51LNSkTWYFVzRHPPiVqQjXJdDue2r7GbnlV1RjOqyRufZuNQOiX1rOL+wuDwK0XaXPDqaU88qZDCYuO8Zdb7w/N53VVMwwV1W9I3grV8z7nznNAcUVc1ppZr2i2GbGk6k1+9ObI/HnkxNbn84BL74pQjJuPGYD6xqYw999sH2nuP+6vv6RuNGOgZPx0NZ632jaKxO/6vheSjT/+U/+afH3i+1BeSC0xyps0QO//9LBPyyiYpWxxP0OtNmNmCMccMakrlE0aCImmoa/2i6WmyB4SfYoUXjDwDU4nhgKxEgVQCsxsTBoIo0qR6SLMNVaN7PMGg6CsOLcc6HQ50orDJeodZY6GsDLWzuLq55fLpCb43Q7+TM6/HzQ0mTUq69LAqj72KKZsI3xtj6kOg77Pe7Nm+g3jzHSKUOI5Hq6NOzyWzM5fJXB8yDVrpoOwOIfRBtafdl+RXBfWmpw2NoYcvbUUrJb3hIzOtZ9yi1L0+1WL0Giip9ZYaQpgNB3A7VPSdT9/eU+Yv6fsUy9T6yZ66bIn0m6Xo2O9bpP4AemhpNTRRuSiR0lQ60eANhzzZWxiqoVMjaqVBljGOLaHzcSt9WBWorMeyLRzrKRUGbliibBupGk79ijINCZyesS2JjRjpjZnZIYnUUbIWcZwSx++JZEQYGrT9Kck2oV42SK0mTBRyGmB6MZfBE+43R9o6ohJ7qHyE4RJGLUkqKLsOS5mDgjDRKQLfYhGEhJZPkfZMVYuyOjT2AWkPby5p9Vh9Tn3U9+eK1m2wLR+Z74njMfbM1kIVCvcBlTg4uUcjcgw7wvQNIsvECI8kSmL2CgOHyBlztBrKPMe2QpS2ZJQ5uR0QtjHV7sh6a0BUYYzn4M+wnRqryZHCwI8kpCV5oWGRDoYhcN2KeSSwbJNgHFAaO+IsJVknRH5I1JzTVQWGdv/KmswNkbmJ2l7Tbnwm1vdU9gn7TYnrG/TKonKfMTstOTt1afX7pg2pygpHbxjHHqZ0aIqUXPucG5+60T+jI3bfkdUtqS2wLJeR0AupBqE0HcGg9bxh0RC2Dm0jKawSpZkauntldMTpBqu/xfPOEVq33Chm8v+3FuZxHudxHudxHudx/v9z7K9X9HN4ON5jZT/mel9y/+mGp68N2sLl1HbJuhFvdyHLcYkzy5CV4KurA23Q8+OLFT+azwhrn01lk+rni8LgqaPrnC3/cb/BpefZPET0krk2Lkwd3iWKTdXw9qHH+olglll4ZoDsBVLUGKZDX2dMqoCr6ZYP2pc8XO+GpGsUjHkzOmBvO2zZcFvri8b3XLLkYdri34xo1IKD+5rdZM2ki/BzG3NskJsWRa4wRzUnqh54b2vpEMQ9jnKwvRPmm47Kl8ggp7qSXNd73LXBU/kRapky1eD2+4xvnO/xlyE/+5nLN6LmN/9nuG7umRghZbHnLHvCt7cHzicu20TiXNZDtaKz3cEGViiLi8agE4rc6vAnEReJQSgshGPiJRMadtzbByzL58Jo2cucjQ/jAkYLn7Lzqe57jqaF4d2TTxKsozcozFeLOYZeMhxPOZl8T2IsdX+aXaP4sM+Yzu+op2M+WZ2RVwHvxI5WZYhfHqkvQg72jo/zkD+TDc5DyfS5wpQ9o22rb65obQOlKtqmxZU2dAdc20CYFr9r9nx3NHG/crEImT9X9Ist4e0Ia2IxGv8AP7+xOybHjtPowKhzMMIWlTzj4TcNQWnhBy/Ibtcc3u9JX/u4/+mW5yctbv6cPMiZNDM67zukH9Jk3/LVvc/L01c8OT5ll/41eTni6Co4dMT69dMJlrMJZ7oiMT0Q35q02QLD2OGEBlbrUh4THDWmViFe2zFueo73LusnB6a9YjVSJA+SU+MbWvXhYF44e91jPs0pRT4sfNaLB8TmOdF5g2nYtKrFt0OkYxL2AlNYlKTI1qRFc/QKVG1S2pLWEYyMHN9MOHnh8MHziOXTFbgTqqyiNXqMouf+JuHdm/eMK5/cKFC9ha088lxRvX/KMbnDGM/43//PnnP5ImK1nJIbI1qrZqoSru49Xix/T8uEjBjRTml0rmL0Q48/Eh5des4m+g1dbqH0ATJpEE6JwCErLMxQsKBBdhMsq0YYKUr/wKQ+KApMKyT0TMZjk2MFyUFQZjnJ1qAVWnkI/WiH44yRdkSRHvFkSJIF5G3L82c26uiiuoRo6VDpQ287xgw6RkbNWXfBbOJhSYbO+7u7HXF1oI/m9GpHHWsHhqt1szxZhBSuSy62+F2Ab51RGzFFllEdIjrNQQgyLH0z3Jo0eUevlxh2QWe4dKIb9I+Wp60FWpdZIsNnZLc7ZO/QDSyHDtFHtDc7etMhG90wqX061yI3DxjuOUZzT4DNdDIjdRRx0ZHf28i2pzZaVAl2eGQUOrhKb51mEIbUfYKZeYNyMssr+lZRVA/IUcoi9JgaDr3uz2vif+lybFvK0MAtfqibzG1B3iictmJ+YhKWHl9691B0CNmzjxNGcsMk0zUKA+yeOncRXUEXJPgzhaUPuFlHlpQDODDuTaJQDbfpHRGtMgf7QWg6BNo5a7Z0ToLIKpo2QFi6uqEGnSiNoIw7lP49yZ7QcLlwnYGlkbU9I3VgbJ9y3QUU+udS7ME8o1PaZ+vQVjUjTUX1MtaZMWzwDGeGqXWlrgZcFkjDpshsmuJAatccnI7U1uyTiqK4xza2BLWP6U6InIYirFGu1nHOQJnDksxyTArZ0MsUA4+UPQ/5gXxnMbGPpGZOa5lMdMtHziDreCvesH1tEEmBXPaI6QN1OyW53VP3p0NH7WTUoIIFVt7TVSWVXpjYgibS75UamRYQt5RtOCwcdOJBWZKib2lqiUvL2DSoC91hMzCsGqvVcac5lmUhHYOxEeDoWlHf4fcpt68T9s6BE7llulhxEs5wtNf2cR7ncR7ncR7ncf5ezmYa8+HrOTc/PmH59nvefwv5wuRY51idwfW9y2rRDjBxkXW0JwFhXrC/neFXkuTj77lz9fOhzeFQEJoWK6tnvHHY1wWrTnMIJuytCl81nBtHDlqbve4YFYrjw4HtrcF0McXWYGlt+pIuh3yHbzuEzgIzrVASnowv+Cb7G66zFUEnkIVLZOnLJg2tg37XEnYG6fhI6yeU2ylq35MeHKr8oPHnHJoQo84J7JK4AFX4IEz2cco4cDiZ6fpGy6KE/HbGb7VxrXrgwVT0u+/53DnBfWqQaGuCTs9+8wHHkx2f/6Mj6y9+xEf79/x1kZIGJ8ivf8W/fx/x8z+Cy0gi4oJaSVq3w1XFUFXu3AVl0uG5wXCZaedwaDNyWRK2LrMHg5twhDGbEJ3H3O3e8OY3JZeTCYuxQRI8IOtQK8lw2uMAsAy0NpOAKqpIoy1CLPF6i9bY05+0zI4Wo2ROUSyZ1HPeioyT9sCECe2DTf7klMmlxyZ3+ey2J2oVU18vDQqyQj+DS8aNGGDxfRmRipg4URSdjYpShKoQtsWJnRD3CbtuiUhypJcxDSx6NyC7sfg+h/HHHSJfEYzuOFk61LXBL9s7rheSj25sriYpReky/0iz3Xzu72rchU/+7prz1YqHz4+s/vI5o3nKvjynbs7YTa6HhddD52MVPbIeweiAkAbPdFr97EA1mrA0LplM99hmT5XaVFWNiuWQINDV4V2Q0AQtUzXm0otwdOzYqEj06xHBLHrJprCH9PXX6shPJhMsfTm5Nxh3J9SLamCxVW1JrUoCvXBpIYwCMl4PsMSu1Xd7BcJrqTsFe/uH85/bDTrRs3Of5QuXOrQ1Ox3DLlBtzusvJF/8xysCFOvpkXBk4HsO6ET+XvL+/ki1WPHf/BevePkTj85x6DQrzgFXHbh51/Pf/eI7/vjHf/z7WSZYVU3jxKheEBgO/mxGKgVpklOXS1xjR2FamLMC+gZZ2QhZY1sMt91VVw0gFt82kUK/Mzu63qbSHzqdiT8KGWuQhFNzf8zpVYNlRXQGPJlF2OEr6qLjWPaMZcT5KsTxK/LYJKlvUKVJczBpnZygNiiaGl+6TM8lwURitDW/WLfcPZRQ6v5JidCk0NJCRrojb6DsBIySVsdYWhvDa4Zfkj6UVl2u4f0gNRDAQujejK4AGBM6Y0dnVXSdPTAMdPVAlvrgrrkABe5qTmolWO8nqOkVQk4xznzaNB1+Dq1tkhoKr+ox7JguPB0o+npx4AoX107p+56UnsCT+OZ4ULoonZ5QEsdo6IRL1cgBcim8gq4RZPueKmuZtB5Nr7tkHXbdk6ia2nCQKsbaG1xlR8pMokYlu7xD9ilhueAy6JkHKw7dgbKs6BqDsvdoTB9LL3rCBpFW9HHE3kkxwxnKEYgSikxRWT2ukFhuhNKvbrsjXIghMpQlPUVZoeG+vSro0bUBF6ElQ43+3lqMSg7JilkkqLQZousJPRdhL9geaqrEJHcKwsbGcCUPDwV1YJIUJeF1wWZisnT2uP0JtSXp05pNekdaKpSw6BqL2UxRaZBQpmGdAsdqh//pCoBoDPouIk/qwY7QmoYOqTDzTT55MkJVKUklkWI5/C5ElFJQ0tYF/U6xvS0pkmqo+ATjU54ENc40hL7jvjJRB0FyHtO1Pt5DDMsTMvOEqn/A2Y+5zSS9ucXUPA7VUydzXK+l3erKkMLTXgzV0JSKSJq4tkvrKSxNR5LhkJroahOanNzKEUjmdcN4VA1WCDVrGTuStIKyLjGoWGcVYqe4k3u+Xd+xWp3z0bPJ7+NZ5HEe53Ee53Ee53H+Ds7i9ZLDosK8bnnfrOhqn8WvdtjRhH5SUQt7eC4zjDveFvoWeUlaa0V2guOOqRLB90XPMW7pjB650OY2yeFdyG6sL2JcdoUkXWWYa/jrSnLIPFqxJuwvWOqLmvc1t+YRZcwRboFp6qeadkidqr6nywoy9wrXGjMPTlg/bRF/FeCMv2R3+BT/dM28n5KKEqEvgrwJoj8wIqfYeKy7jkCzqZKa/E3H1HGpnrrk1m4AX4+kZD5K6PWzoBNgjtZ8sBVcRRFMb5F1waYMULHFj8o7vNUF56MLWn04swpuJil/bP0pd//z10z/wx3e1x2H43veCZgaBQ9vbFb/1MDe2yhl0WUJSoTUskAfP+7nCZfbCdsGbLui7wR7syDvQnpZcG/e43cFc9GxlCPuE4/7Dj66DLg8j7gtHd69KXnuNzxxx7i+vgTWz+wSMfV5vrKJy4jdCJaF9oFaqOjAVmhNYsOf//uYs8mYzz4pqO4+IIyueRJYbLcGh89y/qBZkTwIkjfHH+D22FgLl96GrC/p11CnkJjGkITo+iOmyHBmNr5lcCIycrNhl85Yaj5ErWi7ByQLFkogxxl3B0Vk5sw1CD122MU5W2wq64ATuJwan2Ctfsm76wVG1wxsvn1hM5v+Dd7qn+H5HZei59deQnzIOYlKumpKVB6Gy+7GWmHaPSvRc+7OKfwYZSV064B3ZTM8V7fHkn1xTTC1mBs5gTsZuHWuTqiHB2RvDrw/w0lZxwYHSxFIg+3bntkiJNf15IeKYgqOqumFQegvaMp4MCO6doihBHVZ0bYevf4B9tDpNI6+CDQMND5NqAfM3mUxcbDsBsOJBqijp2IOm4Qv3ryhuerw8pRNoDjkJme9j+f6tF3MervA+mnA//jnz7j8fITheXT1D0w3VXXcfZ9x9etrwnz9e2QmBCPWVTAA80x3jMzLYZFgh6VGTSDMhvE0oKgN+mKOCBSmpdWJFpmtb6V3gyoxtD060XMou4FE6YS6a19w3JksI3AcifRCTOeHnvbhkLLR8Iomxlb10Atvpcc4NIlGKbJUHG5gPq/o1hFmtABvzfZBJxrCQRGTq5rqpuO3V7qKUdGo6AelYOVTqHo40Dqty14ZiMrDERGYOXm5JZIBz8OQZyfwzdbgq5tqOChLSyEN3V3vUIbuuTQ4ho6K/8AJQGhdzJRmv4dohmCP8BSgHaBgBCmOKHFGY9S65xDFOO4ZTV0gqhvWdkTlpMxmC7y+Rzpj2OrDZY5zVmIVLvltS9JW4LWEixLXczGbFsNsSEuPplaYfU6fP3BkRO3aQ7pDpRuU0TG1FK40qDoXkWzZ9B5+5GJVJcW24n3a0FV75qdj/A8dkt/d0TqwLROm7SlTX1K5FWIMSWNhbzOaVlHVOVmhxQM9ka/BkTZlayHdktZVmKrGiHs8zxu2drtUYNuScShopI3dCMzepFTGkGbpnAV9r9WSgq5LkKrFC2tkNSZWeiEjEMLCmkFyf0C1AsdesL57iwqecDovGXs5aeuTpZofkNGqnsYEo2nx/CWB0JDNHWqjb+57Gm+EJVt6bQ2RPRsa0qNPtetRE20ikfThiGhmMnX0fztimzS83e9IE116MmiVR5Zs6BhjypLgySnrPKM7VARqincaY/Y9juhRxorqeCB0zoZqhdvkrLcNhmWxuIiQXa4xFBiioo4FbW2RGALV62UTeKGDqVWhVjaYOWyr0bsbioOkKgxaxyK03SGFoOGbE8/EFR5NEOC3LVVp0Gw6/LrmZi+R0z1dkXNrGYjokZnwOI/zOI/zOI/z93Ve2XDdfck4/RhGO/pXdwTSx/MCap0upuJQFqSNwEokdtoie50w7sg0/kquuMgVJ42BNB3qo8GVWaG6HLdZ4lk2i+HiRLITDmlaEAUZzycjxp2jUVe82+WU9wars3tCd8au2GJ3DZ41IdVg9L7GKEIsJC9OP2ApOt7Zr1l7DnmU80q5SCkITI9EFYSVy86ySN0dq3SB1TfUqiPpJXdNzje7bLjQm1y0+NGRwLCx7SWiasibGlGMmNgWD7OGSWThfu/R7Nd03gm/KxpO4proiWBkXnIVvmfx1qOxCn781MRuP+L/uT7g/PKOeKY4Cz7GVZJvvot5PhGcRw59o1lxG/BWdPSERUFr+ZitpOoLpq7NpZpz6A1Sp2J6mCIOgtpvWcxHFLZieyw5HkzsIKTdV2z2R6Rrcubp5LdF2mWoLKW687g2tqxCD6dQWCi2/Y42GDNuJrS84Y/HYx6sCVZQ4H585P5dSZMKfrI0sfQB7jZiOi7Z3oQUo1uMekNaXuBsp9TGhjyDdmJi6mRzNiEQU6wwwzVbLjRbbtoNporRzmKsZYFxSdkHAww9Kw64Tsw+WVLYOzqjxq0NbssddSfprzxOPwv48Pkdrw2L5q8z7n/c8kfJnO3R5nDzkqW2Gaw7rLmF0d3g6YyFNmNUGbllktExclM+NlzGwkRMQ7rCpUwK2r6jFhYTvSCRJ9TzFD+K8Q8/wmkyorrgOGp0Dh+jkLj6Gfwk5qlxgSq3ZHyLo/WLyTPy9D2p62PlJSc6Re17mMeM29SiSo9Y4h5zEeJYKxw5Q7oCT6ffG80ZFEh7B5qvYAlEZ7ON9bn4yCcTk8CZcrU58svf3LB7WOO2EbllEbg1H8RTilqxuS7Yl0uePhnzB//ZnE8uRpSOO9hObA40LXz7Lqa42nJffo8VOr+/ZcL+YA+xaieSvIv3LDXfsRnTxfpm3WFh2IxVR9rom9JqiA5pHUunD+h4GPj0skEZDeibZCEwZTHwDsy2R3YlRRvSGQHTqYe0XPKDpNFshsYiLVsCoYmZJUnXYkrw44SdktQKoonLsWvomxFjDYyItA/WJ7AgFQ5v379n830zwBHtTpM0BBQeNYl+aZDvTETRYogCMa2xjXqoauhDbuBIvKlHNq15v0mJa80M0DyFfoDwCWHQVwZ9Px1SD0qqIU6u5D1abVC2GUYmBhiMoUn+Yv7Dh6x9hdO5KKkBigw/tyDyaXwbqwoRQtEJHZG3ScWRpKzoc4GdVCgVUVkVrak3eyPcdjxAHE3DI6n17b2PL1rqWtF1DmWjkKmJLTNqzW2Qgtj0mU5bXhnQB2ccxYFY6z27iJPIZd9nbGKFsW+Zji74+acOX71/x/7aITw16IoeETTDPwxO61M0JVmSk8W6vtIhzZ59qjgWCa6YEFiSZl/QdHoL5+FYkCctsvZwXAfX/4FtUNUNeetiGyP6/C1xdzOoDrXeQqdfztwVnpVzVA1e2ZA4E8qjwugqIiHozLHGVuD2EbW1peltfL2IcHNa3bcLTXQjotJ1AOuE2bgDd8/DXU5jhYwjHUvLKMuUTmMozClmb1Du1+zvO9JEn9YfePki4nQ1x5cBrVNR5RXvjjsO74+0RQDGbnC7GoZJrQzqZs/1NzV54BEGDwQLgWhPmZgxufbH9hlOdofHaHjDy8RnPNevTgvH0Y5Zg6YQqBp8e0QrS4TTMDZd9EcAjQaG6oiXwnR6rKIZqMTa62JZWo8qML0A0/KQQuCbEtsaDWmc2Mh474AKTPwqpxcOU/37aVpuvtPY5cd5nMd5nMd5nMf5+zhttOTSivn6WUNUufj1FHXwyE2It2vmqyVOrzV+LsZsj3o4RZp7lIwQpYN/bKmsIxURphFQZJrzpJ/dc5bziFE/xqpahFmSBj2hDHkxcfjk5HxIix5zd0h+ro9b3ldHXpYunm3RGfYAAq/alDKULMqQrMloXbjknIcf3RB96WNpkJ+74Cr4Bk+c4eYmpun88MyY1uSaLq874m6PlCbec5vNu5rKUYSlZp9JyqAa4uquFVCVNV6bk7sTDAmf2AvKpaQ2NZi+wMoEX98UvDr/hu3LBbNNhH8P392vGf+oZbo6Yp0VqNcf40Xfk7UW9l3MXSKY/1yyvJzyRVVx963ksn/AJ8DpTjHCHlmlVJait7pBlZ4HKaNKDnrJQimOviILE2RgMcl7Xr9bc1uWOEFNb7fU24h8fCDwpwSeTWIY6FD57f6AOHfpu46s6MErSA4fEk4OiOWIXbfiRXnAqy2M03cYbz3SVvJ0Dpvf9dSHay4uJjx91ZE0U5JDTx5HdLqWPLXoZ0tMv6efbmnSmqgM8f0fzg+YGiuY4loOO1GiaQ7zZcTNJiZse27znjkdafGWpon49Zc2gdgiKp+F5ZAtWxYfR8h8S7IZIyVMG0UxmULvYj1UMNdnzAeuRx7j0wsO9zX1ZkpTf4+tWXKzKdGJyVltUhwF27hBc+BdaaLCnpVT4soQL/QJ+5q20wf6PfXBYG3py9MO4Zxwd6wIjQ1hNxpg7kVsExsrniw87qsRK5WwHC0IXReagsa0SDfGUKN3owDDtJjaM2z5gw7StN4PCeReuXROjhdoYL1NkY/orJLvtju2919TijGj8JzitxmzTYkdmGzTEktf1vrhsGg67uDrzuPJyYp/8T8NWT0fIWwXUXeIakfcx+zfGnzz9dcsXQ8jMDH1+ev3BmC8k0zcDE93jipFXS+onZog0J5VQdO7lF1OrnSESQ1VgL5tqHTM29LddN0QsJHSpawNVFdiKodOdVQqJeskTiFwHDXEdXTNgUYSznwCQ2LaukvSYhvnzD0TTWVo3FO0N2bytOPEWeI3+ga+xG1GmCctviExGOHkCbdFR3nzgDB8OkvDQLRa0sKeWXjjEWUuMFuPcOZiWRXS0M6NKfqTMikLHraK+0wf7hXSblBtiSHMYctp1gyddGEKemc9RIOEPtS1gk40GE2JNQ1od9oCUSBG64HT0FQd3UNMexKx9E6xzH6A9Nm9gzc1iBObPG051Pp7bwhDrVj0dIuEfdWh9ObMtQiiDHtkYuo/AznQaW3HRm9SinxKm1YU5KjAx9WH0s6haSqEmw+qmKcjSSdCzFqQa12OWQzdnd264XDzMBBKT086fvaTMc+ezjjsSg67ezzhD4APtzMYyZx+BFnpYGQ7+pHAMDUI0yHXh1lTEv1/KiSW7Q51DYVE7/EsoS0PNc1BMwJsVK+rMDmm7dDrFEmfEPQuptaiKP3h46M8TX0dDSwHzG6o3LSxgRO6YFegwZKNIvd13WY0dIfc0KVvW7q0J9lrsKePYfeYYYVb9rRlQ9+3OE5AWxhkRUtg6qiWJCl70rygbrS+0WRT1NhpRrUXLByTOt3z1f2e9fuY8qYcenuiq6iUwlEJam5y/f6EQ5ZgSBP7ZYuVC8qyHLadRC0rdCpHbwArbg8xXaUIiwBVKZw6IG8kZeli1EekeUAG5oCu0LLjrGto9OtQb+knJkbvDX/PTmtjZIavHHwr0CEWzF4vo0wy2SIaG9Up0tZgsjA5C2cc5u/Itw6u1FWUBx5e13/b55DHeZzHeZzHeZzH+Ts6m3CNHW65uH3CN8ZrPvKekxkPtMJmbcP9Kme2dng212ynORuptdYmjt+w54r6bkwiA2wjZuRYQ4fbNjIcV+DLElvtuGp1LN3kIpB8vFxwHk3wJpoNBp5Rc/SuKVLJ7d0R+VBz8vP3jOsfD1A/U9++CokQLUVXMKpHxKw5s5bIvuHBVjihh5tOUGmC68w51kcsadEEUPc7MGfcVSmHbcZJEPHkeUciAsb4WGbJAR2Z75g04Esogp6rZo9ZjvlsuaB4rjiZn3EwTFJhcbi2iROHeWIQOUfa0RJze2B71cO55E9fuPzb347I2hcY+zXWs57iKuab64azs5ilc0o3g6Lt6JWuPxjsljHWKMLrIIsTXE8y131y18aTFmlTao0dZhsQVRa9+cB7U7DZe0yahkgqVm5AKiraoh54ZiEujufxzArI8zWeb/NwWCPNJzwcS15MNsjpEu97E3uqdPSVlf2Mn64s7s0EZMtXv214ZRa89x3Ozk9YUBP7ivyob9IlwtMGggazMRFliAxtAl/S1dre1pCpkmPm0CqfrEpQZot3FjAXAc22J7r3EAuHp17OujT5ar9mmSr+8c9D6oeI7z7aU9ce39+PMWMPZ/6OUXk6QN3byzvUtykep9TdKUWqMHQdwI958ALC4Al2dc3p3CYSPtsy5/WtvphMeLVwCHSlxS4ZOVoZ2tNbDV1pEt+FtJnmC9QDZ8HXTAs7xpKCXS7oDynFwxzT9BiPalb+jDevjzjF+XC56c5nJHWDWTXD0mo8tZHNCb3+s6SP6AV1VVCU1nCG6voOq3WosulQTW/1ZXajAaQm++9d7oyUu5N3OFvBmWegQoeprJC1QBWC123Ozg35Bz+Z8w9/csbTDwTYuvIARlGyXVfc7Y4c1xl2mlKIknl4QVPqzsvvaZng+Tu8wGM8ntLrzn3nEbXZEHGyvY7kVg1QFQ1hdB0HM7Ig0x17yWHbDD98qVWFbkmlo0SlJnpaNG5HldWouhsi+dIqELrK0KkBbIGtI+/65tWk6yReEDKZlKRVONwqn1sZuTiyMY4/2BmSAilCGsdnrDs5UtDdN6wTm9b1sJqMvo1oPO26EUwvTc4uOtrcord079wafoF5l+NYR5rW4S5O2N7ErDcGaSnoqekNMRBne62ExAdLH/gPdKLG7BfIoKXMteaxQ6eJVFsM9Yw+DgcjhaXWmNZk0EbamYFwE6R9Sl7dY/sL6t166N7n1ZiqKPFGgsmZjzRNyq6CPsd2ILBDpqFg6o+Gnk4jK4JQR3g6ilZgBxGmgE4DHypBVulqQYbSb4i85GCWlDqZMGqh1pwCnbTIqauWqSbalgaHTc99/p7bXNsUXOxJTnq/55DW2FpV07VUZkLZ9bTddKhC9JbD6TjUn9BUqXbZKrzQpui8YUsmlUUW92SFonNbfEvbHQV1Zg7qGmPUUDa6L1aC5kHIlroPBlDgQ3P3/4WR9Jlk5NY8qCOH/gz7uKZoS6xKsBir4YO8CpJhg1t2LjoYYyiF6DIdXaCr+iEdsT0K2sbE0umWqh5UPk1fEx8l0u3ou2aoAlRNT+SlOLXJ4danSA7cU5Lkd1zfV+yuE8y6JUfXf/RWEerygNv57LYGfSawwoquWmCbNY3+QFcubtcQeS+Rs5y+7vFKE8uv8R29uzeI256irnCUolKCzqkxWousMIcUhi87amryVgM1fYQpKQs1bKlxdVXERwgxcBGs2qFSJX1o0YuSoDPwXV1xiZjbI+aV4M7SppKMKJ0z2mrs8uM8zuM8zuM8zuP8fZxRD3GzZBWmXFSnzPSt8KInjGsO9SnVdc+dWrNSHm7v4kQ1XhiwuxWU1zHKjIc6xCjwEFY2XGYtogC/j0izim1UUQQO05nLWacPxj2GqZ899zi1S140xLs5ZbcmrheYmmFw5zKd9FSipG0b6rzAxaeWa3xWPBS3RN0Yc6qXDRnSUERiTGNpOLpNU5aDfU4vRCZzCxOX7E6rzBvSfYFnKjJXEWnLmNLaewvDNIevF5oGs9JiqxPKvs9k5OEbHX4IStdZaxP7RJEZOeOvZpg//jXW84CxPrsUGZt0xY9Xitl/bvGvfnuA73LGYc2IKeWXFm9Skx99nuB/0mLfn1B973L/7IHw6GL2Nqau7haCTdnzcvwEw4dDFjPe2NiJyfWk5WAesDAIVj6Xlonf+rRNxCKwabKGg9nTXJrItzUPecaPVhHHbcxD7KOME5LuO8zsOW/3Yz4PJGduReFNqZ73iMwhGev094Fe9GSVyVr/Jao37DafsrB03FpHyLthWaEvznJdB69CIhEMt/1905B0NcZEcqHtAUISF/qZWDBqMsYa4g70RkY4GnGdlSxYsQoafuaZHHSFZBTxN90tl/lzCvWG69pHBHfI0CB5/yWvzv+YwsqJ7ROaUU7VGSS/cfFXitOJ5qG3+FOBW46p25yv3pbcFTvE/ZT5KEKdJEM12BdzHKvSQetdu4YAAQAASURBVF6qKieUHcLuWFcNSWUSyoajVm1mPcLumeDjSdgaOZan+MyGuN9jTku2WcXFaMxDvudidIaSGb1xZBadYigPx4C2aXS4n1JlBO50SG+nKsPQtrfaoW4apCUwlY1XdRi6Ft4pzsOAd7OAr4oNl6bFfOKR3gmu37rES/iTP1zwj39+xsl0PFzEotrh9fjmakfxqwSWGnovKPtT6vY9YW/g+9Pf3zLBmWsKak1m/XDjWnfvCd2IXsNPhEMhHoh3LW3hYNoZutyAr3AwUZki3Xd0u4Taz5H6Br/wKXUVoNFQCYUtGny9NKhtyu4HSJ8jS6RrYJtTurIdQH1mqGmWCiMrqdiz733mlonlOBRYRLIks3Ii4wTHrfG6A79IK+LNgb470jd6WREOLk//XB/QT7EjB9Ot0GZFrd4rGo9aSiYzxajpWd90lAd9eFU07Q/QE30sa5qU3nOQosEyfmhOGGWARmkO37/U8XIbo25oij3K3g5b2L6Z/eCvFVd07hy9Xton2nnroswGR+aUO4UVNEPiwbJCRtJkOte3yKWWRGB3LWHk4UT2UBmYjqbDpi3RewbTHhIUeikjVEtlCHohqcuaQ65BNwWOP6Vte3LtKa0tKBJav2W067D9MQ9lTLjwubycceYGFJ0aOkNtY7A8n7DODXZVzLhxcOKCnSHZphlGERONDLyL8XBAbZsUJ1X0eYvyfALfHki8TZ1zzPOh0hCEAtuPkK3EKFtcv0XojtSh0bsIfAGqkhw1nLFr6ZOcyWiJpOCoITw6dmZm9LZJsm9p25jd3mW51N0yh+1uRzgJqFTOSAlwvIGQW6QVx9xiFGigiUnXZ1QafJkZOCOtTrTJigbb14wM/UrP9T0/nal36jraV9HcXtELk2PeDCCbIfnQ6lROS3/iI+OS1pujMohVQdnndKWN+96inbekymBsNaxMSWVl2KXWfx75IPJoujGO9qaqgl0yrA6ZuC57qWE7PVKZNLrHVTZ40wknM0FYlVidGICjVV8PUTi/suhoKWSMIe0f0kONIJBTJlLgjSwcT3e8Jji+QdfPGLkJzmTMYrVi0emP88d5nMd5nMd5nMf5+zizxuFN7BPOG1b2hHpXYFce9qjlJYJ3a0Fm59zEFe7MJpotEGU63NJqLVumJCtXP6tNODo1o6DFEyZKQ8hrj2UpmWkgYFZxm+ZcrzcE5j1bnWHVGuu6Y1JccPGy53Qc4Vc9beWSFVtcxyWtMoy+GWrBOmW8rh+GuHjdVti+wbj3yUp9Euwwqn44C0S2T1ofCPXNbxjQW4pLDV0fDuYGVV8SHwTxLmERVJSth6FKnKUkmzpMth5+b6Lcgm3/gFGvaHtt0tIB046mgjxecqVy+ps5nz274DDZ0Cxj3G9bSt/kZz9+Qukn/M7MmVjuAFvXTLDDQ83XX/s8nTtY1Y61OR6WFV2tYebpkFKue62HT8mbEbLM2LQ7pDDxrDH2QQ0w9Xpi4jYmcnrQmHOi9zO6subBajgfjxFJSNOlsLM4LGLMkUt+jJHmCY5v4tzAyHaHZ8uktwjdHXNekpfantbwbHLOsdjy0m14MD1spyTZ7ElaiRNULGYmddbT6LS6C8lwWZxRZgOrH8tVeIaB2xgI1aHsDnNkD8+weSW5K1uWvta1G6RvPI7lgQib1YsRpQZj1ian8xE/VhZfbHziD3PKX8QEiwsqnTQoCy7SFbmZsj3vyL7aYPRalRnQ5hdDlluKNYYfsntweH+tLydh5nWYM2s4r7ZVRa/h+rbFIa8QhSKaCfwIlmZLpNl5vaZauPSlxCtz7LGHKz0WUcGhkdxsTNx5zaW2/dktx9THDTJUlSPkDxflY3dGp4+OenGX6TOrQBgdrFIap8TR9jxKLHyMxkH02hBnMp9VGIuC12nHvC94+jzi7ZuIoiyIDJubdUfjufxnf3LOT382ZjINsXtjSE6Xu5aHmwcO97fUeYuRNjjejN5aMwlPabqKt4vD72+ZEE0DyviArFwMr6DONiT6lxEogkZSO90A0ciMHifQ3X01+O51lUF/kIi+H+Ia2l2vb9Q7v8LyJJ7Qt99ygNy1QqDbTzpmj4oInQnYR4S+vaXH8bU9oWetD2bbFEYZhnfKBJeJnOC5BYVoNCyfubSx7APvb3p+8dUteZIhKh1RWQ6xcrv3OD13CaIQNzoghcQzXYQ6YDQdo3DO+XSCta04du1wcLWtEtPVLxZ7oOjTaUVkMSgBVSnp9OLA8RC6r2V0GKZAqIy+D0CssDSO0z5i6e8pv6Dz3tA1R4QxoS9Njk2O5+Y0Bw2OtKizcAA9tkNU3qI+0SpBH9NqqVpzMDgg9JvOpk170DAO28QU2pTRY1gmjjApWk3uK3EQFL0mtzoD9K9zWt0GGHyvedJQ60VF7w4wzSwvqK5bnj0bIZeCkBmySChVwavZFH9lcp/1mFIvR3TyQUN1ZoychslqyXTiUicFadzSDKsVA/1viu20WOgPkwrDUji2xNNmic7F1BsZDU7RP7da4IoaqW/tNWtC2TSi5VCWmNLDMXvMQh/sBQcdgbMDzlctif4AT/3hH564cQn8jPW2Z6JqnEAMFFOO4IQmqYaI5v2QeFCqoKsMylYnIjrsxkYIXSVpMYXuKuk3nkMvKiogrR2yQ02S9QOp1tJbRG36sG2MTuCHBoWd0Pc1nRCUWxsjjBHOBlN9gkGG2aVMg3OCsKDoApKqRLQKVRa0WYjqekq93RWKolR6N4WhfFzvSGaMBrOKU+fYpg0jA3vu49QGzVZpgQOGbPE0j8PqBp6C1l12+LR9iyUsfNunHyss0wLTQto2bauJr9pb6+LpSo1XEFyc/C0fQx7ncR7ncR7ncR7n7+qk6R7cKda25njyFsfssOWCTlRM7Zp8aWCXLykm+iE/x9E3yZscvyqYBLBvI2xdMxYxgWYS2BZxkaKKErPWl0k+u6xj/yDYlxn11iA2PNo+xXAyxpea+RTjjhTnC4bnUnGz5OG7BP/pjq6fE662WJWLU0447nPCsTHww0a2hro3HO9jMq0/7xLcfkyXigEKX4YZhZrT6fqyZnF5kvujN9RgI69n92DQjlyezg2s3KSfaEh1Q9mZwyXXQpvME2uoF7ixSxscabSBwRCUFxZV/Jav4p/xpFrTewbzPuQ4+i1p9wHrOOPJh1pXeYrn9rz8UvHOvWJi96zzGu+thzGpGY+1Vcyi0pY5qSiMns62cFWPmdS09Y5MW/O0ijGKyXOHpbYUTA2Om4rtEZqzju6sxdoJJoVBZGrVfIcXjqjFLbBiOp6Ca7FOLMbeiC/sjoW/BzlCzGsiy6B9v8HTYPoyh7qhrGtEmOJvXOz2lNDpOPY1fWNi5BapVPRVQ5gb5PJI1ugkwzmRbXOiGxqdRVXkxGlJOYWRKYeDedkIQlNgSRtR11BWXO/vmbgLXJ2kHocYG8mzscfXuzuEmBFYGZfOGWtqjrOQ++IO6bwk4nc46Svefjvi5DRDOSvy8ghmQHLbcx6lw7kwqMd8olXvL49Y85KonGB0LY1asznWNI3DiGB4/lcaqq8EbtARdRaZOSHet4ybnibUJe4DefOC/tt7qmcJF9Ez2L8D80PKeotZeyT6bBkoHDNEtdpi6AwpYp3Ob/Rr0fRxzXCwgfSWQa1XQtJA52i05U1akunMx1kGXH9d8bu3Nf/sT2M+Ux6//Q8e1ztoL6b885+c8tkfLPFGvr4SpSMZzmebq4Ttwwb1/kgvarJc37dOmI91fF9X1wXHzfb3mEwwXBQTVBZjaQIr53SHI7Wd0UURjl4WBAGFJXH9HwBvaX4giRW+1PC4DtPS8XGHTmqgXI9jmoNuUC8ILP2hITWEQ3d6TKQm7buSXLnYaC2K9quCaRgkjdZjOITCQrkGfWNxVxwwi5RaHoj8OXYpSBLBL76+Z319j9NOMFWucQ+UMsZyTLK8Y5TleFOwnB5bOFSGPRxy56MpkaFtD2uM0ECE2oLQYTbaH2rTWy2d3dDVOi3gIjQ7oWyR4wS7bugCg14TVBsdLP9hE6Wpm3o757QdjbzHsE6wywMyUnTFCGWWCPuELpOY3pQ+zyj7LVVhYSsbudlieCOapqTVwEdDLyeKgfRflclQB+idDlNvsnrNU9D1AYcTL6QRFkbYEXYBSvtUjRZZtMMNd6fZDTb4rQkzB3sOEzUmW9fc3RdYUuLbFUXyQFMbRF0/9KxWY233kDhKe4N1/77DG1uMZlM6VZIVGt7SInS8aurijnws2VEVmV4vEYWSWkik7dD2WrcjMSyHToMEDXACky7rqVudHpD4Xo9yI2SvF1QNnWVh1TVFbzOzJgTzmlGtaKyItTpyTBVzadBZAnIbZ66VmGLQvngTidXqhU1PmunN6AHHDijKnqQtNQtmUINqRih9heNYA3Qn6fXruhiSCXV8pFLdsBl0uoJOKpQl8Wxv0BaV25xGBWAdUJmh/52h6SZ4bYvvjXBkC7gUiV4YdDRZxd6oaQsL/YUjL8DRxgbfxUJXPgJSWo3b4HzC8PffHdwBZmqrkqLRnAPN7tAaS4UULoHt0IgjZZGzK1oc/XeVCiybpD2i9inkL5jN58M/jo2uIHV6wSAGh7FfGsiR/m4f53Ee53Ee53Ee5+/jHBuDV5OOOLmjzRZMRxIV65vknt7bEdTnAweMSUdphgRdRWel5NpuhseJMBgdK+ygYzYxcJXBph4PkD4nL1hLAxU51K7JQkasVnJYXtgs2OYP/OhHpxxqwX/88lsq/dxz3vG0m1C3NVn2QGCFhMrGFPpiy8P3OsoiodNJAdvlIjglCh74y8lrRjcRmdI1zwpDW89cwchS1IXFvSipUhffEvR2h+/n+HKBsBWVURONZ4ReS18pLKdjZNc4/2/2/qvZliXL0sM+Dw+tltrqqCtTl2qBahCAtdEgjAYY+UijkX+XZiTRaIGu7kLqK4/acqnQER7utBkHfMEDQbKS3V3We+ZTZt5z7t6xImL5nHOMb8weoYups5mNUeRxhHM9OshYhYbd7mve7i0/fjySrWa+iv+cP2RPS191vD/ghTNfvNrx6/A9r/5sReetmB4O9EfDb399z/orn1dXOYdrQ3iO0Cd4EgurRHwx8VHizs/+J1+/iCKGHuSMv4JcWOCjqHZ93MeQ7mLk5EO6V6TzE+ESk+4TbUImWYhOM9OUEjmf66jkw02P30OfeJhMMXy/4rQ5EF/51L1PeveOw5DSYlipgdlleOHEl+sElVvcUcI7A+JQeHAaNZQYazGpIouMrNap9IgRlbSSe2pi9ANcpJkuK4KzRMm3fKxOHEQFrlPi7hHsV6SBocv3NGPI+9rjS1FNzFuSyxKvestD3XFKj5zmI09Vwpe/3/P4lPL5Oubytc/oYj6ee+5my0b5rIOW+kIj4o91H3M5aKpA1NxuWdq6WXGzEm5dwGMjiWl2UY8fJcbdOeJiIE1CjCxlp5S2nvlu/JE/0wVGYjC9kGZ+TRnN7IqMx/ctbANCZKHbUgQDZb7GE7tH1OJXitmMVMIukPj5wF+W2ALwd3hLDyp26NU6J/NLUrvndOvzr+40v7xQRBsfozP+y//qc/7yqy1OlMeT2LwnDm3N3bcjH75piHJHaybmeET5Oe8rxXUeLzy19+6IvZ3/dMOEvjFMfkRzvoU0XmTTVsAPh571KkCMLcYGOE+aGEMZ+NSeRz0NS1zkAiK0Hlo060q2r4ouVFitKVeOdRQwBQqDj7YZOrKL3GNqEzxJcQg0xkgkngD3FJvLjMwf6WzEkFZUlSP0LKvU5zJJaB4tf7wz/PGHB/y6JxXQh4ron44YUV1FA/Wj4XH0qGQ6WfqsLxwuLgjF1xVkhJXjdJho656hMYydW7wy2Ahk0ibNpsiJPJl6yiTpidmKZEaBSfBlWueJhF621z22Ffl+hOsdWl7EVuTz5fIwiYQ9SdSibrAc8dV6mRIhEpzA0Psd56eZWj1gTUSmLTvhLUi8YpqhQ2lWBawnD7N49QVkCJ4dybREDCYL62ErPIEyoGpDqnaiG2R447jcRsxjSZieiHSAv2pxT8I06Aido/NZ+Aapl3B3ONJHJYXv2GTZQoMVUMdWgJnhjKfPmF78UAmza8n9ljKQ+ETx7ffLJHTheQT+ogbxrcLNlmmWl+FEID6OqcATkmk40vUTs47Z5Ak2jJjbga6biEN/iUCckS8hTaYCVNKRqhGZ35lBLzYUNUsahoiZIiFlYnKflcjfZsVTPdE07fKZz74MtSJCX5pt8TkFeJGiQnGdBGw2I107YcaZ6uThGW9RGIgqY5gFrin3QE+fB+iTXSwvXmNRq5RZWYawRnWfcfb2xI+G0HrLUAM14A8b7Ol+YSAQa6KyxRYefp5j5Zo6sc7MuKgjLAO2O5Z4zVrketahe8N0J1hSYeHMuMlitENpix0m7p9azt3M569j0nxHIckOQcf5XGNPMU1vuWqThXUSRwnYjnmU19UKI+G5z/Vcz/Vcz/Vcz/UfZcmS7yrz+PFDzG7YMAhLangAVeAVGbMX0l29Y+wTdm1ILudKveKwnpieBFjuaFOfFxcbXu1EVeswtUfdTWKWZvZ62Y1RfrEmDxXiHc5yTfmmpPhoiHcx+R8tzdFjfxi5Kyxec0+46xisZm3uaR5zwuSJ/VNOUhiUCimSNZ4neXIFLmv5In7J4zBSPzqK2KKkMTMzYdDS70Q9G+M3IXnZUkWOtk7ZLL1My9NxZHfj8CXOuzVEKuAqiplF/bnYS9cM5ZlkVnhDgn+RMPnHhTEXDt/yfrjA182SBPCyyHh38AgZmZ4CiquC4ODzLrDk4ecc1Il8qHj7oeNvphVGK+LVQDQojpNHKMtEa6n7/tMyUZZQa0USVSRNiO9FeKGomCHJfMJeU9eaRKS1xufODHSHiRfZRB50mHlNzUh/Dmie3rGKU7zB8OXa0Z1LGlmW9QPff7RcXCd4ct06hxfFS4+zCxzqxuM4KerpyE35eol3bFt/OSPbUuz5HuMhJBwCdqmmTCU5zEMJZD8JlsGP9G61NWQ3ltjpBT74vs6x04GXq5x+FRBPNWHt8TAGJJt2se/+6sYnUx2tMNZufHQbsyo6Yv8NpybA1a/YNz/Sdwmdr8mSjntfUQyaefK4rWKqVBhtPaNYKoaQ8UONn82kSYJnE8owIlg5OtMSKEkDsUS7lqFe835fs7IPXKVvOHs+faXIkoyb+QPqes3d/RXlZ9/hhl9SXJxEp44fTygsmX/DsT9h3bCo5P0gJPELuk4s6gNoMfu8IVCfWCIy1LDR4ncnSC1ZFrPxAqr1RJ82fPN+ZGqvubm64L/560v+6pcXzKJAFpX6MHA+PnB7W3G6k4Q7j9F6eNeWwL+gMwO+M3RDh/Ucan7kh+D0pxsmNIfh0ySkn2jGiHm6Z54TXHuFaeZl2z02E8qT2MaOtIhJjiwpDmYS+bx4skUcMkKwKGMYJOKxjNiUKdeF5Wk0nOsIbRyokVmsAsYw64rZlUznCc9YwixjLmds5BMeQ2ywJ5jXeIFjl2wXAv+/rj/y6w+3MjUgijdY1zJ67QJ0cbEjiBLyJKIaW5q7NUPtMXk14SbjIgJ1rOhufZ7eedx/mKkfO8ZeVAkedhgZxpEg9NHBRMCwTBbNbPDNRjr4xbYQ6pEhlpdoBEPJPHXYpMBJ7KSTmEhLUCTYs2zCe/SUM3neImFxrcikxBywwvKR3h5RB80gN8Qgwwjx+DvyMKQoSyKJ9Zs87BwShcVifziNhrEfOE0VYzAsAwv/PLO+9vFUTpmmqK5DeQqxJFUC8es8klikRSv67ZmL+Jp5qBYIzvX1NdFJCLIjBxmQDTPFG8cmSSnXE/E5RXtnOiODoxAVBiRFitIi1fEXVkJvJ6zOaGWqasYlwlOSP8Yxwp/lxhjo9ETkTcSZ5Mv6jJ7ABzXDOKPSAaeht6J6kPQLRS6SL04UwxWzrwnkHgwHnBcsHiw9WsakZugzVklEr3rCxOPyOqP3DDLCmoUaOcqLJMBTGbN4kyZw1EyjJtIx23zimGiaQTGOHcqXF2rG6OSz9zGdwY4VxjrCKSYMHKM+YW2+vJSNU6TTmSmWa2iXxIko6glMw1ntly81Lw3Jrx1hVKDKLVp4EkO/DHqEaRHlKS+uE2KRwO3lz444HeLcjGqqhdegYh8VjssgabDyWfus4/Xy5b7LUlQ+C/6EQF66ycxT+8hBomWGC67aiPLmDbGf4stmQfVMjf27nkOe67me67me67me6+9p7ZKQ001PdJ8u50VJ4HrUDWu3ZuM2qI3jWwPdXUi+PrARS6Z3wYYj86jwopDdC4/NlU8cBUsPoMoDYSrnrxwlttvTtACs/Q2s4iviMKRuGvJUUhFm/offvifz92z2BQ9/ozgkDfF/diKvbhimM+PUU00VaghZrUOyOCQM9NKsioKh2h25urugDd7hRk3rQVzI9jyhmSxTarj0M+JE8SRn0DSi6hMOuqfQHi/dmlXkmGZJpDPURpHFOWWWUbctXiUBcGJttXgqoECzJ+Xd4bTA8aZw5nQK+PX5j/yjzwqqeOSiH2EOOPcNV0PK346OF+s7mnVJMxzRfojvGr7/fk+2r9heX+D7E/OYoHXCWqLpvZDTtmdIRMkrrMiEXGwc7kjVGPJUE4qtdW4IR4XyZ1blwGRy7IVH4QL2zUTUeXzsAopI1MsjnpopwoDb2MJZwJMGtw1ZZRkXekueN0xxyNXlHY9eyfkpQDvhyhWYYeZwkOWqNOOykPRwg0UJyy6BTaQIA5/WSqynIW5D1Hla7M1BLClsPf5JoaaeewE59hv+7CLldn1kdXzJyVRcqS2z+gLnPbHZQHf4jCx/xJs+ogQC6qpF0R43Kf7hLe2ba778Rbqk9p23T6S9ZW7WBD/0dFXHqTizi6+4yWJq/56PH0d23RpXJoTeTKAHajnfe4ZCQIi1T/xK8VW84o+SfnD26JN8CRPwhxZve+aX+sWiYtDpiXNrSOoHxikjCQ1vbl6g3EwarnClRUlCyNgti3EJMLD9TFxGFIEjsHoZ4Myii3ZuScjQ8fjJbj+KTV+RpJCnwi6sl4Ha7sU1X18n+KFllOjHbuZ8O/DDd3vqSVRDFZvtBfdtxbi2vDErTPvIKlT84cnjmPwB3h/51ydRwPyJhgnDPBHIplKVdNUJVI6bK3ybcfwwEITBkhrgQtm4qyV6zow+SmniSFJgJfYxRUIeVOoYfBk8CuiuJCnD5eb2TY9TMjyQaUgoQXmgugVsMXcGWkVYyrQyJg57vK5kNBPqnJDGZuHny8N1Pp55d9fTVz155LGPUubhhBFmQ5KSrmY2ZYR/uSWyPbmkB/iac9/hHxpWnuLQNex/CPjuY8X9saJvWiZjScsILwnoO28BU/itxeoeIwRXie1QHZ4A8nqFF0bEtmX0R1w94uUznmpRWYin7pHUVJlsNsj0LGaexG8vSQwJoxdgA6Fqdgso0bMSP9hh4nxJQ/AFGpiFBJlP6veLfGh0CaNo6a2PsWIhkSmXo1MhU9ctMZaVCTAnnyI1SPplKtmCoyS6drR2ohuFXdByo65Yv8lIYsv5Ti9RMOuLmPvhkekRQj1x7u0SRVIMinSTUHs9YzWhZZCSOIZYVA0+RbwjXfv4y7BC6K6acNT4Vj5/gSsaAeWiPY/ZOZpemuFu4QPI/RAiCRozh3FclBC6tCSjhzkr6nOP8w2Yijbe4PyM0RemQk09d8xKgCYjVgYWR0uvZRJoloSDy6KgqeaFoVEmE+fc57zwJeR6K6zEQMpYV9sl9UDJtZLUCWeXdBGBLBrPW3gEWIfTMzbUmMojzERJc4YsF6DEp2Z/saZ8QHu/IM4HkiqgFfGJDFCuLKvVinDlL/4pX3wnYv8YOnxRrsjfG4gHMOQyTLjvG6pmxBuGZYIv7b4O5FpMzPLlI4M2JbmR0WInyq40vvAz0o6D98SDKYnk/ghTgtRj6u8XqKZwO1JG1ukFryIfOsFAiK3kuZ7ruZ7ruZ7ruf5jrDkJcedqodSLzddwBEmJqjX7oVnOh1cfN9zZmafe5yZVnMsn9MGwXimKVLGLAtZJge85qqFeLKxp4ZZtaWsyqgTGp4mclK//85jrMOGP7048+mfCb1Pef1Oj8oTVVcPGZlDOxGFKFUrClmajooVB8NWmZpW+WBSdH+wjV/pqsYPGeoXxAi7mBLYeb5sHwhlS/4oPqVg+FRsTkcfhknjm6YBuremyiSIv2fWgh3GJNRdsWiX8Mr8mFAuzLKmCiaaWmPSA4fVIcEgXpXXay6JQzukG1R1R0RXfjCHbVBE0sjSUOG/HxXrLzy8qKtshG8Iv3lzxYtIc+w+8e9+x6SfCcGKXBRxdj50z1qFw1BTOfooSz1TMnCiSRcsacLYG0/psook0jok6WSwKYLBgvPFwYcCPTzPB1DLd7VB5T5DlvG/gJ8eM9FoTqwGtBXDZstpeEewq5qRGFSVp1vL64nPq8xl3nsleONpjiZrO+Ilm9BXD0t/J4dknlXOlGnm0Fb4RNUGEaTVdLcMFSy49TSLW9Wb5GcRusR16vpeo9dqwizwMOW71kctozb9+aLheH0iiC4ZJsQkzvlv/QBb+nOMPPd9vai6vc77LZuJozWb1SF5nREZzfoTTacLM4wJMPJqax8OKMoMwVqzDT0vObpgZk5HGD0i1LAoTRlmy1R5jX1CkjssyoPZyjDDxniLCMCEwHR96S6Q8Ll/JYvkXxFlFczLsXl8vyhJRVjf9kaxYEW4bXC/JcZZxHvBT6aWyxS6trcK3domnlyRBHQcoBnrEfiP8uJkmTFm5jJ1tCeeK27v3/M0H+E93l4x9Tn174sP7e/b7E0HuUNJ/eh2rjcf9GDLMNX008aTec9vBh+o7Pv6PEXdd+KcbJliRcIvHO0zBBOjeMoUSh2GY9MykA4rc4nkz9SlBkvfqs8PJxU8TrODsRc4d+7hwXlQBr1fp8gEOwYTqFJE4R7xuSWXYijpANvQSpzhpnJjoRdoRO2Z/INHT0tzX7oQdHTcbiNRmgfid9iGeHrgqE267Adt1CwJQmvVsFRJdK7ZFyJBqcfIsaQxx7IgDtSRLdMeJ+n7iw/fwdD7TTXsmI2+cnOiqIJwDqjvD0E8L82FQFn/M0GbEiz9t+oNRQHfiCyuZJLZSvOxycyn5wGRymYmhg1mmKmGE88wihVd2xpsHhizCbyaMmhaWw9T5OK5R80S21WTbgCD+1ETWnfgZJDrT0U8N82yYscx+Q57MFGmKbgSmEdGnn0CBq0hzHDqyaIVaz0SDZdUWRLP4VWLs2LEuRT3S0Uq04261/J1eNCzTMzW1ixLjXI28Sxwv0hsm0U+dJqo9ZJlky0qTPZFFIcoTWIjEf8rARYYYjlBLFKein4blQRjF1qHkpZjjpOWfB1xkSONiuVF7pZa8VGFahFPBOulx4uXqK3S/wl4JdNBHR45UZRzlzyuZ3srLc8s83nFsj2TeJUGqF68cY0cdbAmKgK3fcRI+QuLIoglvHBiE4TBK1uuAS/QyQZ0xxH7E0PZMMpxwMaEX4HSLn76QHwjiiaZyJN4OFRwZhPfhh0vkpTT/Q3bG/7ilsR1R4pMUF+wuOmY/QuOL2EweILpZsc4j5tgQhYrEH3k6tPxYV0z1vDAVhEfiSaylD0bXTK5DNGW+sBSmCePNnL2ITZwQZjKZThfp2+C1aGPxbYyzAb0ZiLyab999S2/v+KnvuFi94c1n+d/1HPJcz/Vcz/Vcz/Vcf0/ru4u3vDntiJXmFFSLX/51EZEox286GO4cOz8nennL+XHLox049zXMV0TXRzaxRJIb9tZxKey0NiI4pQTl/WIfVk8l7bahvYs41JYffr5nd3WDJ31A13E+TGxtSjsq7E8cPwlLtrsNEY5/9fgbtJ5pxTY7aZo6pg5bcmFdpRmZVyypDqv6GpNORP4NXVITTwVmnBgLsc0qORRxzmSzPpMYh3KSjCB2UY8hSugk+lEgjVh8Ud6GEV1Y8947kyNnMMXky+LGLcDB/jwyv3SkrmQfD1wdt9goYhUX/LH9yF/aHWOQL9w4lI+56PnqlPIv/3BFe/eBUCweOuW+06TSXxDw9AjzOLO6GFBhzPloGf2WUHoUb0u0yhbI+6jOS5rei3SLR4zxR4ZtyTePPUV2ZuMu6XRF9Y3iQzPyKmsZbkvMz++J5x6C7WJR741wIaLFGpKqEJW5BUzZnY8IbK2exIr8CtyRoHAMYcaDUxSVx9ercOEhHJ4CvMyxFiWxAAYPhqaeOWYjYaEovAJTKHQSMLQxD48jh2pg6lJG36DamqTo+XDKuBpTmsTyYptxzg+47z3qOcfLZWi0kY6ORPojgUd8Hy4L0jc/C3j/5QVTdeK7uz3xOmD8VvO+bkm6gCRfoS8y5m8eOTYV0zRTlCnFLln6vEgPFGWwNPDCiZs9YeGNCwCxGkSZf89swkVpnoYdQ+LT2Zitt+KxHTl5IbsLUc0HpDcJ0RLY6XGYfkeoXmLuKoqfXLLOPg2C5uEJ6hVhni3KlP5pYLatdEGCsicS2/r0CQvQhuOygMfv8KOWwcW03kyUeJyOB/7m3zQUumMTvOTu3S3Hh3siP1yiJ6Mg43g6ESU5G8EYjGeO44Gz3/H2+MTtv6n4/r1CrwUu+icaJsytJixrrDaEbo2iZi5XBE4TJNL0pqThhB4nqk4usFv8NMGFT5w5bCuypoHBBIskYxt5rOJ4+XAWRKE/LVOpdSymgYAidhitGVLDKJZtI9Icj0yPjGPL4znBt2ecNHPhjArWXMYJq2jFnRG5U03kS1xMh1MNxnqYqUOnMZ7EEG6EfC/N6gwCJfQtSSobfY+Pbzvqb0/0txorMY/CgYjlJlhTvopwbUt8mnCjYg6mJXbRFx+Sn4iRnUnV6EQvMTNuzqEZCYoLbO8zZxNz1xHF14scyMz9YruYW5/RSNbosoRebA4il599g3YZboHZrPGLibSUyE2NHQPG7tOUSrJElmQJI/56ha9HNN6SlpGHQv9MFvmTQGXmwFF6KZGySCpk48V0qiUXkE7QcdxfMO5PFK8GBFbaTiHjUC8JB9tsy7FoiVqPVLeodUgqrIew5dKLMaVE+DiGfiSVBlsZqtHQn2VwIw+fWSIUZy0QSm9RKjglyRsDmB5MuMTEpGlMksswoIAkWmT5sQyQRkMyh/Szh/F64iLDd2cmVmQx2NGQZYZ57Uh+jKl0zWo9U/knTHNCuWixKYR2Te9/spT0w0DVBkukYuRkiCHTRrVYCba7iKrWMEzMkrTQxSShIxaQ5GSwvV28PNMyBJoJszX+5YFGi49rjR5hjEXskBCFG4JdieAt5BlQW4HS3JO+LihLjZ/LsEQkeRIzaUXJhJ+Pi59Q5GB+sKIZBw5NRT+4ZQigPEmdUEvSgzYh0yTcjR7hyDon46qJDsskNFozszbyxZYtz+zZCS13wMpgyClaya3tLJ3wQdyR78ea/ZDyFB74P/9dTyLP9VzP9VzP9VzP9feyJJK+FQ/1xiD7imTO8LstujwStobmFGNyQ5FNbK98HpOZ9eMNT6PH6SlES/Thhfj7O459ipvW+IlwoORM+Mme6mlhRbUkAsf+LubRO+AJtK5THJ1Fl47Q9nxmvuAnP7smTku+H+5YnVZ0pUSfN4vdWvZH98cTv/jS59Xqy2URKYrSyY6EOsSmHXMfsAt2vO2fqIeKS4na8xx3WYdnNVntY6IT2oq1WTE99MgK0NN6UWDHOkbcw3YYmCNL6AJO0R415ySSPHYrxO2eIei4OL0gW63ZRAHKe7Wc89edRu8OS7Kb5ySl4EidnHnBlpudwCBTfvvuyAuBwn+Us+aeh/nLJWnCywfCdcwmMAS9KKlHlB6olKhEKpLRkVjhCRiKVKIdA6wXkguXrBRZwkw9jCLo5f5dQxpb+rhjLPeMdU1flvxk9alDbG3PRZny/hTycrsllL3kMaFrGwLvgXbvc0z2JL5mXEmk+kDBuDS8VoYPtKg2XprfadPhkph5jBhPYvm3jN6El1XLgq41Hoe65+GpZXYhqfbp4gdOx2ixZuNlfBhk1TjxRbziyR7Z5hE/fOsYS8Pqdc7kRn5RvaYtRtbrgqmwvH86LOfpz/XAMU4YrjvqarUor4XTFpIRupGV9BsrS1xElDrGK0rugydWnuX1TgYyME2GqfboTh6+aZl6WWyHJC6is5CtYmw6c3/fkl1WvLla84dqXFJDMo6ce/jFzeUSy5iWH3B3f4npDtTtA7v2l5C3hJItajS+JBEYyzw4+lHSFhR5tiYQjt4kjnq9JLNJQoqKLKnq8IUeGXj0sV4e2urDA/9SW/7RFxHnoeXuFHCZJ8vgRgYtq9Rxez6wLizHsebB7Ln7wfHrdzP9D1uMPWLq/E84TJCMTTcSzimjk2mfqADMkmOZB9NiZdDjFuYzw3zAzgKyk192lucY39eoyTHIRY/nhWGwb+NlcjYJfMNBFghp36cKLML/9EXanYrEYZIYB3QWLIwA7U2c6hgd3FGGV3hRh84UZVLi2Y7HtuHp22nJlnVGbAd6aeQl/7NWlgvt0L5bogp1lsIc00ziQZJc2IbHu4rxKCkJKdbJVn1FuUu5flFQXAw0XUN29hlnH3s+4onE3QkFU/w9+RILudy5kgkrGX04/FgzBy1zPy/DjcCtBLuywCXjPMETaqcNOAtXIczw+wFVpgsvYbThkqhgeCDOLwkkHWIS9b0wBkTePsrlAZmIhhlOibLeoiTdQSwispiXptnMKDUuwL6HoceYjqdWBi1risKRpo6jTFMPB873LUPkUcqLI09IxmoBOIZXO6J9gC8RiCohUtKAW4a2IYxLXLgmTDqcUE5l8DRZmrNYVwza69DyUh9nokKa62xJDpBXQ+ZpVFIs3jGRwJUl5JKiMSd4GvDkl/J5EkqtnRiWJBBNJpGIZkelu8XCoaeZYaqgVPJLc2orXl4UeDxSFwmFRLqMYh1RROuCtPDw3lYcbxVFHDC2MLQyWJKM3Ai/8OjlPpcvFCGmiEJgjAm0IS7l+kp8y4zxRWkhsZodKo8IektQ5uhju1hMRBUi10NemFqFRKok24ToxOFWMn3UtMaQtIo56kmmjHHtyK/OCzg0H0X/56g70O1AKZ40AURKzKaTWFKJA7XyCieyIb5NIRYYj7eoQc59SzVMON8jCiaKdQxDStdMTGKHCDR67Hio3PLF+3KdMcnzOhve1uLFeK7neq7neq7neq7/GOvq4SWDpBjYgLDWpNuP2HrN43xcOAIEFd0YkXklu6uEK182+SG9fkf1ztHXKZNEK548OkmP3AwkK4++2TJPM7M3oc87tO6W/712hu/Nntf6gvrg090flri8u3PCg2y271raVy2387fYPFhsqutjzUM/cLHdUx1l6WSXBZssU7IoZzL9wk6Yg5Ek2LEtBs7Kpx3EcuoY0hOJl6P9dFELVOGeNEgo1QXueELZBiPdeegvhP+ainEWXpiHy+WsP+PiiT6yjMfwk3p7MMQ2ojhfMOhmUTs0ckifXzPHP3yy0R5lqdMwfAyxpuHz6wzvjcP933o+/Os7vm8zpnSiCEKus3tWxSWdWmO7B7Z5Tur7y7m+F3uwaVBmw9RLktiAKlpMq7BJyCtP8YXvEU4XVHbCi1vSMWC3kiVjQvQakvsVym7QKM6zJZsmvus+kDdbeLU0E/iNZXQik58+DX66GhVo0pVw2EYCHJGkrWlDMPtcXRjMKIpZ6ckcJ6U4+z5lKk5aS/1k2GQDnYJKdv7bjnWXMYQjowA6Wk3eZ+xy+CCnXM/jaagIHsUO3LOdG1Y65ZvgwHgI2LkVp+hHVl9v+OHxkd/eSv+qKC4Uf7G9xK17wjmnChpuzw4/2VN1EatLsS5AK0D/2WOXG65CyX73mSSS0RhBu9M1KefaERU9yfzpjE0wL/vQvmoWBtxRounvz+RfswyE4jFiima+PYRcZPekoVhfxAbt4V+knJ8azpe/o/R+iolvcPIf55h1g/bCBR3geQF+FKJjaV5n1OwjOYtxPhKXJeN3wjbsWeV6ieucc4MnMfbNwEN1hwsihjLnj2PPl5HmoDp2LsLvpgXI/9BV/OZ8x29+bel/XDEFNXnhsRFp9Z9qmBAkHm03E6gEl3XoKMGbKqpGEe1KNsHEySXMXSNJemg/JvJmunamLfUCkBgqaaIyItWIRYp3jz1Z1rJKkgX4V2YhXSSWiZGuronH+ZPEX8Xkec8ctaDXi2xeG48+TBf7QmhWbKIRrWNuj9/zcDgzi/xj2uOrmX4ImCsPJ0RVgaW8HJffIwgTXKnQfcBsFG480d0/YT+2S5SKS9QidyEIiFYRxRoSsf0MjlA+pDzGk4tsLG4e5J2AVuXizfKcz3w4MXmOtLhme3lNPzwwPBTLZr43I0RmoXamQUjweiCdQ9QxZRa4n8D4Bkk/yJnFby+pDv5EKioDZ3FyDf7nT89K7IXziPyCKJQmvqZvPQanFmlX1TZY52MatQD95OdtT90ycGiaCYo71LxDhwIRHBaJlicsg3ZiEHCfWDCcT9uKr8qxW0fU5xOVSOUbj3NoKeVlfzHiAn+h+molkMqJ2dZgU0wU0vYTqfwmmVg0woXXMEkzPoIfxoSxXFyxc9kl0jBwwtmI8L10SRTo2oGgVZxNw2RzApuSKUOj5GGeeDrLZ9Py2HRscmFidAx/9DnUAav0DVV4xjdq+XzGXl5hA54AGCePth0okgk/SJmtZVNm5OuJ/TQtCgTtApJMkW9nxoPhLCyDPCLNJS1ipm96PB1DMWIE1DmFqGmgF05HHyyQ0rGc8Z0EhVpISuw0YeMV+i6gXVeLCkEiRp0umEXNEwqf4YIiKEglWrJ/4ORSIvn/J6EdS99v6SZHJPeLFjbDp+gYmQZLlqyobhavoIijfLHxtHQuIJwcWgA6ycgsQ4PMkuJj1hnKpby4CKkGRTX1BGJXea7neq7/n0sOBaIgeq7neq7n+vtYJzmvDHLmHlGRt6Re+euP/NCJ4rEk84WBIAlTJYdamAUBjTQ5VUxyOWKnknYyVMOBrUpY55CsFPdTSi++aE7oXvqKS6qxYZSz+wFC90D8lFCdD5zqgDxynOKWtq5x1UjIUShPdN3ANS1pKltdwzb9BJ/enz+wKV4u56DAj6jdRxJ7gy9g9KLmOljRNTnvji1nW3Nx1sQikhVlqCQyuALlB6iFOpli45RBzldRj/JHjAsZtBIuOnFXMMUzoxFwdkmYhHylMszqQG0MXTmTHkQgL4pYxeljRv95y7rSbCXD0cnpcKRvc7Ky4Rc/2/Cb3/9brPqKcJLeaSbZQnhZs9aXDEMEsaQexAxDTOqPSz9RDBmz9glElt8PzK3idJr5MRiojgPFGJDFI+dgQrqlQRS/zcDNRYYtc7pq4ClSnJsz7zrL784H/ovLC2pRfQQtl64kSYTxphlix2RGBuOx0QJal94qWGwn8p23CQpsYjn2FUrS7uaZKJ5ZxT5RoRh0wnQeOUp/ZyR1LSBMFHo+YQOHrl8wxO9Y1SVjaCiigU2V8/7jRDg94Cc3vPmyJLiyvJ0+8u2D4pC9Ivf7xRq86iPmVU7VOI5Bw9fbgrcy6Br2tI8Nh/OGOZ8gzvlFYTgmoqZ2DN6wpLOlmSUsswXS78+K8DIkySKG0/ApRGAUGGfErEeCVDG1NfhiKxYbu1rA8ZLZUbUdoe8TBCnH6QNePHK8+4K8vGWTXtDei8L4ARu/xvYRkRY1hmbKDelUEKiIKIqhnIiDiFA7jKjj9UjspWzCgcTWzHFLkH3iuAW6RycXGDPx7Q8/kl284eUu4He3Fe+qA94K/qe7K87hAfc08c13Fd98M3He53j3DXb7nv/q//BfLPfwn2yY4HqxFMRL/mbqNwsFX7cwtgHNqaTu77Hx26WZCbwY5QTCKG3hhHbR0uyKl7+ze5zE5gXholaQ7jGPLEWWEuUTnTkuTeSsZrTRi6pAwC9ZLBdNbAATlnChgUrTM5ojcfaSXG3pTc+370Ye7gcBLizQw9GJlH5aGit7bdhtAgIksjCjCBVaVUsWbJinHB8buoeW6WTRknMqQL1uXlgEYz/SVJ+GDtUg8pBhgV+4OEO1PW6elshBNTY4kyxWAgFmCF5zlcasrj30xxXBhcO7/4xePTIFkOSb5Z/zLhXB7PF6dUHXPDCcW6quRQUpTiZ1syHPUhK5OSLJG3XLjW6FKjslKB0QyfVUkjwgL5KOtusWTsTY9Rg7MQ3yBRDC2WOqZTQc4yl5GQeYeabtGi7zkFujCTKLr4RhAf54XiIrJxvQdB5FabDdyGQcbRRwmQUUoQxvJNazJ8njBdwnIMIxH1j5Pr6naF1Cnibkq5RRTQsw0ycjDiZC+RcFouYQVoGoDixmCgjyiEkLPTUjjBsJQOBQTfSqY7NNGXufqT8QljnzMNIIp7MJCMKOdeJzFwS8P98T+G+wVceQKZI4o5sjWgEuaItWPuexpRjkvvXZbDw2L0N0oXC3MmTyMW5Ch4arNOV+HjkfDLmkWLxYkRPy9OMP+FokVY728eNizxAKrWz8bSXZvSOBS9DqhBn7JdGiH8+M6oKVcBqEjVFeEmwcXhqjxiNKGAunjCnQ9F2/KFfckobh07oJb9D4Ej06tcsXpXVmsd5InIvV52Vy3I+BYCiIVU4WzlivQ5mExnhkwrgQlsfY44syIckIM0UWlhCfcfstztxjZNrzXM/1XH/ngYLU81DhuZ7ruf6+VRBe8OGPP7DZZQQXEVf6M0yq8N0lUf1p0dcdKoxpKbcema95PPS4OqTxMiavpWibRX4+lQlJNJPLYsfOpHbkHHWLYsC2Cr/tWU0CVp9wm4T4RUAR7Dj+ruLrX8W8/vIrstLxw/sfeBQuAh5XVYbKRoLgxMcHS+7Bru0425Yo2mBwpGFGKGpNAYAL4N2LWOc5gXfC6wbCUaTzPdkw4Vt/sXHLmXrwW5TYeeMEJcs419MljsuHNUobznmPfw7pMCSigu6GRVnxJhZ1Z0o/HTlODcmLgkxU1fNEr/9A7C7Ytz0XJl1s2ZsQHu6aRem7TTJ2a8Vf/G/ecPvNwNvvDP0hQKevCbenJQUsISS2hjb16NWEJz1X5tPJdlp7xBcF/d5A3Sz23PtBM3kDowD1soH4kNAKJ+1klnjwgplskzGPE4FnqfUTH/cvSLsb9F+P3JhXHO0jgxZQ4op5b6iDZrEsC1RxmD2civBbsZLU+GnEmIXoaibrL6npmRJDnmvBzlNE+RJdv4/vOIryNoLEg2yOqCJRtVjiYSasSlQZMgUT2yCnm2e8s7f0XC+Flpg3xG7F16HF+Y/0zpCNV+z9O8yLG9LwTF1tmFtL9fLEvL/it9VH1K0hDEc2SUyQeeyiC+LE8iBE+KFirAfho3MjjDUbiGuFdNLEsahqDOdRkuksoZeSThNBMTE4RyIqjWiPv+uZHkOaOiS+DoiGE79IpmX4k+Ql+dHiuZlIUiXKgMT7EiGCzsGwRFuKojxNN0R9yjSbxZrggl70yEvzrsSmIWeL2SOSHkVuaQHqDxqTWzI3Mh4NY1XTMvLRe8R4e67X0DU+U9XyzfmJY/iR9p9bfv+hWRQc2mzZ/KTjZ6/+in/yD3/OF7n90w0T+mFPvHmFHwTs1ivOx5rTPOMkbuXhEbWqKXVGGK4Zk3mRTy92iMQtmZVKWSJ56HpL7zw2QUIYabTIc4QctwKrR/aHjuog8nnNKLEhnVlSE5akBrsSyQOmb+jyFq9VREVKUU5kSYnrZm4/fKQR0v/jHq+fGMsYq9USWZlcZkzWp3oYKXOJghzElcG4Fl6AQnWGuV9jA7FhjCAb5j5YppleFdA9THShx6nL6M6WYJQGT7b+IjnRnyILXY3n6U9b76wgF7jIxjC2wxIhGKUD8VVMr3K6MSTzfOY5pD2dCfWa+EKUCmt8mzDriUF3i8pCzS1xsRNPA3aQ5nJgEqlWFOA8iRT0yTPJzY0W//sYTHgN2M5nozZcX+bc+T3H8xHTi3rBEvo9sSgnkMmcI+eEVSv6uVsmYGUW4MUT1WEkdDOhX6IHH5e2pPmO2TWUseViBcNo0ZNFt94SVzjNjsD4hFOJFiiim1hlCUW+IdFqGQa0E3QSZRnNBG5cPG0CoowD8edYZjMyTpYw9hj6aCGnHvqeurMY1+Jij1b+bGQWP1UQ35JGJUOz57bvuQkuCZKO7jxi8u9Q3gW198grMrwwph8sOopJkpq+VuxFljZ0XG9y0kIRhCHrUPEY1Jz3jpCQzc5jDB11mZG9SCkvA6gN3k4iOQNSuY+CDeMHUGuF126xusZdfkqvuH0UrojHruyXezKwIyMVpb7Cirpgls8kIy1TxtoSzo52OixT3z4UeZqPnVt8LckbPUZlaIZlsiyQVOcMQSBEjfhTNGYYEc4tnTnjTLAM8WZhNtiErD/TKhmEKXwvoU57UhXQeg/sK6gkRkiCLySW57me67n+TkOE/+V/fx4qPNdzPdffl8p+nvJKaO/WQ88e1SriVXqNt5+xzQO9NDkmo+8cOo+XRjK6s0TBE5PdECRHtoFBm2vGu4TbU0+0alG6ZrfVhG6DSWZM7eAU4oWwWnt8/eIFjZyDr3N2Sc3Vmw2XrxM+3H9gf5oYg4g+7nmxE2XAjlRZ7hNLODYMtVpiKI/1E6G+xpUNmX2xREVahB2WMelPCuG12KuNz6MnzZy3MBV6vyOPp0VJYPoR04n4X5YyisFG3DhDLgBHaSSFUhYVgpGn6xuiwOF5A+/DkaJJlnS6F/uCRiDcT5ZzOeGsR37rLRbUw8rymc14vI6Z9jVmCInLFf/J51/z0f+BwZypDhl6NbI5XzIkEnGuybuYQdcEQYdqfQ5dzOzNmLgnnwrOXUD1dJQYCqYiXCzKXdfztpu4bOAm3hJnHffTS57Ov+Onn29Qq56oDzjlHlfO57PrBH3s8ORMKzuyQBgREftxWGCM8p0WiFVZeYQC63calRa0maX2Wy5NuMR8tmqkt2L79hGjd6gaQt8RZBJBLlYZscE7Vl26KD1CAdZvT3jGxwinbSMt60y18rnejHTjS6K4pu3W+H3FX7x4zUFi6upCvmHRecPPS8W5jykvJlo6/vYHzfYYc71boSWp7Jzw5rViimr6MWWTepQ2Yj/0DJIyZ1aMg4cRVp2E3zXTYsfwfLEXxOSNLO96Ku2jZGAmrAWxbtiWq+aKw3HENZroSmI7BzIvp2sNl/MVbfaBIMoYn3p6X6wjr7lgzZg1MCi81KMIY8T4L+wOMYV7U4b1JO3Bxw8FiB+B/0iWOcK0oJ8smcDWdwKEDDn1He8bD5esFr7c93c9F9drbrYl797t0XPH099MnP5VSr+V+8jx+ouM//0/ecNf/OqGb3hgdXf1J7Q5SPqAnpaYwsaJ5CGkG06I3Vo2t70LyacrUs9gM80wKLZhSHrloT3xydslgk+AJUnisVpHJLlDC5nft9RiohJ5T2cZzEQ39+hRoukm4iRkcGYBivietNYRxlZo+XcGV+TSkIUNYzVweBowY47KL+nNR7yhRfIoA2bSLqJpLf08LZwFV1nUGBGUM5iW/mPNVMdLWsHcnpcoF5te4gmwRZ+Zxo6py2jbBNcqlEjmZ7Nsh0UGZTrDOOllUumNDhMFpJEmLVKqasYz0I8tUb7h9Y2j6XqGxz3dfIVnPikoTFAtcX/D1GKt+GEMgdxMAnkMcgTYKsCPvh2XJtzf+mSeWvgUQpKV4czUG6EqfALzqYl0E3H9KmblaT5qw+M8cG4HrGlJSo1et2Ski6+sFYaCC1ghbAAId2uO9weGRn4XSV/occNAuNqIN4FkskuMiT8GXG169i6gamo8P6BOJ4Kux03lMlQqkOsnqQ4CXfQWoI9s0+dupkOULxFOCbSxR6tgmQAL7ERmTZUZOB5m7iuDmQMKAak0jrx9xHuhSaYQv3S0LuBmt+b+Q08335MIN6GX6bDEaFpalWInhz/sqQfNLsvIk45D5S+DlsgNzHNPM8xEakUQD8TZmbuPlnnyFmuL2GmKPGOzzSkLxame0NMKXzb7iaRCFNS2odmP+KMiu/GJ15cov128gtnlljwYqbs1SW7QKie8CBjCHDM+cvUAuyKh7UYO3RE31wwuwgsH3LShlqxf70wnzAznYSO7eNMyIpROUeHApFq0S9lEYquYGZoZbwqWGKCTbXDdmUGgkHJ/egnOTVgVUMvz0vTcjxnReEcXl9AJOOO5nuu5/pT1PFR4rud6rr8vZewfuX75it//riItZr59OnIVXbENPQ5JxavNSM2Wfa9pTMW5/aQIlnjwy3jGJSVaVlfDSF03fDyHzNajSHpebEteCe/LtfRJyPQS4kTT1x6NCqhkSWIURVRwd3jkXXxiei/wxpFN6uikT2C79BovoxcU1w2VpDrMI0VXUI17LMkCKg/KKwQHbsxI6EdUwvLSIVf5Dm9qGad2CSOv/JlIrMe9otLTYkHQ1YgvqWtFRNxJlOUT2lqu+jWd15MnIakniukBdx5g8qCAyRge9iVZ94S+2JI/TnxuLzhF74jqV1Ra8W7q2LiA7eWIO5SYe4fLQkZ7Jlm/4qsvLc3LZLGPN9JrhMKQCxa1r9cKdy6mjxXmLGrVmDzUzLJ46weGbcixsYRtTDGJXVtT32qOec3V51t+E9wxCGxv3TFZt6hH3KPHX9svOVwNRC8Nx+PE9/ZAoC3nYGDXGkwKK0lnMArra6yR877GWzULO+POeeR1KMZlxnBYBi0SDylKaLnGQzcvlpFDMfN0jMgfNPqlLNUkpWxiDj0KXWKKkcNppniccDuPUKCDXs7lRvGh35Pzc4yucKOlLny+vkyYqzPXxy94van43lqeUuHtObbvvqAqH/nLV2Ij8Hn3B83bx4l5JzbsinGEy7FAC9ChnFm3KUUoi+92UQWIQtjvUwlsWxIKddqhooKukzj5iHBIaNTMZZwy3eUM84R++T3X3QvGmyv0uaRXBx4/PDCkPXmwRV+lxK1YkBvsvCXq82VJLDwF69W4ALwgwJsF0C7L0xA7ylhFLzw+38+4uglZX1WcTiP5KiPzS3K9Ibq+Zc9E3XpkYcs0+RzOM8fkjzydFN++y3j/O0Uad9jI46v8l/w3/+2a/92f/xPun+64ePT4UH380w0T4mSDNw009sj7O0MsDZ83otKUwISYtsYEI5XEYrQhzmguNopk7TBzyrFraPuGYA5AJ8uFKeMIpz260TA8Vrg5XaiY89TRjYoid6SJW6JUYqdII48uaBYJRiAS/0jAJgLuExnJxOGh59REzLQLNML2K0zbkaUDSZLi+j1zn5JeXWOJGET+FFpUG/Dtj3fc/6HBnMQ+oTGjJwYNdDAQJMFiLZjHZBmSuGlALw/NjKcTdKixUYzXGAJXYNVhaYa1HSjSCxA7TtET25CmWeGFBWU8L5EiLQVaaXK1oxGLxMOeWewkY8DgDmSzL0p0IvHyi93A2gWs5+cexmpqqwh1gNGKcayYrGUYPOYRiiRgnYYk6cDJHhEW5NJw7iKG2TI2K1a5xMgcOZwqOsSOciZ3a4bWLFvrlUzbkGSGePGuHZo1hW8oSp8y9vCEODr5zJNEKbTMHDmdFNcXETdXAe0pYzYTpps4y1bdzUtWqlIzyvfx/GGZjImrSGwUWjxjWgZW8u72mORa1xFtbbl/HOk6R76qudjmfNgbjrJV32t0WpEq8cMNaKGaWr0AEwWiqB/a5X56lezpusvFN5UMYrXw6aKJKPTwJ0M7zASxj/EKmj5mshrtJYThitmrOArQ5N7i5wOjtrQfWkLXICzYQPggU4PXrchFZWNSTm/l/j1T7tb4X/msJa3BvWRcJZi3Ke1bRXLdkNoSLx0Ipye6WVQDDe3B4+hGjl3LGGjU7JHO8afUC3/D5Cv8LlziLYV5oMVPlUdI6IzAOAfhjohVxA3EhMsE3g8l3nUmr8X+IlDMEDyBUepP/AZdkjrNYVT454E+TChdTu89/F3PIc/1XP9R1v9SlfD/7p95Vio813M913+o1f8GvtHv6Q6fc7E7YX848Uf9Iz/bhvy2L6hHxee5xglnKfNpjjGH90d2a80gCQdNhYsrbOQTZCH+4Bb4X9hcUE0bxt0jnn6k1F8iu6rOhdy923N3/Ld4U4kfWjwrCVMV7W990rnk+gtLLMsOWRSqI2WyJkpF/B9wM1u+O3tUx5an0vBFcSYSK8bYkoU5vhYLqGI9ii3YEhUBcaAJm4lzfcAIWNxJbkBNKItDWcokit5T+GlNOsqiL1o2/X4vZ6iZp0FA4C2hNH9lSBdA2XcMqwPqw0+pojtePd4wqJaLYMv31/+G7d2XuHLmzTngKTjxReOzLjT/rDkyN/6SzDAWPS/fbMlcQF0emboR//aCPp+oJSEhiJaEt2AY8INhaWAPe4XtBeY98fpFRrLWHL5PaWeBTxpeFR71TzdEB5+5ScmGmpt2C8pQjFvu25GbNy+4dA88rIWPFzN6I2EX8Z194J+mO1InC161xI/ncUl3MkvKhfE9plZxYVh4CedGEUYxeSprzpFpGBd18P0wcX96xHMr1EPMWe/x6xQ9HzBi46i3qPVEYiM6r6Hyn/C6z5eMsm/OE1+/gFzFlPqWOZx4qFvSLGB/3BNWM/XLnGbyyHXJXReSXmim7R0br+f16gXfiX14NzD+MUHVIezOPIaG908PFMNqSeqrworLKCLwnKAOUaGkeA7oSZTMirn0SHOF3xumH0VV0OO/iBemwWgsfXtkcCF+kzMW/qKaKNeK8a3Px+EjhX9BWm6Iw4JojJZlp6HCk7BRo5gq6YmkMZAhir+AF+38qT+yAk6ThbOsnRNFJ1bmXjN1w6JWkWHZpkzYdBln9cAQDJgVpCePH78f+eZ3Ge++GRgPGreb+M//6SX/3eVfsv5PW6qHIw/nW+LMZz7qP90wQWTsmTcRpAWdxDwOA2WU054kGUEgJAG9NFPOLA1f6yv2Qo6vVxRzi+qP2E60BwOJeMZFci1QwX7CzPYT48AOS/Ymk6U9ziTRmnhraYxslh1l3C0Zm/VkCIeIdGXxs5bJWE73R/74VjJKPZKNnMyeUJ6HjjyKLMKFklV6Qfn5mvDyjJIJkqQdjC3nuyMf/vaJ8T4mlFg9NTL5oEQFoQeSULxbEbPwCKRJlbgXf2Y26eJ3iV2Am0YG1RGqhf6CEi98GRNv/aXxDIYbhvQoWX8UvlosIFMzouSmMB1B4pMlilGVy3AhNB61EsCHRPA4dGzxkhjPzMvh0wanJeVBTT79uaFSPYPSqGgmDAJ86wglASMy1MZxfvjETAiCeZF93ewSurVjk4wcppgPpyfScUtUTIRqpNWGpjszV5p69rnYKhINzX5iJRDO2uCqM3ujWUnkgwBJZp+xDRmE1VDXbNIV6dYjDjLcMPPwNFDPHblJCUWKHzhi+Yx8j3OjmWoDYcsYSxRkRocMmOTPNDSD5XHvmIaWJIdVtqPvPvDNvUZ3OcPX9/jdBuVEzPKePBI/0xVB0spIj3GuCbwdeectU+6rXUKkLYdmJtUbsvg9QydytpCmgunBEKxGhtDRD3LgV/jyBDeiEsgY/Jj7pqMZDPkqxqmBUyO5ryd8ZXh69BnPkHreAlD0NwM3r66JAsuTy6hNy02QkxQ+QzNhG3lWHvDzL3kaDSfvgf60xuRCDtY4TkyzJizW/Ndf/iWDX/H/+PbXPB5brvyAJIiXnOLAl4mvRk9rkmFcElScTMp1xzRLykawWEJUrLCqZTASOqKovJnQPCExGtNwR95mi9fPDQVDeft3PYc813M91/9KPQ8Vnuu5nus/1Or7GyYdsHaiHI1IvZCDsnzlnciMLGAG7HomujiRnWL+9f013nhG2Z7A7Jeo8vXKJ1j5DGTk+yONrehVuihuz0synCJJzGIdjs4+ydxzMHuy9oR6ecPD+kxSJ2yUyNonjpuCF52jS0eC45mouMAwLelhAfIzPlBd5pjeY6hGJkkRyI4EfvCJCaaEz2YxniPyEgLl4Ty9WKlPo/AAHNnZLBtnL0vILhqGRLM5bolkmThZonGkccJIc5TdQFskmDLnC1NRex1jpPjy/EuOYlUIfH7b3/La+nzQA+b8U5pdw0YXDMNI7w3ssw3xOubiUrH/ceC1gi/jDQ/TiY1KuXARZ6+mWleIYGIaHWmWks8B9+1EowSoLTDDga2f4ydbBhFISHxd8MgHiTjfv2L9WcdlLBy1iTyc2F1HNG7mXPW83O1Q6US1uYOj4SftC/6HsqIwPRdiiT2/YYolQhw2SDy5cNlGyilGldALLL7aEAQeXnEgnc8ot6KxHl1rmWTI4DVMQ0/zFDMliuDnjwxnQ3VbkFykBJkibSJ6XyDp07IQFu5AI3aLWjpJifeUhIeIyh4Wm7q6GNFTwKlyJPjY9cj5Xc08lvxEH9k3W95FH7jJt4hwpJ8UW1cQ/kwS+PolJe2uFfbbHeNwu7D5Mu81vcDrfUuR5KKfp6qkV/OJXk4LYywJco7pE/3lSGwqPC8hFrvFroMh4IqIu2zmxRTQrZ7YBlc8rL9jNZccz2fytCSSQZYXYfwD/rgWIcwCOrV9KdnyBDqUHAmCSfL8ZrzAw5e+duk4Nb7y2ZYBd91I96NP/GWAK3om75HRF0t0SjlmaDXT3DXcfh/x47/9sCRl7LY5/+S//IL/03+7JjIlH/qB94/fLEqfMo05bpI/3TChq8TYUJELrVIJ3C3DeOPia0n8GS9RDJ7E0okMQwARYBqfuT4zyDbdysVpccoy2oSqkZi8W7zB4zDHELTkItcXaKHc+MWAmnuUsAOSivEgLvoVgdXcNQNF1BDO5bLl1s7jx3cd//K3Z/zQkXiK7j5lnieiApSALZIU7yokzuIF9peXHr1f0pxCDu8rbC8PRMGghMw54ZkQvbPEW0MuPLoiourFgzUxuwCTbJY4QIZHPHNGDxYTpCh9lsERvj+TZI6AjGClGA+yferxO1DbkrgduQjW9OsH9hjmOERlhrgXr7tlFWh2esv9cMYTj/9ol1gQUWGYqsOTTFw/xlqP9txzN6ZopcgiyV1d4QcRjdeCL0kWI5Od2OQ70oUCKhwCUVp8AjuG54y0jtD+QDCHpCtRM8REtwGcfMKXLVGhSUzGxa5F+SlPh5GzQEEkAsY/kfjpkhl7UW7IVUinex6f5Jbv2FxYQpkAZJKEcOLUzVxsCrIwXnJUzST5wkIOMfTehO8042G/RPYENifezJzadxyPEaM/sEky5o1ha3M+nj4wthF5DaUkiGRPPJ7h8kXC0/3DYm1Zh51oVdi3M+NwoFuiXgKy4cRj13Ke0uWLwu9kkpjQ1IpquZ97Sd5k7Ce0kmhIgbD0eGPIrKoly1XuNddOtDIRpeDi2hANjtPHA0aUJ0fN+2Lmok6xveKp8/GmR8LTNetXhnd/hP2o2RjFy/LlMlxpx5nOtIzhBV3bkvozWSBkYo9e7v+xoRhEXdAuJNcpyEgFpilzuFGGTDPKZTjPZ9KSdvKEkUGfFvVBvgAYo9BR6Bwn3JMsYGUT7NAwtjL13GLKE927gPDm94vK5bme67n+3dTzUOG5nuu5/kOr4MWezVNOv2sxncixv2CdnunNDpQlrE8EseMqukArSyzZ9euK1jncbcKUhZw3Dd4PmqRT6FRA2h5Z35Mr4WXlaLJlEXXfjczxwMUmJaxuFkB2JvHYdof2NEnhodUl+R9v8Xdr8sJxwWcYZ5bF46hvUeNLXgUHDv6GF1Zxcg3cG/iJZhRbp/jhPZ9IC1RxZHJCyU9IPMs6X3EYWubgkTocyLto8eDvpnFRBd8lDUEPuQTzGUnd0lTbEzQtnQo5+Yaf58kSBT8/jjyahjTaEc17fhve8yv9Nb8un1jfxTz1hnzrcZoqrq5yvo+elkXbn++v+Sr5BDq/yC8Z/QfqbytMnDNKFLiXEYyacjLkAuVerNEdo1g5KLksJy7WOa5f8ePtHjNGhNOJV1oTrSr2K5+vDnqJwHy181Cm4PHbNT/q77nKIi5txu2Dpl4b1k8N06uK9ceCdtVxHY8oVkR+SrCL0GJlsCPuKmMcT4sVvS2eFpVC0V/hwvd4Yo+oPOrztEDBbWZIS4+8Kvj9fs9KGb7oXi5sr9ZFrF/4FF2AHR3xpsF+maCHgqlvudCaPPLYCq/sYkv5BE9jyKV74sdkpB7vuRj/nOtf9+zjlim+4vvuyOUq4WK6WNLpvjvUrEkkLJ59a5nXE5l2rKaA+3SFqSJmOY9vIgI7UQwTYSB8hACXgCs0eaLRZsD08XIPS79JnDElLeEpJ4s9zNWMvU/IX2uUNdhg5CQ9me/x8uKzJW7SqYlzJw4AS5ifsYeMaZRnwi3cCGmKlSyhPVmw5sSBjw7d0uxLF29tSKxnfvUyx1/n3H98h9rMvEy+YpfCZvuO+0PKWgYLteaHuuH22MOsef3Vjn/0Dz/nv/unL5m9jFN14qqRQWFMO9bU9ynXufvTDRO88AfqvsS82zOpa9AnzjZiVDuUrfCagdLV2DQWiAJRK1INDy8+MfJigcZZK94PkfBrDvcdXe2TSCyfkQckkpgIUj0wRylZmmBF/q5CCoFeJDl2lobzTCqUf38gVxtSm9Kakd8fnxhOLZvCY2wqpniFiwLmfIX1JpJsRIkFo9mTqBzrjWTZA/HqBcXqnh+DmWMIvTaYXpPnay6+DIiuJFtW0dcd9cNAXUnyXkISrkjTA9MQ41XdYovIww3WNQvvIYoM6/Ka8iYhMpKpWmOnGwL/gbE78Ha0zIFPME/kqZD/PcYgZRgecMGW7KchSbTifBgZvguxLkCPe0ZhbciA5CQvFGmKZVs+o3qDF1hc35Fi8bKIyQ8JxALRScKBpYw64jTGxiNjq1FuZC92hvOB4sKR+h6DLhn8kLS3JHFAvdzMGX6TkVx5ZK3ixycYvY+kRYTOL4hnw+3tPWs2ZNfjkoaw9TZU4cCh0TweB8L+CG1MeI4ZhEngQx6xpEQYY/BESbGW6VdM1xhaPgr3lUCvUKPl6SN0dUv8C8dFZsntzLTZ8Or0lg8YPnyM2EUtq13HbvcFFffsphueJB0kDrBny4NAcmIHR4+37p7QyZBFFv8tXpDgCoVugwXu+GREQSGQngviyLLdnvm4H2k7S2Rl4y+yoxhrYqZxZuxStDF8+LGmfdDkKLwowF+FrKyh+uC4D0eqAZqniOq7P7D+Ol8UGeL7Sj+LSOIJcyu04YCplnv9AefOi0JAIiiJBObxnv/77x45q5FMRRRqxRxGy32xVQ4zJAxtxyRsiyQlEeVHYBmmCCeDGS/9xD4Ja6Lgc/xRrnWP6+tFkSL3sYfPpCQCyFvosOEgQMzneq7n+lNbHP4//fPPFojneq7n+vdZYxJQdJZvNhNFVbHZ7XnjNgy9WthOv64a/hMi3vw0oPITXmYdQ5QiSXn6lcdubYiamQ/nmVk5yilgdBHz7IiMv0AHZdGYdDkfVM382ZE/Cy8WefekLjh1Ad5qJpkLrF+xusi4byNU11JGl9jLe2wdMVUVnxVfcDAVjfopcySA9DXeeOTef8tn56+wxcSkLJ4wzhTLecdXEjQvPvQZL4p5WRqy5pLKWuqoRtkB01wRmoRcnalNLXrRJbIxcyXjeuCd3nNzN/P54cjTOqY2ls+inDqY+LJY83j4yO4x5/BlxNfnDT/oD8x/vGT/j6qFf+XOPj//ySXH32k+HFrcqmWz2tD5LelwwTm/x0rEZa84tj23Yrd1HuvjjNLzkuDVtkby7mhJ+NFOzMcjvu/z+qc5P/woKXVwGef0TxXtjVjFHa/qL3lU7yhENRyuOY7NknLw2AXcJAJrXNO8PWPDnK5oeDV9zhh95PP8NW/LW/yj5SK5WQDgViWoWT7bEyKGGMYGyxo3OlrTU4cTgXWsvdXys7yMW+Lmio9DwHjtWO806t6QnzyGxNH5UBzW+PGa24dPIPehdBRRh68/4zZ74OLHEO9CU03yUWva2yduq5bVuiGfJWbxiapfCUmO74BX52Zh+4XeBpIjb2JhVoTcBqLWaPgiE/h9grUZkTT3TIwPYpufcFu3LIsdHUryL1xEdd7jvJ7OP7F1L1h1FwxTjwliVust43EgC470jcbbnZnMG663lwv4PMkSbDjQ9pKW15DN10Rhxijcvn5ASeqgpCE6TTBtQVIfRX0cezgtKQvdEl6gZBm/yYk+j5kPAX3nYWShzERhYzLdcxhO7FF0rw98Xl2R2hf8H/+3Hl//9Q7/GGGaBjP1CO9els/f3b1blpO74PpPN0zIrkvMXgj4Db7YA7yWyApZvmE+t0yFWAxGkjwgXntwVjR9RWYNxr+nn2JcckHiJHLkRCtekIPH7Es+qWKs/AX+EMWWfDWiYwVztPi+i2xFqQvc1OK8jsv1mjD0Sbc5So3cfjvzeKdYa7fkfUIKniITwuVGESUhNi7x5oGiTBYf1GxHXlES+dLYrvmYW+x5jzm3eHpH8jqnuIFgtcUIWPPYLhto4R8ICE807NY9yXIaF79Z5Eme6fCcJSx2y4tuU2iugoBa1+iNTzG5BcT3rnsi7TPqrqYbMsr8Cps/4NuCXBpJ/wWSrpjF8EaVvH8aOP7Y4JcGL46wY75Q/1XfLLBFJ9txv0KLtCvwaGyCmVYULiZVDVUsOaQR1lS0KiMSMKZfEFcW3yuw5zu8slge8KDyF4nSaCXZoiJZidXjFTLrFNjI49nj4/7A9SalSK9RYUz4VBIG9zx2R9pTwmgi/KAn1D4rX2RNgD7jfPm8PzWq7WR5lMiSSDHOkobS48fVomIZDwnMGUHR4vvgWuFXSH7vI9dRQMGK6R4Gf0BFJfl1x3e/UXx31/Pzy5wmeCI4lXyZWN75MrTJ6Ks9Q7Ph+uuETXTLYSpJRpEPdfhZj6cSfAFD4lhnEWuvppckBduSi8UhFgtJTmSSJZLHLIyBgW5IyH1FkQlUZmLeb0n0Eacl53jD5a8SQmd4K5qlxzXN8cT+12eCVbvkygpk6HL7hvSyXr5MAio+zgPxakekjsynnDBKlgmk9hP0OSBULdcmx8vD5f51s2XuQjpvxoUe3hjgDSM2bFA2k/wYCUNFi93B6xfFhe5DpvFMMyka74hvX5EMdzjdLfFJsykY8oY5XpGJ5OG5nuu5/r3Vs1rhuZ7ruf59lvmd4felRxz3nIavuMxHjnXPXhaHx5GnPzQMP3nFnD7x2P+M2YhKYI2uz0js/TbzUFOB9jueBoWqR/JS0fset+qIJwrmUVINQlTTs3qyPIptwrbYXECMNV4nnLUTW7HBHiTzekXv9gzhj5A9cdH+lHpyJGHBw3BPpnOe4kfmxy/x0o6NB28/NhxczeeSjuYk7n6g93t8SSEYJrIgx0kL4SlqdY85+XTiE9ANUR9yb48Lyf9yTHG+xNw3IlHgy0PGQV0Qy1JOQH0DXPoejRYQ25pDEvLx3Y9c2X/MfTrwF1XEl3XGb/MA7+4j8dVP8bpH0g9burDlNn1YFkZzMzC9seh9y3W+W2DvJ3smf/RhM5KmEM9w38F37zK87sSmvOPUhcyuZ7dKSLcXNK4heO3xZrasYocTRXhmeRf2lL+d2UnT+uoH3nm/4tv2kWuzo8tqbPbE73+9wq5e8pTf8fohoz6GmH8A3fHAq6eXHPv7RQktG/Mg2dAcp8U64scpWMXheM9gDFEUcZNlDGIdxl9AnV0+Um7Dxe5+rjuGusWbL3BPIUk5LAvIyoI5vkOJ0qJIeDNowvAz+p1le95wWz6gBsOhD/ns4JHtfokNZ+piZnO8ZNSK4s2RaE4pP+8I38q5eCQqz+CuuJwN3n7khyrjzs5ceQ98fuXzDjhXjnUQMK3Esg4useTCeJs0bTtiaEhXMd78AntOeVQH1m5D6EQRUVKqistfXXE4ixVmJBu+JNqJ3DdeFMiRL4qRhM9XGdM0IRtHF2ToKGQWkKeemR2oSQYGPlogenIkl02ooAxMjOwdfD2z9gd+8mbL+cFyu3/EHX6DlzrOexF+N4xGOBcDyqx58bnPz3/+gn/8Vy85NAeejo+L3f6xfqCcU05uoohLknDD+7c//gmVCckFu4uejmuq90e8LKWzIdo+Lo27JAE4PS00/iAusT20taIZe8JyJPZhNgKPkAbQJ67jhdR6VP6SzABHZlEM6IRgDEnFZqAnHvdPOJdQBHYhWWpvy6h6En+HygTwN/DP/8WPqOOwNKvSmM5KokSWZA1eXm0wXk+YB/jGUuQDVa1wuQS5OKKT4baC7uwxjAHWFqSlJf9sYpat+VkxTxN9rxk6cJVBRwqXSfrC9bKN1u2Z0HTY+UTvErJdzvU6Ib+JcbEAGcdF+q6yhO1qYG4L3g4+unkg3hSLnUO4D57A/JJXbF6H7HTFk97grMIEbvF1CdVlFfkYf2aSa9nFi999sjP9dCYLI9wM1XRcoi2jSDQKM1ZkUNEVSflqiQ9Mx4w0jjnMDl9SMXzpqXs8rXDFBrP/HbqXXNccLbIxwTbKoKDxOU2xPAILPGfof0SXN0zFibCLadSI7zqmYU1lfIqwRgQnq3SzeI56gSmuhUshDFJhbFSYk9Bz1xgZBFUzzTgtD1wYhASjwxqZyo1YuT5eRn134HfdiTw/UAciz7d89cWKaPPAv9w79LuO65s1J2/i5UqRPVyjw7dUjccYG4JBUwYC3JHpuDyIM1Onl6hMN4s9x+Jkil3mzPWAPZ/QqSUWBckgn/0EUczcCnn4zNRYwdkSlxbTJUxbh63m5XMwq5Dw5QvG8y2536DmiUBp0s8dr3/6jxl/+ANPPewf9+wTeBGvWEnkpZ3oHzRxGS1qET8ecVaYEgPIF5eVl3C5wHjEEmNlwu6PtN6MvNq0AIFUhPKaJebUGX+RoEmug9/JQMxx8jJmUZ0ERwLbUc4ao3IS/QJf14zzQLUKqMWHJYqg53qu5/p3pkr4X/t7n5UKz/Vcz/XvsoJAsUv+hsj8Fbz8LVH3iscx5kcz8efriP/sS012OXB+m/Cd+ZGfeif84ZIqcfRJw7FXhFlJ4QdM7UQXCGtNbMcS7+5jTURfT0RJTRIqAlvQqhZxiGuxFHeaatREX7eYo0+47nmtc65e/yWH84H/fqz4SVzwdn7g28NbmtVHsvnPKD4MaCfn8xmVG6LgI99NHatJQOgBQzRQzOmStGaUxMJbjlFFoCM+V19Qdmce9pbHVDGm8wKz0yrG38wo49GkLaOtiA6acHL0peYh9bgcNKnyubXfko0hD8Ud/eln6Jue6LDij94j0VwS/qKmGG7w0t+QuM859fe4XvHL7Qt+GA6oypJ/iGFeoYqMPug4Zh4PaL6+nLhKSw4fU7qqpUgazOywbc7VNiFYrwkuQ+rQMP3Bp3qccZ8fyaLVAnaXOMfN3cwhariMNssm/eHqkfybHZ9fSPpBzeMfvyTLSnj5B+KnNT4J1z8JSbo/52yfiJTHarvl7umAWZkl3SPcWrJ5t1zTcZyZ2jVOGAnhSNbHeE4Yc2dcH4o8mXPa0TifwKwIRFGeHDGTKM+DZePebRva25jv7j2Kn3zgr92LxaKbK4/H7sRxPmIe3izww0FiLcuI1Wz54f6CfQiuO3Ed9DxMjl/VJedUohtlSywb+6elTxvWirKuFrt44mfgR+xsgW63lOnA9noiNuCGgCFQ+LPw2RREwpfzyVLLZlvi9QFRoDDCIhA7R3jiVD9Sn15RXgsA9IQzhjBZEWUxd/vvuQzWUGr2D0fC7IrgRUuuxdIhkHqFM7IT9AgDUc8IP0GW2grrzWhZgsr5fZ7x447theaXP8kZ//UPnL9tUTcB95yWJMZM+BCeptxe8bOVJo1y7h7f81TVhJJSEflEXsCPTy1+v+HzzyMC7WEWq8WfaJgwfexoVjOTSFGmivDUL/6cMEoZKHHlQN9vaA4d/vFAHISoMMPLo+ViJNqj6mr6Zsb3YmZ/otYGNwXESUxceBQp5MWJeFOyEgm9a3n4kDO3AcfsjGoV2zTCRgnlxid3Az9+mPjh8ESeXCyebzvfEpyvGaN79EagGo7NRcR58JctbX2vYFfLqpy0M5hJcR4fF7+USELcyie7mVmtU/w44Xh7oH1f0x0yVFegJVLv8czcS3RJwOzuCEMhZUiawcXSpJZBwuVFKYgZTGgpTChjC4JrGScF0PqUfM/84opk2qCGllb5C8TmrCsqoUMklvXoWEc7HvyHBcQ4Txk3mSJezTxWHqcfzdL8Mk9MncfYQm9mAj/BmgHmI4m3Xai1cz7hpQa9CUkjiU0ZFgnW4dwwuYhMZcQq5TTumd2GURrPMFl89WKaN33LVClIUlYXMiZ8iT9PcBQZ1cTcDwuIMtA78kSyaDvUU0EbnSE+LSkYoT+SBwGj2AfMuMSeDENAe9gzTQqVrBh0h6lPkhlJUMSLdSPy5wVwgzWcPvi0zUikW1xZMGY5X+uIF9c/4fLpB777sKfw1pSf3ZG7l1xse94+FUSiLMgrTGDEQMQ8NCjfcuUJ3RaeOoNLQsKxpqpb5jljnnO6eVwSEzKdkJUeTS+cjBpv7JcI0UhSJLbXxNGasz6g+omsvGDUA148Mth7qko4CBBcPpG/vObFCq4v4K1LMR8U7aEiDrbYGA6uJ9czU+CoXU6eHBicDBO2aElZSDakUcsc/YBFhk2rxf/lTTWxxNfIvSa3fShivRA9x4TKYjE4CYjRKVp+B79m9CZUrAm5ZuQdbRgxdHuK0KObFcWsmas9T838dz2HPNdzPdefsJ6HCs/1XM/177R+Zvji7q/5Q+jhqq/4MH3DfHrJZ5cDzbhm9bNL9uEDx99e821Tsf35gW3xCjVOjEPAebogmAdMMGHWjk7Oj2NAMNXYTkDm8wKfU6QoMtROoHsQvou5n1uSVBSgBzhsIJTl1Yw1NY/d3zI2ij+bfo7L4a92v+D24Y5V/5L7pmfdzbjVO5LW53hVsQ4vOb0v+bCpiHmkC5644hVZXDI5AdopXvQXC6Oq81rSbcg69TjVIW0v6toOd1FT+yMc10y+5UWdLQOPehRZfclrG3O6MajbhLh+gQkntvdban9Flf6Gdt9hX5659jasW3FyOMyPOdN6Yrd+xbf2nnwceR1tOXpnnoZ76r4lTg21f8uujZltTH+nefBrDnNDHles0oaaDHtKlp9/9VLhr3yKtxn9usPLDoiwWnqUt+MjnV9T9BEnb+Y0K8r5ip+EB6ZJrK0V9scM+1LxT+7OjOMLtjc5a4nWdD7Ozph5WBZ/o3FcHnfcl48Y/y3W7FBqha0qqlPFZnPFvTW8O1W86CfiWC2DovokwHuxVuSEKRQvT2z7iHl3Qfgwc3YjY2p4jAq2yQdehSPrOmfcOIJp6VLwxfZRjwTFijIYsdIPfLzkvvuWIO0kBJT8lPNDmuHbnrWAEQvLOF4yvg2pryXKtCVQileFdOkpZhhpXUfkRl5sBHQo6l+ovZSq9WnHijSelp7p3HgcDzJQ+cAGRbLa4ecHKkJuDx1B9lKEK+jwDG20qAl0kZKEGf9T/Df8tPxz+vGJ89N7jO4Y+5zEb/H8kNNRrBSaLM3wtCGSdD1JExHFNQ5v0NhZFAty7g8Z9ZooGLm5CXh//RPu/vAd6dOI0iV7TxHMmnir+NWqZLe6omr3HLqeQ7vjprxbFBCB9K0u4mYrC+oLAhVSXkqqwZ9omNDWhjbz6R8PBGOGSg12vmSoU7qoJm3uYcwIohnP+agwwnNHhnOAlwkUZI0xOdaKN0RaG8OqSLm6WOMXPrPECh6PzOeS8uIFu83MMG7QXr+AD1cy4aFY/ECbsCDNCuY+4Zv694RVicsH7NjhBFKXnXGuh+hzark6Tz1dG7JOInT2ESeyEhNR12vG+wfaLsHrBnLPw2QxURkzd5JN2JHEWtwWjHPFGDrM9hMsUOmeuK/xwnDxCRnbYdyadOfz5s9u2O5WnENFtj+RBBnG10w0JF68TANXLzcEkULPjsf7mas4YQhSNv2Z5l5iPWT/31J6mjwo6b/q0WPKYTYSTrL8ntq/Wx74VR5jIk23N4yzx2hEIaKZ5jXjIJOgmsvdQD/1/CTe4a7OfJjfcmxy7GDwsgnlRYzhzE0fUOUZ0/3TEvUSSmrF8Eiv3ALDTEyPlYc+qOnPiuko0YM+owxmAplrVByriadOcnZPZKuRtV/iC+gh+DSkGGvDYATNKBGIR9o2wOoY1R7wgwIx6kvCwdhNmPiRuAyWv99K5Kg3YucnPL3FnEaeQp/9fkRtHvnzNzH//e0Nf/ubI3++jbj1A9rqxJCmqDhA9wbTrBdlh54DXKpQG1CVDEMkx9hnGkL6WLb9HrFs7ueA6jxRuRFPRzgU1pUykvwkSRLAyucynbzDq2r8Laz0mtoljGqk/07kTD3Dx5FTm5B81SxQl3/zbUPhJrafxxzOXxL5b3lXKXbkhN7EFO/xkxs88WSJ7CtyJKmlJ2WYAqIeOuVwQbdwM0Z5yQwCr5T4mjWJ9Yj9mkkmkmOIlfvBRViRoZUDiedj9Q2Je8DrNaOSCKRPE9DHaQXeExUTZ/WGOBCfynM913P9h1bPQ4Xneq7n+ndRPx1zvr848PLDT3nreazvv2Z+2TOdRvb+yGcGPrQtVRNxbfaY1Cx24svzDZ13T9U16HOIWg3iISB57zGHlvOm5TTVbONLUr2DNsXoltUxZ6gHTpeS3iYy7YRVcMH06j3RY8HbVHFxgsd3Af7FI1sbMScJsZq5Wm8wyTvGxnD3Jbw8Kk6h4+J+y5haXjRHTtVL/rb7gb8yX+CXEW3SLs2hqH3NokKNlmS0YfIoYkmx0IzjhGdn/Ea2544pMhRPell6eb7GxtLn9ERtyk+55mN9Sz3GfLZbk3opr38Z8+68JQstN+cv+L/uFX/1ueHHtibWK5q2ZxPDxU3B+hzzob1DTYbKDHx8uOeN9smGLcFseL2ZOPQp9UGg+A4nkvggIP98vcQWRkFA4TwOp4k57Ai6mUFltLHiw/EBNzi8s8Syx9z0OX0yUJZ7Lo+ab4rf8KF/w03xgXf5Z2TbjEu9IooSApcwDE8E0YrV6oqmP+DJPvWrgNe8xFdf8C+m7zndfc/lg5ybfW6HW2o1M7iS78uBN1mHL8tJ3ZIllhhHLpywwbHPDvjhliBLcSZa0hGu7n2Cq5Jku+L8t0/8zdsTn2UPXK5/xmglJ+RrLrbvl6GV13nc+5IUcok2bwkO/4DD5kfSi46i2y0MveHGcf2gGF806LW/LPySoeakEi78mUKU20qsxT1KrCqjRs/eAi4fwkeq6C1jtGErdgHbk2Uto18QBA7f00TeK15dHHnbaz7cnfh6A6WZ8R5rxq8kNjLGzo5/0P81bdAQ2DV1/5GLizeLdX1qCsLd0wLSl9RDgX/6c8Tk+UgWiqgQnCxGXbokzTlrCUVqgvR9MUGs+Ie/DAnimW/f/khY+RTK59X1xEV2Q6yzJa1POCFf7G6I1TsS73IJMJAe69o9UHc+w+3vl9jJV6+++tMNE1zdUQrHQAVMpWP0J4JQ8i9P5LrHBpdL9mkmIBP5Wwef2R/o6oEsTImF7hneYUe9wAStxEkmHuY6ZF1kqD08zpoTd4TtTNq8WRq5XB9ppw7rvkCtFF5bESSGpC/4Q/tbvv1BoVcerq4w04w2l7SbPZ9J1MY6YHLSRDf48lIwKW6+Ij3GzA9PnI73PB5FXiN6H4mltIsERKmEzljUeUTJC0SXmGQkCmZS9/+ydDgClS7+pdk7E/YZavOKX/3jV/xf/vO/4N8OD4y/PtN6ATvxysQTbj3SzjE324gp/Qx7f8cQeayuf07ON3QqoTeGc7pZNt/nYaSyI95G8RevMjK1ww9n3j82PO4HZj8BiacxGXE0kbycGFuJJTxxGhStxJCI2aiWNARvmdLO1rKr9rRjRvN4REc+asxxYUTp+ZAGhKczVej9z1L5I/25w3cycyuJzJ65v2AaHrGVSJQUc1Chd0JhneiOZ2p54IYCK1NLu6WyM4lt6TqBmki4p0+YTwy9xnOXpL7EA9VYiT6ZbpnGCddmqFUJxmP4oUaJzC0UfkOArxXatEtW72Ff834OufzVC7avQn45KP7ZNz/y8H1FflWyf/+A6XtcuMb2Z6pzTb29pIgF6lNhbEIeWKoox4yGUSRFumKXnrm8fo0bJ+5ue45NiC8ZJdO4RMSolxP6rLBzxOPHgTBJUXOB7zxOYUv7JEkb52XYpPOQMAuYb82SA7uSWKXaUccRelpxtZFcX8OwKehua+qwpwgtobzIbE4gBFjXMXo3jO1xmR5q/5IhBGMbkqlcIj9liq4pYLb080Q2lxgbY8Y7YiVKjNXCn+jniCx8xI8zsiChj0ISVxKPLZX/ivP0z4nHPyMdb6nMB3bxzd/1HPJcz/UfTf3/y+Lw/82/89kG8VzP9Vx/ysrDkB8vzlj9katx4uM64OrkYctkiQQMlcbr/oJs/RvCpy/5/P4F2ZuZt55lLldcSHrDe8N+6iBqoRRf+cyNDRnSa3yrCfqAw+UdXdwRPf6U4yngxjxRXTnUeaDVBVd3KZX5yOpQEGxzvihhy885nE/85vWPlOd7Pk/+kr8JO37RrfHelwsI22ueeB/FrC1ElxmxeeJ8p3lffSBIPeIuXfhqlSwOfdloW1RQfUqOaC+4lpSCYOJd5xjUwBfJ1cIY++gfmUdZFh4WBWslnDhhVvGRLIu5d4/8TXHgn7p/zOwm7qqRfA7RZUF+95EP4ZFd/QWTusdvV3yvT7zYrbCz4cJtacN2Wc7l0Y5Ep0Rac1ANmyjhRa559zRRypJRrRkmkbp7RDc+7tRy91Qz+NHCBxhFSX53yV0Ssi4PhLcR/YuEXe6zWnoSn9/H3/P5+x2hp/giDvngZ3x9GZL1a7zZox3OXOUrIbBT9yd07JMI10ErBtfjDhH/4/jP+MO+QNUeT949Tl9DsCfySty6JlHTwkWr+k+gyxebHUpP3B87xnHDrC8JT2vC4Y7XO5/HU4e/3hKrYEnVkL5SztBTmNGOI2EoPVu1SPXzhwvuXtckHzuK5GuqIsOXXgXHzZiwKkOCoOCzIaVpPvBe+3h2IvL1oqRXkpIRGGoMvpbWyZEpyzbJ5NBN4FmuKEnNL/AHuT8atOexKTVTnBLIQnqeMG7GNx3xyZKEEUbYeWJLuDd054qmr1mlO67XL3mbPfKluiHfbJeIyP544rxPlwFWsUuZ3QklVmMVYe20DAxEkeG5CF+WhKJQEBSBdthA4SYBtUOxsfzD9AXBXPK3v/6ezy4DbnZrpt7j6bHi6oWkQiQMpiWJxRptmM1MQsBJltXKIziUDNc9f3j3mz/dMCEsHY/jRGp/Sr75QNhvUOI7aRrmJ8W8fkLrF4R5ju0T4jAk7C2tPxCpiXju8MJLnJjJ64rkMmW93XCTG9LgzMGXDbLAHGdOTwNRdGAbtKxeXzGfYvLigJpXePmacjszeiPT44bj7TcQ7zBdDW2JKYYl/1W/TGlFFpV7FNOOaVT0Qqi3Nfs7xen9HbHALLwNSXPABCE2sMyhoVEea7mo7rD87sNcMg0GIwkAscYPEkLrLekE0/TEPBgIUvLrgV/82Qve/OwVF/0l32bf8y9+f88f6jM3Z0fWF5TbiTnJyduBU6bFlsMXyYHRSvOtqJuR4/k9h6eYjTa8vF4RJiFvUo3d5ctEanucmFzFyTM08cQUnkhWGbtyJ4xEivWK46GhPg2cQ0MfDAx7Q+catEl4eMiYsrdkYcLan1nJjZ+U2DEkTBxJsWXVP5Cc3lMXHZEqGYzH2TuRX2riY8PDh5Gq9Ci6EpPtyRPDOKR0a0MyCTixYwwD2vYtY/9ikQLJ9CxIZHAzEw0eF3FEdzPyWMVw0ozNHiPPCgkulW36+2WjHicJVjm8JFgAPX3bocMVOn1NdLqjvnnBq8mi/JBXP3/kVyalqgv+qP9A0HyB4neoYYb1Cnd2tMeY1fVMNWR0DxGXuSaJW5p2XFIxpmNI5QzXNx2rbcHkr9CtYew6mr4j0OIaS5gklkViFPaOJj0zuDPriww3BrhplPhWsmBclARa0hR0xfB9zV0e88svOwYihlqMKhKns17ifVyeM3szFYrcijrmjJ+I52+EWT7nmGromMwez9/hpmFp+P12Qx6viTyYBYqqBoyAgnS6+L+Ui5YXnHYloa4IihcUbcnoKnynsL1P8nLN421FMLxmVO+w+Q1q/w4l0sLneq7n+ntTz4qF53qu5/pT1ji3XNxdcMdnOPcbisBRei+4Cz8uC6Dj3kPI4V56hT7XHPqMYobPQ0MQJpzjimqdQXK1NGucHGFiaD7vGNzEqs+Y0oqi1gubLI4OXMYdJkpIHyOG1YR9fc9TBWm9pjV3hPMR+9kr3AfN7vUa92iZuozfffYDP/3jFac5JU57zHkkSEpKe8GR3xNPMw2GYFNwnAYOfc0usvSepohKZptw9j4SkaD8hjB3ZKZkzgcmveapahabt/JSkjHh0ffxryRCMuO+aPjl00DvzXSbHtcpbt4X/LPVd7w+G7ZdShJbvs9/5OYqwn+75t25YfuqJyk0bzeOY9Py6qRIVcCmuOT+/MDplePu9ntupoTo54qDec8Qpzy+2bB+lJjNYWFm+Scfr3dY3y1DErGTvD+eidueaCPnwSN3Sc/u0vAqS0n9mF4HpFPI9vb/yd6f/UqWpdmd2O/sM48239nH8IjIOSuzKmtgqYWmmoBE6KEf+p+UXgTpQQIItYBusckqVlXOGZGRMfh4/Q42m5152Ps09nE20BBIVRWZlIrF+yUigHQPv37N7Jjd86291m8tyNOCc/Ocwqj53179CbE9pzQKttsdia2d2BKl3eGdpGn09zym0od7Ujf8ZfT3MNsf2DQ9b+a66WzNpA15HApOlopM7zmxZBbqxj/JrtkytT3mkYNat3SZwpgucaXNtu6H9oeg31P0KV+Iko/NBakz4sLV7uoV2CcUWchejvjRk5q7+Qq6f4q3uGF2OOflyZbxZwZvz4+c9RGPL/QpnMFBs/SaBCcMsChQnWAlCvy+Z+r6XI9KujuLSRHTJQxijGtYJMLG0gu9q4bUuiGgrCsCIQjiEcd0T37sBq5Zdrxn8uiU23yN3xgcTy9wu5b1seTMfcVdWvHpxRWu7VH2R5TSLuOKqskZtad0cUXYalAo2pqPfsYM3IGboOMPhi2x6ZGNTSP7wW1ioNlv+kTBx/QFz543eOEVQjg0mcH95o7aXnLMevpIDXGYwJtQ5tuhXtTC5jK+YH3oiZ6lOG1M+2vNNfw9iQn7w5bQe4ycvKRfKWrR44YN0m9IpcCRejExEF1FLFO0voGQg22oGAz+kO8FdlnhzAS4x6EKY7MN2Ds1pQqQrUJVDeusY3d/y+WzkO+FOedGN9TdYQnsE4EdnbFO7/jd8jV5VRN177FdbRs5cDQljpnRlSEXVw1JELBpp8jDFk8DBw8ht69aitQgelpxKLTdqaYpIbwaMx+ZmK6gMkcURU59PJJXOSJ0MOtndLqxodwPi3dvtahaW3M8unHD5bf/gJ/MZ3RNj7AdPj17wrk147cXK379zT33G4Pd+4yR3eNHC9y5wkjDgfxf6dhEsyAMTJ7t37I7trSRSZD0w9+dB9A1NyyXsC8zurHOAVmMmhgRB5h2R9vpU/WE6WXA9NIl3eTM3zes9gH3xZZSpWT5hvZ4g5y4eJNznJGkkDWmVHjVCtdKqA/3g4ug1Bm2lyZNGFA3R9zdAVv4rOyIPLQ4cU0KHTtoJoR+htkcWOs8T+0hxZ4iKzFKHyfaUTka5GgT1Cmu4ZAJh+MuH0Akh7ajyCS97pTVCplW9rbvsUJr+EdXsMgup+x9/GKECHPKaYO9vsHyQ2ane9bSgsrBiRRnZz3LrcXxbozV1QT2c+Q0pS8yZB9SaU7EVOeQBLuiBl+3bnS87WqM1MZtY/KiZLktQUTYfcLUremERZdG5BsL36shqHRvIoHUNZAC27rSlFE8WSGnAjeYcNZLDt2RKl1wKCWt2BC0pxxamPonRLOc4ysbso73hiLQNRWdyciLh+hBNESGcpp2ht1kKNERuGPMxKBrDpi1jWONkZaHbHoqq0D3mZhCZ9AqXB2x6E2kbkIxdhhmQ2b3GGaI76TU4g6HGZmTs07H+LaLb3rcrcEZt4zPI4Tu23mYh3mY/+zmQVR4mId5mN/H6EO2qTMlZDXwmH6+3GAlJnkeMR/9JXf5T5gGmwHg9rlrkeiFPWsQno1lmUSmwzvdBPFaN55JuHRp8inJsefcSVGNoJyW+LLh5vYj3l8qZrqaurSwsgniZMVT9Yy+r9ld7bGXp7Qftzx9PeWntzdcxilu9BELnTfvbax8i7XQp7Y2TdhxLFOM3Qw50WwvQWhFSEtSbeFX3PPx6YQnpm7l0q1oOqadaPgUjo596ix5oIZsumnt6ZQaIHXTMOPMdylUjpP5w4n+YlVyE9Sc5Odk2YGxYdGEDslG8nl2zSf9OU4guCw/ofnxHf/D/6lhfLol92IeWZecUfHWecfNesJJAJvJb7DmIx7VCarw0E3dyVqxOl7Ruy7fmxk0kyN/805SpTnnfkcUgxPoOLTmgJk862d0nknstyi74C4dcZzBTJncyyNl2qFqg7CYkE4ynoiQ8WTBbHpFUaXo9TmZ6MY3a9ghnCjB0F9bmUjNTmglN6+2uFVHZucDfyv5sc/ocMVqu6PWjgKlX8yKeRsM8HP9HBzHK/KspLo+B98giBpsy0DWHpVqmRiCJJvx3reIDiXfXz/nVye/IVjaIK4obRirivOTCS/MG6LxmOfHj0i9b6gyzS+AyR9fUlobxhrgvpd8ef2es9Bhf+aSVBmqddjuzMF50SqBEZfkZcVJblF7HdHYplEMe2BqCdJeIjKBqQ/GQ4nvJ4Suw6Fq2aze4eiGD90O55q0c4fEMki3DuN+hh3d47VjYjtHtjb9SvJXye94FIw4D05YHm7JN3r3cdj3IWNdQd87tJq55+lYvDXEXgZtwdQGkR6j0x0I+ld01WAP0sZoexoNZrcdYu06Gdescxv3dUMUN9R5T7eR3OpD46BlGpxxVA1975EpvT9vmV9pN8aUl9zw5GOdl/89iQkGFzr6TXXwMasW+9wahIKKiNDaoApN5H9HttW5kjG92QzUy07XKhx0/uiI1VpMrlySc5+i1pUTIbZZUWQZ487Edlzu3QVS204cQdSZZBh4Xk3WuLhBzWL0Hc775/zN9efc7BqCboQrVxTmhBaFd3iLIXz6q4TqaHIhBMt+ycVJyW4tGS0Mkm3JL/xP8JtrnFbSiQidRm/tHUf9oSe13Uax27l4xiMmZw1lfeSwOWIqnUMZ0/YSo5DYdUI97/GejHnx8YRZPKY3WozKHF7t0VnMnzxO+OHlc+7eveFfLQPeL2+JVp/j52MmYUdx7uCrEbZd4iaKvD9jMWvIHBNnFDDWS31mss6g2a9xtVihbEwdD/Es5pOY2HFJ64pDY5Dp2gmpXTEJ3smRs1gRVaOh0UAqi/erHH8d4RoraDrciSaDusg0xyk23G1LZBYxnS6GCy9StxxtB8v5CFVuKc032LaNWQoOQcvcCshbuD2UHNsex3EGroSu1rGsCLsQGGJD11SUfQg639NqmIlJVebITLdoVAgKzFqDDxV9OKIPWq1HYc08zLof4J86VmL0E6zsBuQZVtDDYUuWBlzXDuefPMHt/wJnOedQrLFtE6mX9r6nKqZYzpqud7g/jpj2HXbr0pQGunumWtsUVoE/CQaibFtUNNstUk0ohXYkZEP0A7vCqAPc3oVTgWFmjMuY0jbpWkUfjEg8T1d/MPVgan3MtaqxR3Bwv4PR1LTtE/poR3EIkPKIMauZdjsqryOpfaQwiAwQlouy6oExkjo1TRNwarRUhxGrsmPk9lhBg+wOyDJAKWNocHBNe1BdRafoRImwp5jFbPih5+peh/uGv0g9jl3FT840BynE8U121RarP7I4uaRPDpSHOYXxAGB8mIf5hxpx+LvMg6jwMA/zMP8xoysTtQlXd9WbmwU/8cdYYcfTkRYa/iu8Y02+3ZO96LhUM0xymqONNDOkdCjOLLRbPHjqYJQOR81+Oi1ZeD2ydwZ7flw+obI7Hn+k8Jx6qOu2TcXhtOC1U2GsSixRMdtWxN4n3Kx2/Ou791wFPWkS0G5vCd2IV7uv+eHFnw8HVWHlcyfuOWsSjrMVpu1THkAG+mtb9KMt1X7G1+FLEt/EKR0i7eC0fJq+HO7BbA3tUxLP9vDcCzwNt26/5qBytk2CTEzeT2652ifM6p6ynwx29xfdhNJUvN69ZGZr+LbPmz7kvMm57nJkrng6bpiW5zRtR642ZJOvCJfPuVkcCdoY9a7E864oZU72XcVYCqxurpcxEueILWIMamZGyrte8vJ4oPM6HvsXPOts7tOer7IMO3rH4+4puTumUxbmfcPebFg/WsPLGNoDp08CXiTPGJsTgmBKnh9Y5kvOolO2yW+5TH+E5QakFDxKrlBS8Xn+Odmy5LV55Nk8pskCkkcjXpg5fW/zW310LzLObH3o1bMtSvqsZtp7nPouKRVlvBuc4kkXD00Wnd2QRxXfBAZek7De7XFPz0hch++k59w8d+h+Z3FxHg4HzZPpvQ4ysD+0TOKYSWhTb1d0jyP+5O4F/9ftK37w6DGVmbGr7xnHL3Crmp9W1zwWM5xgwWr0Ff3LM6zUp51VhLZNMW24LXv8nYmhnb2mT+zpvbdBavhhD0t1iy1SVJEMEXBchTvV54MNZTfB6ww+vbSHQ+Pj7RYjiol0TMNrOJ1qIaMl29+zn4V8dRuwKEfIzEIte2hnNFN9smfhyBnS0Dt1g6l6hD58NwclYWi20FWTOuKsRYXetDH0wbdeBM2E0HYx9YH0TDejKNyjza4yWW5iTo03vK9f46gZ7jYkm7zianZKtbznm9drgrDh2R/++e9PTPBcbcu+wzN+iHnV44UNUR/TT99AOaU73WPeL0jVjoOxxW710ren3ul6EQYipAb0tTLBzU8Y+RVVnVPvJLJtWBoGoX8kHKXg+HgsCAdGgj1ckCpViLpn+rRkKd+Q2wX2ymb2UU2js+s3Ja3hINUI5onuh6TqU75ezvBkjTr/NtOp5FRbr17ccP2rezb7I+cLG/dosesVkzbC9wS1adPfVowa+P6nl3z/04SXu7f89Jcrjqt2qP2zO59eFybka12gy7c+/T7/9GJM7/bUUi/LJa2jT8bbYbEOZoJPTr7H0zTn528jfvPqJdkXJoe1yXlzRAZaGPCgFYPVKXBCLLNhbpsDdHGzuiPbJPRocGNJFNoIT9fqOHha+exaAtfGjnLqyqIoNAl0T1p3KNPEdSY4rkEoFZMm4LZweFXX7PYGUdGwSF9zODiE3oRcHbDbit5dgecjgsck5S1OVKGOc9TOw1BbKsMjEDvC3iQtA46ti9ztqKMO0YaY4Xa4mHUTRan7J4fYSIM5OsOb5LS7hiK1aeyt/lEFwTmtscbqR5jNCFEVlHWOY1ba0INjuPSjlirTCmiMYzn0reDlrmT/u4z2xOck+xWL5GNeJlva9YLe2iK3Nc3Zlsg9Z6dbFrIeU5cAiwBLf29bh11pcjhshh802A0iMLAjrQfpD40drTY2OWMcJ8fTFSxGTdtkyNodajaVVwxWMZ226XOT6eQVVZXw68kZM+10qXIefRqw0Ap3JPGj17Qbj+Jmix8HNN4ENzNxdPfvJIEi5ejmjLRtTcMnNdxTuywcXcsZ0dLieB1mEOIJj76JyXUVslnh2Bayccj0D+hQZ/cqsrKi7RWBFRDquFApB2ZG0s246WvM5x0XpklmjPA8m7LPsHRjiXY0WLpt92Ee5mH+Q+Z/4Rf8QxAaHkSFh3mYh/kPGes2xz3xuK117PmGwjIGN4HwZuyPOz4pPdKxS7UZaZQXwpvQ6UX9Rp9wKvyjDoea9HHFob/F2ZlYa4ut79B5I8ZmzqnfIqc1qUjx9idsbR3jPHBVnxIfQ26cdwTqbGC3lcEG633L9PI11uEF1b6j2/vcTyQjt8Y3Arz67XAq7XoTjsuU1tKMLH2iHCL0wZFupmjGTIKGUTmm3mVYjY/0HQq/phmXGPYYp/IHC7h2LSgaeg8+Of8RP737jG+qJS/UCc93pxiBoBsJbsSeMBO0VcnCnOK5U9ZNxeFjl8d/GSHOO+T6ntO94tfjjE/mz3kn3/LeX/Kj8o/5ulryh9EjPrdecT1v+MH9mqbZ0757wvRFxZtkQ9Xs4X5PWyb4/gkvHj0m9Cq+Wu5JsyX1KiXX7WnVkfq+Y3qtGzcCRjLCEkdWomWvY63pGdv+LU9nMefhnGk8pbK/pG0ihGEOQoIQFlf5D8nKPUk4Z6wP9TB5efc599t7ii6hODlyf5iwuzsQliU3J1OEUliVQ6ABkXoZVx5T3YIXBpiOwq8iYnvG2t2zOeqDXZsgLIizAPcYMRpnUFY8rgJMva+sNhzHLpcvx1jzDabwmRsLtqak2qVYnkHcBrw/3mF4EbvPV/yfV18xkNY7cG2X3cwlSmtubypOrHOMTuH5OafpnMg1mM5nbM0D79OKoJqw0K5vo0Mdz2kOOZv4hkbo/fLDzmMZ/uAaOTdcXk8kd8nPmR6+i6rhaidYTltGHaRdxSqZ8Admw5tqQpatcY07pHnJyFsz11Gg8CXzixmHVYVhb4iSELs6QdRQ2p1+92CiQeo1wmwxWw9EOVATpOwGoL9h9wNkUrQOstetbhK3/1AnuY867Cbi/DzAkmvm3+hWvSuE6yJUTy62+KMLbsIVxiHl9ariJycj8jr72z8f/q4fJKJaMPYC8q5Epbpe7pr80ZiyOMH3LI5HGyNvCEYxMi8pDHNQFa1xSKVcVH2DoeMKecjGvMNSBq3r0YUhhobirXa8VwaLk1MCb8zOysheH3BGKXXRD0/W5ewxP/v8G96ur1j97nfc5yWnjoGQMZUb0asjpnfC6UlBZHtDdWJlLQm6AD9a8snY5jfvvuJEzAmjU0o5otZLpfOOcFwziX08L6RyAuowZTFz4EXOb0cVxY3AXnrIZc0haLCMhmhtUBoeSeLyrY9a5vPTwaLulkek0vWIOapv2N61VG7Lk2SBFQv+7JPv8MOzC95+fMevX3t8/YtfYNpLppPRoKhFQUBdV4SJR14rROMShFPsRrMZfGJfdzj0VI52ARyp64b9xqXBJYosJo6FG+nXIaFqX6IvA12vWRYeu7BjNDN5Fvds82xomdhtStKmJ6jnkL6lmZ1z6twSlAm2OWF3WyAPDv1YYNo/ozUdPHVOvX5DlkWowEcaB0KnQE4sZFlQhveDzWgSJ/RWgyhMWuMjpNpS3+eIokepjrZSVHqZFRJbRphyOtjYbO9LnMAfIC61VQ5MAE8DcXRVYygw8wP2bDS0aJRvHlFY35CMcvzFCMfcYucZVnKKURkw3RKcfIxXbtkcJghH8wcM2i7DDaYclu/Jyw/ija4taoTCSedD527qNZitGn59WUvUoaKpG9pQuzk8+tohnEa4kUu52qO8emjAUO0C26upl/dswhMM+ZZSLGgcKAqXVhYE3wgm00cYMicpPSpvxb6x4HDA4kBgmYNFsA0roqqilkdUP6F1c0KrYmSGJP4Ez7aodJuEbGj6GNmZtCIfhAAnD+iER1I7tG6B4WvYpYETdDydjinbCaGVsc2XvKIYapMcPyPb7xDalqUfw/bZw93XwzzM3zJ/m1jwn1JU0F/77/N1H0SFh3mYh/n7TH/qY8lsaAaoewure4H74h678rl9HXPiX+MIi2ITUU3veaIs6qXJrpMc4opRecTZzxDNlEo9Zznb0CYbzDRFNEsafQ+lm89SCPOAbdNgcc5o7nHoJZ655zIbc9B+5WTC3e4zXF0z/yphceJSVzuePZvw/7i655/9iyvO/uyK3NryWmbMU4t1LJjPdIuBP1T7edJm39hI1aOeGHQXJ3iugbpWlHmD1yaEhxFh5A1LWeAEw+Fd05bUXU1rVIwnY1Z5hRnumFnf57ZYMWksfijHHJHcqg0n1ogwM7CTKd6XBemLO/KVYG6eIv4w5Z//RvFuuUJMA5KvZvzMvKWZr3m/6vhecMIsk0wsfXgW0XYVljHjo/WIbHfL9e2IXIsnTUU3drh8OqaPLb7au5isqeq3pMmC1vG4ftMg8jdczsf0R49RabM/kxybDd8NPubJkwmjcErgjDCq77ItViTeDFcLB0I3GmiQvY8fhOwPOzaHa356czdw1wJTITuHY7dhNwoRmnPRNRwvLb442fD8M92s4NFHKdXGQOmmu2lFWWX4R4FTmcx1E4Ot2PmCnbXHtc3hXlkvuU+fSBw3IHNrxjpi7+aoTcnZt77L0l4i6iOuY/Po5AW3+9ccOotLTwtAOc/CCe2FPSzz21nFd47PcejI4x1Br+hNF7nKsSKbNjjwvpBI0yJaJ7SuYDPZY2USy2nppj0tVyS1x9ReM+06miLizrrHWxgsmjle+ik71fGuKLhI5gPI8X1assBlYQTsRMNMXPPdJx9zu7tj22wx7StW+ZbvPv7xINjISYXK0sFpMEQYbAtl21ga/q+rIDU7QToI3aCnI9561xb2UCLwAbAgkEK743UMQiBNH9MumI9abjuPlHu+Hfa8TR7x+dst0/GRiR0xObtEdR3myubdTcknpsnr7pLLDzC734+YICe3CPOCU7tnrzaUmlLvv2B8e0+dbMA8xTTXlLWD6h3irkPYMV3tYVYKK5ig2nv6dkvaTJGdx8QpSLoMXI/oPOZg9sSLmEnUsStt2m4xfM2T04jjcUJ63CGaE/Y3O+rdhpEYUd8FpFIi7CO27YDfY4SwHls8kQHdvEauxiAT9q9sXu8PkK1wOjm0CaS2Q2dGTJ4HLJ6EQ98rmpEwtbhIzvlnJ3/EbDrmi+Id/6/ll9TJmqeRS11n3FavMWXCo29/yg+untLXObQ2stU1LQozsYbs/ecvX3F3jPhsesePThJOn7/AmsZ8EsS8uMi4fv5P+N0X3/Cz9YbPt1su6xGXerkOEkSZ4RrpoORF0kaMWzQNJCkFE2Vg5Eeu0x5ZGSRtTp6aqFFA7OcQ1FgTCJYpRb+hlBkcY2rf5sT1mJ7FcDziNS3bnc1BVqw6wXi74dVpzyQyCO++YtXZbN9P+Xa2p/nYBq0YZ4JcbQd12ZC3OOMFvuljzRzSsqC42+J4GiBo4ehCSPc9wm/I8xlH6SLbFruKsfsOU9RYysIqtQVGYTg6JnJF1jZQ3COPHf38OLgkLKUjFBNaB5p8halCbKdkFp0xOlSMqkte1SvuixXTfo0YhaT5hIvwPaZ9wc37t+wKsByDi2TQyTl6Dl3lMnXGdP6aukqx8g4jSlBxSK1yZCpJMCByOdo+whL0kfwg8EjdNqEIfQfHNBklCYe3Ow5BiuX2TD2Bef6YddtgFAciW1dBdlx90vB+2xKFI7Zyi5sqIjPB0GAbX0snDkFnQqR7ZE0c57kuhkQKh1p2WH3HAo/SsIntcyZ2yUF25E2LYSikV3Esa3wS+qSkkR2G8rA6l9zSvc73zMIK4XYIN0GVGUa1Izs0tOanHPdLwniN5XoPd10P8zD/AfPvalX4TyUq/K//rr/r134QFR7mYR7m7zLK6Pj1ZcXT9YL7/R5h3fBsa1HZNj/0tuzrcuCnNclLzjcfsatifvudkttf2LQ/9ZnOWsKTW+yzFZP6CY+aCel1TafB19YIv7Y5sTpy2+Au6nDMhqv8nt4I8Yfl6ISvMTmf7Bmbv8KzH3NT9ZzXlzT68ISAz87e8+PPE5pnp3yz/oKyNRg1HtNxyNTIqNsZZedhySN3uTEw4J54z3iuLgnvE75cvuNfvumYj3r+6ConbFzyg0fsT/DtgN6AdVJQUPI4O+HH3pwgSvjl/i1q95rto5bdUqGmNc+zZ4huxrvywMvpHT+pHVx/SX14SsbviLJLRp97HLhgZf2Mb6mnFE7AdwXU3WO6SPEq2fCJuGRv3LO8uyQJfkW0qbGbIwf7yJtI4RQW0uuZN1u80uSj0MfwC5abKfkmHBbOMWNOz0PGhk7f9+wjh6dnBlPNATMiHs/mnI4eYdkWr1dfElsj5uEpwjYpqxpV5wROQjwa01Qlf/2rt7ze/obHY8V29mOOzhc8rTrMcAqGxzO/4eV5j3t34M+rZ5gLXROasy10m6GG3R+oZENkjMicZhBxXOXQWIJ55eoQCWYcsM53w2FoIQX1IeemMPjOhXZbfIac/IhVesPIn3GkYNmuKW9/Td/G1AuJS8LEP7KxH/HU/pz3nYm58VjmtySmLq5zUZ0cfm5mpxVWf0Za9fjlgSiIKS4aSCMq18OcZFwUNp7hU7cpmXpP2ngkTkyU9IT1CTebjFTvKoeE8aOajwmYnDlDc8NGdtz1DZNiyqvTlj9SMQdVEpkmX3YZju8xrwSv7j/jNHlEH1iYUu+oBUHrE4xSDMsduHK9rnPTTXsIuobhnl4ftxu69U2LC6bmJvT0Zo1hSkSrd4mcVihsY8zpSGHXF4N7ZjJTXCwVzWqMPK9pqwxTWLzcvEI+qYnsiJPojt8utUjxexITAvcJVppRBz6mO6VejvBXa456zxAZoY41nI5Ib+WQ29bfuGp3eLq8QS9llc5x647PmLh3mbk5RpOyKStE4JJMRjxZXPDJWcjYe8vrNwuWpaQ5KsanO04WLVV6werQ4QRblJPgyA4ZSEZLi8K4o+oMLr79hPgkJnDBlKf0rSaH1jxzDdrshv7NjvfHCitxqHceqbHFuDAItRvA8jimR7JVwUx4qGnJV+lv2DsBk9MJ//THp3z3KJhO4N0rk//bb8+xkogfPXvKRXT6IfYgdO2Ngel6g+1kv66pvJCP7Iq0VLxUNnMKxFbS2AEYMY+fO1yNf8SPVinXd5/zV782+VzsieucS+cEIzzgdRb1dE9TeMOJuBu22KrnfuOzvgGqJdIrkW6HrMcIMcKUJabOevnaknTEilNkkaNLDneuhqk4OHaO48WwWlGt9tizH7FK7vHMAvc3FstHMfVaNzNsKbwj/b12S9whswphnxDYF2Smolh+wzS6QswzenLU1KJ6qyh15GXsYhjToQ9W9i6y27FtU1TvD+qagaQ1XToNUuh3CMbAUjvZsK6muNsIWh9V5eTWPSNDDrDD0t6itjXp+ZqR4dNPdrzf/w179xwrh34WacUBrDHNjSAbNyjhYASQy5Tr1ZQnTzpmFwGObWCphk3f0qYxyorA7zgNz5Ce4C77hq6JiLwIV8cLfA87CglUTRAGNCqk7fak1oEZASvVcHgb8el3Yi4+KgcBIxYxblvSpPeczM5JVM1RFDi9h9xk7O0amd1jxS6xzlrVNeq0xjOvqHwT2oJ9VxK6ugYmQQaCrXOgocVwdWQjRB0OCKFzdDa9GnNfV5hVzVXikoQ+R2vP8TonOyq2hyXe5I6Pwx8zu1pRBz1qaqA/vf38te6WwbQfY+q/8GEe5mF+b/P7FBL+fYLFP4RYxcM8zMP845iXxVecffmIo58y9gRf7zyut0dORq+wkYznCTe/Vax0BPM0J1Up9jc236ltbn70hjM1Y97PyfqavN9RHnSI8zHMUiaudiEU7NKE6NGIqbFF7AXbOidc2HTTksX9lO+Px8h+jj+BRf0t/OKO80cn3Oxe4vQC+Vcu05N4OCC5393iHC7o4pJr/572uMSrR8zSiPZos/djfNfEdZ/jJzsOmcE+DZjHa9zdiNwymVwYdHfG4ER1dTSh65h3IyAZavm0uPDIHLOXS1ZdyvjrFtwOlc35YnFg8nI8HCg+ETO+mm95tjkh73NOnXM26i1pZREaFT8efYeDp3jqRphVg2gk5gT+pNP38RGxshmHDfPwJ9yJtzRkRJnNDxaKm3xPU56wNAQv4y0/fuTzozrkr2uH+wuDsW5o+02KZ/d8+/kLrtdLzDxlVQjOTsY8XlyR2PGQ/99ne2JvSmgFA6dLn2prVsRifD7Av3+b/w3/8m86rjcHmo9TovZHlMbnnGRjOplgmRWxecf2GKDckq7rKfTBcm9SLxysxwXt9YHm/gRfGJwsdKlhR1louHuOowUJMUGOfVzpMu6mJLMOX3p89uprFOfcqI5nz/6cfbklzzXav0MIwch0+XplsLBXXB7nrIy7wdFuqTe8uY3xvJ7q7oQ786+Jxg6hOqXv3/Ns+mRg7+lItaVDwcacatuyO1ljT4+MdwHGwaUK9fNxGCoTPX9CXu+pdG2CM8b0IVQBInJx5issw+Z0ekpXNhRFg+8YODLEHbWIvGXlOYzaFOsg+PH8nK/f75jFNonv0NZ72qzHLg1k0JHrfVVH2gP7w2M19aGlwjIK6t7TQWgMJRFehdKcNW1/1lWSuvVBv6hIDBVgtQYYEmXJQVjrm5Bbd8NkHlElGb0Z8Nu7Iy8mNaeRT9JFeIunvPzqwMWFPun9PYkJdXNHZe9w21Nmh2e8FS+5r/Yk/RjRjGiMKY6h61e2iFZzA9qhk7WMwdc5GLcnsxRdqetUPCgDhBzRdC7sa/qqxwwk6+bAprRIyzUOBdk4ZinGfD/6Frv0wPVxSV9Ww1JYk9LmR4r6HnPyKeOzI+7VCV6in7O3ZMecOIyZxRmb9xvkckdfxWS+j9d2A+zQ8lqiqwgv8GmWDabl8DiIOE0mjK4sXncr/uW/Uqj0/WB/H896/slVNJDu+7OaR/M5PzgbQ6dhGRqCYdFp4STuydo9N7Kl7sakZk44tvneIsRoNSrSRNUtBC21psXaW0YvHpM8D3nxScvd21t+cSzYHa5xar1wm8PJvxHbNKJF1sbw5u/8GjfoWGc2q1JwgsEitpGDimPjaRDfVGIWUC/1TWfGKAlwwgN5oUjHFdbtBI3qKBKHUbCmz5ZII+FOmfT7LU2uz7YnrKSOJjjc5N9w9ewHzO0jzllD9eaIV48pvZr0pUGeaYhkDZ7+EOk57GsMvdyHLqalIZYCoXkbjW5pkB/iAl6JYoPQVihXYkRz1P5A128HAmybu9hdjjuykPkZstZVLg5hLLF6d2hoaJpLunWEiNdEmgibmgNZtm09XpkVwVIS+hdYaYmR3+FEDUU+w6o2JLGPby4xVMLGjWi2NbLQp/oZ0oip82f0+R7XATGOhjezJxJMX3+46LoWH8e/xcxd3q4rVu2RM/sKh5KbNMCPGXp2DcNkLF3K1xveCY/55SW77efYXBB6X1EYDr2zQbQttb2glEf6cobjGAStdgWVyH6K77oYnUMsFUoK0rZBGgUGujbTR/Q+siso05K3bzPWfolpRaRalHq3JS8PyF4hfIvq8prLLmD8pMEe2wTNDMSG3rZo8pJUV3c+zMM8zL93/l2L+79ryf//1fx9hIT/f36fD/MwD/Ofx5y6T6mqjKQPEEaLdWMQv3CpxC33Gsx48Fg2LtesubnbcrG5xPfgPpY8yi9YuD2v7jb0STVU7GXTFcXhyPhNT/CRSy06Vs5LrOCCs5VB0zqIWYBT9zTX4EZjzs5nvL2947OXDs/Ht/qYky+z11znHYveItsp3k0y3CJG9CFBUnGIv+Es/xGG4XKfv+JnnzQEN+f82dP3nDo/hCJkuyy5Xr6iHBeYXUN6sPircsP6YPODySe4I4O6a+hRQ1uFELrFQFFr96ww+fbsGUX5Gfcq5rwwsII9zttLbPIPDmJzTLRkcAKfnTxhU3xFjnaJ6uiywzbd4iifQ90iui0jP+ab65T1BVxVR0Jpk86/Zred47YhMz8gn3aMTQvxUUx6PGAse+SdzUvHpYwcfvLI49Pnz1hvM/4v9jf84pCyW/9PPN5/n5iO8WU81MOPjIRS71QyRdmKkTclbVPCPqCSmsUWg6lf3y0//YWk3HU0P37H+eoF5e5IGQqe4PN1cMsT6Q/CSW5bPDbPsKKOjTVCmkce65P1vb6vPVKf5yjf5V10oMlS3OUFuWkwPrvBlR57t2a6OSK9gKyomdcuXn7K6bRAnBrs+t8QHy+oYo9JcEmL5P7QoqIDB6Eo1tXgcA/jmFeZjtLscOsZ6vJLgs0Z087FdBuqPiGX0O4k6/McmxCv7BGjiqD5LrYsBiB5netetA4ihW1ZuL1Jo0ZIYXFm9WRNQ2UX+ELhthPkfsKbR9cEd4LVU8HsMKZmw9SZYR4PbMYWM8OkdHtNleNqklB0O+7eJowXCqMVjL/1faaXY7xYYCp3cEDrF0K/RpXUkW9riDtI7T4wLJT0dUkkptAxEi18SYzWQss12sUgRYsSPba0ccSUxGxplIuhY+qyJi32PE06Gu1sFiN2TspxV2JRkWer35+YMPeu2G8ieiNna61RnTnUGq73FpF5j2UqmhAcsaDtN5ijBLt2aA7Q9tmwa/tWT6VvcoSk0MRRqXWjELO+RDRw982K49Yh8Cyqra53SZicCR7HPkG7521TUzcFZhXgWK+oahtbgxsnE8azA4++P0P6FrLPif2AyJ8hvRCDFS8PHdkbl6r8CktbdcSMf/6dORexw7t+z72G7o0kUTMnExOaaUfn1cRHjx/HAeGJYMmRdSW5/Trn7ssjwp/x/T/5LsnIYZvfYeUevhNgmIquqnCImMb5oDR5x5BoVOMIG9V+oPWjeQ2tjSgOGK5FrzYoc0Q0K5h2cx517wjzJyzDFW/vc9xSZ25qbM2f0VmxtuYs9Lh4FrGLBbfFDm8ak0TzoY2idTJsDXVUNWW1JPId3CgaOA9102BWgsCJWO3eo3Ifa9TS1TW+eMz4EJNNNfRRw2pyqjqF+pS8/owo/oi63VMaMZsvKzbvbvCTkKI1qKIU0xzTalXTNHBUi9lb9H6CUMO3gjAclFUhNQhHaTeCi9mNUa2F2Qr6VmF4uslh0BVpGn3N+ODZdJpbENqo6ksc+Ywm0URhRb/eYLjXiHiEnJoUrfcBUFK5uJGDaHpm04pteqSttHrsUTl7yBSR3vRNQRSd4h8rVPEWndBwuWR1aAeQaKSFB9FTtT1e2dI4PaGfM/Z9alnQ1Q1OEGOn9xz7jJPG4MypWb/TsSeTOjUJ1AZ/YbI8pLj7U56erNkXFaY4oY07Rs73aOx3WJ1N7wa0m93wHHuTDF+Tja0YVRgUuqXCn5A42tjnUbSvqSqfzhhhueshQ9XUimybkW2qobP5buVQmTV9UeC2PkJodkRIoQ5s3mzJtisedwmnWlgzOnbCoVotqa0Fjrz/j70PeZiHeZh/O78vx8D/pwjw4ER4mId5mP9Uc3s75fbJDf/8MOa9I3jxfUneNoMrM2oM3mzBbUqsPKGdl1iThm2WEpoB04lPddUSLCZsvgR1NIiiG9rjgUhc4Ju6yW0/uG2treDerqithoNZc1F4wyn2us14VS+ZHyYs+gDX9lGGS1MU/DePv83Xm1/zTy/P+RfRX/HH20vSdMfN455n9h/TFjXFvsBxn/FPmgWLT85ZJP+EV69/zTfr16yLjkDXkkcW8fuE4unt0ER3tz7nxNBtZKtBQJgmC2zLJq8PKNnQBz5pX3BuL/juyff5+eYlG+dLxuUlWf8Gv45IkmD4bFZ2x8vvdjx+/5agdFj/sObp6gXpccOb5x1XWY9bS/7myVvO3yxoah+clO52wpsnPZftp0MsWBcDto1J2RSotibOTUI7GIQNR0eWN1/y5duYl5zyr+1f8TiYc3riUR0tFu9PUE+2PDLnzCZXOLbLttiyzJZ8Ov8YcwA2Nh+g3vQEvoaDl7TrI//3L/5HLBEzOdOO1QtGe4PvXI75tbPms17yrNVucUVt1zyOT/CDzQB49/f3bJ+UVGaA2+hF1kdqP22eMcps8twmFe8x+hj7cIIbhDw5ONgji3xd0t4qGm/Ft/70Eqmqgd2gjhZ3lc8oLNg2O76KvmZeTIi9nmRn0jDjIF9zyAoW/uPhIHSlrmn9C0ToDu1x0dTnhBGOsijGe9rURMrsQ2W8sEC8HFryym6B9BTPzyPsIGCb3tEU+QAV7VXLfa4LBnyMztBLA56GH57ekt3f0I5OeVJO+er6V7Rn5xxkw6NwxCxXVK7gwkk4uDX2ZzW7E5vkxOHb3/qxDhURjRM8z8f2MmxamkI7EwKEth/oQ0PdVIcYWh20YIDZYijoOh3e1jT2CpQWiUJtBxiaIw3p0hlaAFMIB2LTpak8zDTh/W9L5meC6WWIQO+IY7ybW6pww7Hxf39igtVUON4RY/EIO9sN0JK89zENgy4K6VWPkzi4tYWqOtrjms4e4QQNdbclKx3MPMAKE4R+MMPJvKDRS2d0pOkrwiwi9GOEcTdU0JiuZORrpeUpX6xXvHtXozYLTF+hNDW/fYkSzyB0WDW3jFqFud0zGhl03mPNXCWatoyXV7wuv6JZawhsgDz2tLYgCDrEGfjplHHRUSjI/DHCz/HcCtKQ1VrbZyrOJiYOE9p7yfXre1Zbhz96/oT/5gdPcSYJcrMl745sNZSlEnhWiJeMeBr1LFyXatrgOD4GNrVYYzZThK1zMfqDSueJBPW25HXxnlQrSK8yfpPv+HZywn/9/CmbZxm//F3Km2/u8TcJceISJgrlKkxdPzj16MQVrdI2l0xf5/Sa/tloFwfMZj6uFVAXEu8oqF2Jab+m3MzZlSVWd8DLA2rhDpTblfGezgmhqAcaazFVWGwwFoJa2phvGm48DeU4UsYdylrRbR+jzASTDqXrFj2LwhT0VoUvUtqmo6n7IXKhqx4NJ6H3ikFhUJZ+3TWltEO1La5qqBKB65pY+vH4Bk6j4Yw9olzR9y+oHUW/ucbYSez5BdOJy3G/x3/3hCr9OeFVxawLYZQNLI90u8CwbzE1mKQMketLmqijNkZItcF1HWQjkLo2qLJwTAu7iwli3ZIhUdcpVb2B1qPdhThGSjAaU/Y2vrUmDgTOZcjoCO3Y4FgmuP1XlHcu93xN2I05KRUno8c47YrPlzDaRFzGd8zdGU5tMvNHKGtC6Xe4jWRmBKjmhrKzqWLnQ3ymXFIcbVQkIYpInEtmdcp1eU8jJNW+5eW7nO36gLzv0JeyClNc3x/Ak6rPcMIxRvglanVK11fkS81i6Njujlx+62McTujDN5grHxnN/iNvQx7mYf7xzr9vif9PzSP4fYgHD66Eh3mYh/m7zNnJlmmx4BvjgJO5RCc+XuPxGwyS8Eizhff9jjiecuWavOkEbRBiZhnXG4s432OWa4Sa0cQF2DnWbETTetxVGWFv4ctH3C96vKnN+M5CHAT7/IC1uGSb1xTrV8zLEd7UJG0lt7e3mFHHH/hjvnf2h/TniqfxH2B1H1zGSSH5fHxLUltkrs8fnD2Gj0qEVNwt3/Kz9yWHSrJwau68A87WJ2wNzosZebTjZv4lr9WRaXOFKQpubr5mGp1RzmyOfcOTLiGyFjSqRrpHHsUjPt9/yjvjS06aGbcz2NkdT68N9l6Bu664q79D5P6G2Rufn01uObVNnq9GZG3Gpml4+tkppRkzig3cVYbnwGzZoMqWbqcoI4ND/SWVn2BYksLtSUwP+9Sh7QST4xNM6WGIlJO7EacXDZ9NVshTj8vexp5E+JZH2exoVcw23ZC4IZ2h6NuObbHmZHJO7mfElU16t+Jf/+LXvDxVPKOk1IfkvzP41qOEY3tNO3rP5e0FXt5hu3DnO5hVSpj3/IV1zcix+G7jMnbmrO2aPGjwlCDIdS26AXVF70hqW+CYPS45lSHJi45MSfqxj3XCwPyy9wJv7JLE3+FV+zW4p/RdQ3wTsnMK2JyQhrfcqL/m2+YTVouG/eHfkFunOLPHZEVP1LwdgITNwR4qNONwTNrmGJVFX6aUjqLIJowjAzNvCJsD3liivzPdliB6HbMvCNUVK7VBWg5B1mFZHYHsMWtFZfkk5iluEHM4LpmdPeGm0OSCiDR5TeycY3kmB/PAy19MmZsZf/DtP+Tq228/OPYLfdisWx51H56H0FWew2bVMdQJWroO0gKjH3hqOt/QK92Yp7lomgOhUYz6H4nQp7iGjyV0JqMeDm2VVj2cjpgx2VjixUu+Pyu5/6ZCcIHvBQjTYhPc0q5OmZwZvz8xYa/r+boWK6tIIm+AMPY7/YFiY05Dyrcd0ugQ4R6jjTCOWlwRCCPDllOkigfbe2+XQ52e7QiSuKHttGXjSO/45H1HuX+HU7jMTzsuzxIS3+Num/P2/Ya7TYVjThF5SZXXiMOMblphhwahabA91MRJTeTrp98mc22u7AmOpZCpizQ3WJue1unI/T0v3xvEi8dcxgFzOr5sSkqzIDYVs2ZCcb8nv87wp6eo0zmBbWB0t7zb3tDuHZ4rE8ssCUWAPZ5+6KXVHaptS9XVyHKLKTrieERkK3pboRwXs3Ex+xpDmVRtPSiAnx3WbHYNQbbH1j2mZTE4O5J5QOyNuJg94dOLLdcXY37xZsftbcryfYdrt8zHLuE4xjlvoGrRRSG645ba0Luj7jfE9seM+oybziD3cvr2iFJjsuIG0R+GNoU+mTGuSirLRYU+fXsgOv+E7vgWESXIOsLZKYzomjzeE9bPqcUGR9NQO8FulCLSDttZYPQGIj+A6HECC9sdo4wPtpy6Ww2LOL1P0+rsWYmrUnrPHZQ00RTUncLxzlGlGi7q1vKQnYWbZXTCQZyYBJop4ErKPoZ+CdcuVtiT+W9JmlOULLCjKaW/oVolqGg/VFaKiY+yG0z7Hb06HVw1bp+TtxCaLnEwZdtWlF2JpQWQY4Hle8Rn1mCfS1OfTFXYx5Zw7eFqL592S+ickqMrb2yK7Za5dWRnf0Jz3NFr1sUkwHGn+NaUdNVxs/0a4jH10SDtX3P6qEI6Y1SWM67Bml1RdhVSRPiGxShXpCIaGke0cqnqLSu5YxPMMUNJaBhUuc36bcbhpaSvK4y6o/MnWKa2PQFRiKl7n90VsrwY3guu52JsFfXK4mZnE0x2XD3ZchZesHK2lMvXD3dbD/Mw/4HzvxYVHtwDD/MwD/Of46xvf8qTZ38OfUHvmNxmb5jaC8R9RBlUjE9OcOW/XTZjj2B7TVkKcr2k7kacnJ8SPTFxNnv2q4BGXBJYBWl/Rycd5vqc2JfMOgVbOPM8YltQBBZzQxEaGw4nYzbpO0Lp4GUgDpLWr/jr25+ynPl8cjD4U/Nj+lnH7tFXJLeP6eM7fjh7geP9jnwvuPs659f7X8JSIayKk6DFnl8yu51SFYKju6Pse07rE8y8Je0y7mYpZ6HAcKAycqJqzNieayT3QMw3sZiaAZIv+dPZGb+8PxnuH18UPq9yyS/7BpKCH3WnlMFqiMVK6fC9MuTOTCk2+v635FD3eJZJojT3akLRBGR9idfrXQGu7Qo6D/PJgslG4EiDsNL1loLQsZFuhphIAk9wb9a8EzcYN3NOtTtkauIJm9ANcKOA3NljbhRF2tBKk/iypdW1jqavzeOM1YR/8cW/ZnnoKP2AJ63kgMmZseX2YsQXWcmVu+DTW499XXNzWDJLHvN6+56XdYzp9virhLL32TkOVdOAFmqcM2paiu4wCAluEOFFY3ZlStNK3KPDMdPOi57JRctoalPpio/WQMxG9LJEud8wDkbIuuRWlvTFCLX9En9+yq+Cht5c8LoveLSdkjc/5HKzxbIN1t2WsZUMkEGV1WyagkO+IXIjDFExcQDt8ogOtGaHcvShtonnjzB0HKXacNw7BMTUdkVe60PphiQ0aaRF3tV0TsHCjKitmMXknH2zJBQJjzLFr8s9b7/dcPnzluu54iPDoJ2P+MEPPubRCwND/ASFjWVLDFOXCeTYhU+n+XHoFgcNVhT6dH94TwoN/Jeag/ChelMoE9O0NTBwuCZ1maSh/5SQtNQYeiG0Jb1zQMiIvnfxA4Wt6yEdRbvbk+dbyubAKDnnbPGEnXGLpfPdvy8xwTELnAiOakrTvqO1O5wuRG1LLNViy5DyXtdrKPSuo4manX3ATSAezQfCaVF3OGWL7WkavYF0DeKTiMTusXQ9YFVSyITe9jGcmhNvjFHbZOtbdvfGsBy10wy1Legtk24cIducuTKwzlwCyyDwbLbSpj8oOGkZ2Sa/3acUe73M9/SRT7PbDye9v9DQi3OH755MWC1bpNiSXIYY9glve4Pe0IDCCNvpaWU1KEOmapB9x77r+Nm735D+yxv+5OMnfHvyEZ43wV7oPtMP//2hSvF11Z9QWLEFx4a+rWibnlI/1irnfr2m7BSqUJzO9d/tYNvwtsiZ+DPOJvFAy7XyEj8c8+xFwtlpzXaz58ubFW/vSu62Nea+YhTqSsUO1Vu0MqY35CA26MXeFS1N6OHtdJ6mpTQc8oNDWheYro59aBpoSe0UqJVBtwgwihY7d1GxR1PmQ4tAa4NRThn7MY1xQBpPsLuCXmjNzcMIBcIpaPYNXWliOSbCDGmdhibbIpsGV0iE69C2JZ5uvtCCQHXAzrXg5NJHJUbjDcwCraG1dQWtS+fv6Rc9+qeVqO+R3SUhEblc4jsJ7dbA8CaIoh4qEJVa4PQ+nWYALEKstsTodRasozP7oW1Ewx8tuxqAiLVfwcHE1t+zdqdMeoJoQdVNqS2dlSoG7sDYMrDtjt6IsG0tepTclQ7ZvievtsRugjAbCjkf3ujy2CK8jsliy6njs8x63txpLsIn2EHBq5VmLgiazTvicy1cWBQTgSFXiH6ETkL1bcK6z/Bj3aV7Spcr+ioYKntE7WDZx+E9oZtU6jxFHiwsa4aa5BgDP6NHFRbCNwdeh922WKrCGMeorEAN4mVHK31ef+FTliWjT2fY1Y4m+eg/5h7kYR7mH/X8XUWCf2hCwoMr4WEe5mH+rvPb9gn9esVH8Zg71VHmc37x+iWP1SeIn0RMvsgwR9rq3TKXPrPwilUE5aslfthQ2gnTnbZtV/SzDPcgsA2TKJ5i2BZdmLEzKkbbKXYQ40w9svbIsc8pO4ezbsLsNaxVhdP69EcXzm95llwRhiO8Y8UxO+LWNf8mXTL9xCGZ5DxnQWg7yOo5dy9X+tx7iC9vxB1JoB0OE8Srt0RhxP6so0pbdHv4Xup7/RlHa8vfiPf80Fxw2SSkZYdjF0ODQu/0jDQzTrtpzTHjxcfsrZTv8jG/27zF6CsCR1CEDcHWZx8s8cUF91+f8OzTNX85/5wfvvsOBzvjYJZUckp82rH+esR4prieZch3F4y9I7GjOFEuebjH0gwxa8q6T3Flz9Y84KuIZ90JlinJzRWqtNhtNT9tw3dPHxH74ZCLX6ZrAmfMSCRU0uSwjVkEDexayvYw1JXn8Wd89VvJV++/Qca68vAF0/OMr6yUq13M89bDO/ya3z2Z8QN5ym9O3jMvp5Sd3icygqYf2tkmSTjEuItjwPXlCN+U3IkjXSNwdhaZVzANfZ5ygjAM3r97xW/fFIjojCffcTkdL8jaltRwCdoOL4pp85rbXUXXdLw+5uztI4tKYU+nOGJJderx4uWGqHvOLYq6WXOpDxDpib0L6rZFpqco6z2i6qntjke2IrJcWiWwHZuPFgvMXpCXR0Td0DU9B3XkYG25c1vCg01vbKknDbNqSl6bvG7LQZy62k24cza8PTOYH5ZE9ZxVc8fOPsW3Os7fnSAvTao7g+zC459955QLXdfZWtjaZRAW4G0R8hQ6h87RQoqDMj9wEkyjHeLxhnZ965IF/ev68FZzFXTDg6m5hNqhEGA4HYZ2MjQ2huaxWQKrN1BNMvxZ/Zz01Dh2R6MjE48F3qsE2R9pqgLPizi5eMq/MX71+xMTTGdGPxHUb7+iWo3oVEUwkCENcl21l9fYVocReINCI4sGYZxjRjXWOENUDmJTQy6oVD60KZh9oAUULmc+/ihhcwDzOCayHEJvx91yy919xvtdTl+FGO4IuVlh+jZ9Y2BRI3xJP3IJ9SKVdeSiIOSU5iRgHriEacdXP73juKuGZbW1G+Tc4uxpxHw85jf3Oa+/2vPVTU3w+IyfTEdcxj0j2dLPYpK5jup7KM+gk5LEnhG6Jffuknyz5V/99wc++4tf8rF/wXc//TE/+vOPmFwl+PYYx7Uximqo52gLyf1xz2a/+XBhavig0OBXRWJ72FPBftwwqWKO91u6zuWT6ZjRSNvcewottugl0LPx5z5XOu/zaMT+PuXN3ZovVge2OxM2Bb7nEAUmda/tQyaeK+gdD78WzGPFMfRQLwWbvQZS2ripdiJsQTehNCHezEDsN9g8Ir+o6VSD9e6UdrJn5nlD3qnSNY00ePKW9pjQGwqjKfCn50S+Rx7fk71vQdeW6DTEoIiBWwfo2ouybzA0eFE2IFsM30VVJUbZQuUiPIkld1imR21bGPVqsO3I3UR/EWQZUcm7ofdWqJB0U2LUV2T9kVlwRGwUYmqz1W0S7mzId9mmgaeFrVTS2SZOdE7bvWOvIi4ck95yyMyeMJ5ghB6T0MK3FffZkXo/Ii9tMuPAIogYyZAmntIFAqmOqKMGIHoknodvH1hlIZQZYZjTLioy+4JTR3B/sHm5+4ZWq9P7LQfVU6kRcWAgJhl1/5Sgl3TVhmybEqqCfW9zrHa4oz2J/uHVpTheTY1L11lYfTk0OrgqQGUWaWfTxjt6M8bsbNTxiBFKHL8f4ieWmdCg/1FYu/0gqpizYnBtSLaIXcPRLvl/r32ePhdY47cPd1wP8zD/X+Y/Vd3jwzzMwzzMP4RRUcXd1w7Btxuafs3NfsrNixyW73iyDLAdnaW36duAvdkSOYKRtCE8pUxTfLlnrw95JpKJMeK2KCm7A2fRBCf0sAIdlTZo4xK7cGh7SV63eJ3HOJDkusa97XHTM/In75gJCyE+1DaWja5L7HCdgM+/+SVH+8/409GSRXXO65e/5br5krLdsr+VmKM5rXuknWpGWEzbtUzDGaEHZzq+bcVkUtdcbjhpHZ4GJ+zccohny7rBEh6V7Oh2B0ZRwspbktk10zag8lLGmwkrdc+FF/C7w5G5M8Y+2FSPTN5/fsvZxYz43GCdmEg7YLP0uLv4Ofbdj4n9d7A0ebJwKKyScW0TRyVFWQysMTcZERkBedXT1GIAQhY6MN/MSM2al+F7LtwA03XIWkFVKGLHx/VGw6JaO86Qmy+3kjisKNI1h/yOmZqSFg2v0hmBv+HNXcX/85uKpFmwX93guG9Qe5d4bGIoH0eahOOnnB1dbu0tZ++fYNq31NWcuLykMW7x7BmiTWhPGoqmYdRc0+0iqtajdAvMuUsY7rB0s0QLrzcZX70bs2hD/uxZQjI555itEE6EXZpUTkmSlji1Tkbb9L2tNyJiOabVUEwlaesx/5vVr1jOn5Etbcx6S6zAsT2avuVVeMv8/pR0cc1EQ8u3C3y5Q4gGM4rIXA0qF7hOTWCNCZ0rZNfwfr1ls9kShh4fhyOE3dFp7phlYtkduywlvzsy8nRb3Bvq6luUdxtudFS/CCmNKcX0nrMyHJh5f/l2yvf+D5I/O4sZBWdYTk1VChzfoNNxb04+OPt1eX3rYGrWgdDRde07NzHafmDQ6X8Zpq4RdDGF/j1d+ODTmwa9ZsZpQDsS6ejDSTnEe6RexHrN9ivByTCrCMwGw96zEDFF0nOzzKnXr/EuLpid+Ty5n/7+xITwLIOZibXyMHc1gZ/TFKOhwsQ67yidFtXGON0eeUzIunxY+q1KYt9VQ45E6CfDauk0qKLTSlGM6hra2mamzgcL0Xu7ptHVF2rBcXvHYdPRbT20VGh2EwxzqfWTYSlqUkX47RIlBAdjghOfEo4Eh7bl3G74lmnxm68zytsGb29g1i7lpOHsWzP+uz95xpU/5uvdip/9Oh1O6yeip15nvC16Zl7EzI+xHKGLS4buTisOGXUQ3viou3g46Xblke1K8FeHki9+9a/5689+znf+9CP+yYvvEV1OKeuWX623vH2zRq1MIrdnYpb0jjtcwK7jfhBkggD/qJ+fivvUJBqHLBbxAGaUbTos+k1aY6oew9W1H2B7LotHDuPFmKf7kl/f3fL5uxWHg8Q5HKEqsaIE/1TXuxjUzFHzgvqmYKdz/e0KVDEwKDRJttAgD6+ny7vBSqPyFFVplMcI41xbaCrU6ILumGJ1e/zROd3xQEWDbVpYI1OrQTh+hiktWq8mL4oBuOnaAbZtUhgSUenX3xkemwg8/MjCjhvKQ4G6T+jcntbQH5QZXaWg8bEtHf1wQGnRQNLnDcGJS9VscYwFRmvS2HvickfQPUEt7qiPJSYb8lpx7iW0mFRWjzEqYa/ZEnsCN0A2GUU9HfgI5FtcKWkjG9PzaJojZd5gNrqjtR2cBkdX4cQQcxi6kTESXGNPFOg4Ctz3KaptWCSPEPEdh7sZo5HFo8WM/3H9Fl+mPP/kBWnV4dURc3fHQZbMR08JAl2XdOTmG4+qU/TxkV45dLiEtx3bic0ibBiPbUTifvieRIMyA0xLa4x7St2c0egu3x4tPw5Jl85A2RIzauiPGuxzg2WOwPJQlrZDdXgH/fuSvtlTbnVd8Fu++WbC2VxXdT7MwzzM3zYPUYaHeZiH+cc4z/ZjfvXxjh96CW8yj4XfclE94j5J+WwTktRfYpkOVu5DVHNrHAiPp6Rew11ZkDQN53EIaUB6LNnVSyq/QFbaOu/gn+XsKwtpeYyjHfl7DzvWZQcWthMOzWC5IxntahzOh/vn0/Scr+xr4s4j3RecWqdsvcd8a3rgI0eyXx54t9vgK7iXU9rFhomOhNYJdrVl35aoiQ1ZQ9msEeYcNz+w92xm0YTWyjj2HVbm8sY9cG3VfOJeMrZs+q6i73qmcs5Iar+nQdgkQzW8Ht/c06qWZdpyngYUx4ab+IQ+3RLEM26cJT+8veKbZ2+IVh7CTpGOT9094qfTX/Kj+pRFNSVyJJU+zE01iE+RDgT/4+Aubg1r4IqdOj2p22AYFofCwU41q81g+timKgJ+8YUiit4xP7mn8GdsVgt2u3d89c2SayukzN/yvIK//uUtv2p6quma2WLMXd/i7ROWZoZfXbEQX5Mbz0h025fwSKtvMMsYa5pxtHsckZKGNWFvcowDZNYTHzt8M0TkUw7BjqJJCaWut9csrzE3b1Pe/vIaDX/7kxcWj0cBRuxws/8KG2/gAiSeoBcuLze3BI3PISxxxIG5H6G78b6KWx6tXNaGBil+DyfdI7c56z9umX1m8Lm752kb8KiIce2SQO8QwmA8kuxPbbpMx5RbvVsTJAFuP8XEozWLQeR66p9xms9ImxTDhMQJSC1dp36Hp5sb+gXpsw1Oc8FnoeLiZkvhvmPcXGGwH0D5BgmJCEhXNdOPrvjfvyg+wN+VwNTucdMZGhiUrt5rEnQPgzJqlNBBBQOh4x2mzhC59L3ek3NQ9gBLtE3oTFO3eH7YEQ19pUiUdjpoyL/UEHtj+Fq6KU67GpTZYUm9h2tAoQbB2/hmQj+tOZEXvFkrjqvXuMG32Hx+D//d70lMqPIRc1ey8Cx+577D6zW2MsNyXE4mCzbNW7L+grySmLWB6Y/p+iP7XYg1NzAticj6ATRo++DbNVbR0fQGm6DHzLXCIobsd5xU9NLFi+ZMkhVFtqNWMaZXYHQJ7V6S6jxO0GHZHn58STSO8P0RuNcYSzD7U+7u7/nyV7cDrRK3p/ArTFtDQgS35j2TvhwqV6JRz+lHLkHgkhlgdhZeo90OBp5TIloDL9N2c+2IKLBkO9Tw6Wo922xoAg3A2HJIe37xmcEXv9vwm+/d8OM//ITOTXlzXRGKGq+ZIieCbmpjig9vuA+gjBbZSyLToToWrHODP72cEPousu0Q0sLStZNC6sZQzFbrTwadpnpqSGDgMvdcfjL1uTod8/W7JW/uNTilp0h1D6tHPGpwoz1e63FfWGyPv8JQCsfw0NSUvtGtCg121SEsF1m6SC/HEJMPnbNGhllkODjg3qFiG7dRZLaJZfUEk4Dx3Oa4hWJ9wIhbOt/EaEwcJ8HxC+pS0Ne9vuPG6FsEFc5ohD0SCNkM4BB8/YE5wtGgSjunVDkOI0ztQPAzxLan0ewQ9wyrPVBqAcRqBniKc/qeqntE3ZVk2yO9EdDkJ/TsOeYG5pmL1wfEMkSJNXW+pW8jMCq2qw1B5FJp14LU/h8PRD0oer43wvQ0jbYnzmLsQtHpNg1PV6vUuPGUy2SEZZrUQYNKp0xjj/Fkh6hcDhoq4xos08NQeSqCGGPcE1oVs/qE3VEx0UKG6imyitZpcUchXqM4HHKOmhqserLVYagnvR5ZnH7s8ehsqpELAzjSsxua6sjy5ki2bRFihN1baJpkJ3REyMPIBcKu6WoHpeGXZo+nY2vWPX7iDzU5nq1bQCTCNLGKip1cUey0teRhHuZh/rEICg8Rh4d5mIf5+0xXH3hhhXye39AUAedNTTiOSPY+te+xqk3crUk4krRBx6xaYJota2+F0CXbN2M2bjNU9hm1hVHpE1QHd9wSjvTpMIyQuKm+74aDc4e0MuLZCd1dSoOktU1WsW6KiHiufGxhkFU+W3mgrNY4lkB9Z8xP4jua/R/xP3x1M8R+wxBmvSCSc9K6xuojnG42HLbkJXxzskZqzoGs8PVOI+yBEVcXATsdF5faVq9dvg5Vm5P2itB1yMudPqkh8D6c3KpWDI/D8HqMpOS0n1B1Kw5YjFROfKbYG3OeVgbdfozT+Vzma6T9EYeTt5zfjCgdydnSHA7VLKPjdqgxf0zp9UNsWlvT00gfIrkUdkXYWUOEfJ2GXCUzHLdHHW0uFgvcoOZ3x1dcHzaoQ8QmveDFqeS0q/j5oeQuW1AdDvzyZs2vRgbLv7gl+Lbg1LCZjUq++cyhS3q+e+WhPm6YrS/ZTPbcvMpwn5nExSmzaMqX4i1uIzitBe+Nlknj042OhHbEddXjWA2Bf4/hBMRFR9gr4qJkdSv4/OcW3Ff84acBT87GeEHM3WpDfRQ4U4FR96RBzeogBobFO0fRjR2utoKSjlhWXKYJdqPowwO3X604eXHOrXdDY10xPsvwU5eyTKmfOIxlR3UtmS5mWJOWqzpBqQZldEPzWzwe4dghWbPnIPeMxYyZNyZyDbzKRSpJoLkSRkbR+nQqGVw33xFnjH2TSkUYY49ZPcOTDRtjR9OeDCD2s8jiyfM5/8c/MZmNZ+TFCKvRh6c2hrAwVIvVRMNBqhIByugRUtDq/Uj/r1EYRj0cHGoeXa8dkdLQRQ0I5QzIRaX5ChoU2YoBvj/E7LUzXDc92KD0Lt5pJ7kGOvaDONL3PkbVg1djibck42c8/9ZTlhtBWym+/J/qv/Xz4e8sJghXYLhbaj/Atiak5QHDPA4Lv1QtXjjCYEt97KlbrRyW+MZosODoB6yt9rmjlzSHKHQYxQGq7an7nq4QGKP9UAnphQbTmYdnOpSTkHfZGjMR2Lmis/ZDnWTTO9hNShcZeNLn0pY0lmC/PFIm4E90RUrHq+sD2VZBbYLdDgyBQrsZ3hX8Ze/xcnLLibjE9WzmY11X6A1gu4kruYq8gXCqpDvwDwZrgP5e244mbZHFgbKIsdRiyLSYXoBrGtR+SrXd8/bX+rVesBinmJaNO5nj6Mfh6opMDwKtuIFlKaggKCp0g8fb7RF3ZjIbhQj9wotepwDo9QebqRBVjbBtOrMD3TOq2oFjYNsGLpLTICR6fMHTecHyJOL6dsumlOykJuUW2MeU/H5JU3iYOn+gPUP6dNtTGBnIqMf0AxzZUdoVfZ5iX0GSxKzuTmkjQVx41OV0OM3WzpQg9klOwJ0I7OxA0eoayJTIDuicLUJneiztetCXej2IJ4Ymvo6U7hKi3jq0OXT68ei6yLRA6g9Nz8WOfUzZUIl+qNgMjFMMVdEZa/22wfLnmI1PI1q0xqYjIUd5oGaMVRWYsSLwBaXSz/sHW9jMrIYP/HsvpCr39Mqj6zIS3+T0LOJ+U+Mrj8TU/A0tfmQDdVb2JsLtaI0esyvxnSmGaVKojLPxY8w2Z6UhMqkxMBJK/SGos3Qjj4kwKKQiGPtIc4RoJYF7MrRZmJkgPBPUTcfdyyNiL7HNjsqoGZkhvdzQWi5FYNAdKvpdx/rXAeW6ZPbYZnw2IZpozoHJXmfVXF3HuR+iSJbRYrjaBWIj8gChX/NJPfREG5r/Eer3kEkj3AEiaaUjOu8WswjIJwLedMjFw03XwzzM32ceYg8P8zAP849p7uycHxQnvGRPUY75XIMHXy6ZT8aMwyV39+dYzYZGV9apBjdMkN0Wdz3GN/qBd2a4Bvf9nrzTQLgJbuSTxBXC8zBrj7Zp2FkaJmgykgZWO6XaW2y7A01bkeQj7FYyXjkIf8m/tAu89zNsA17IJ7x+Lnk0X3MYneK9sXHtOwplsBcKt3D1oS5OISkMXceeEOuoro4Q71rWqRYstDPgGun6ROaJPjqjr9KBJRXp419V8EVuccg7PjpTw6FqUS4QZ2sM3U4hT6jNnIl1idu4dJF2Ejv8rPxrqreXxKWFirf8dtZzcTPnTbdjYUU4lo3MIu5EhZH31B8J2qOi1dwz5eJUAlP4KJFzUHvc1KbPMw5Zx0bq++tm4IaZdkmedGSBQbAxadcNrzZyaFGTzZ79weHXu5xRNSa5MDibmdwdE77qDji/O2CHPabVkN0e+HzxlP12zdmTMbeuy6PjjvYwZyqhslZY+XeINETxuGb9+C2fvPmExm1o3yfcrU1steFttSH/Zo//8ZRPJpfE+5Y60guxwf2N4OVrk7PO46MfVZw8KofowDZbUXRHkvEJlmGxOm44ODUGCxrf5txtEalL0dVMjYDrp7ryskcz/tuJjX/nsHpccv7eZnXd6XZNVN+QXtVMyynX9z2fnMLJeMQq3mKk9cCx07F0x/ewLJuu0zF9k8BMKLIcRx4IdGthIAnsgER02K1JWP+QTVzgmQWzdDrsue+XNWU9IjxrmOwkE8+jPkas9yv+6A9e8PT7M2aLgL7VDnMXwRGlXcJyP7gFRD9GujlOo6Mc5iAoaOaiVgaGpgbTQGqXgdQtDwadqBhwi42B0Aw1LTAIfeyseQh659Krov49awAwamd/r/fZ4Wg6GA4xDd19aJpDZMLhEpIDhLkGHiLfNey2msfwexITml3OulUcXxWYta6gsBh0EKWt7C5u7w3igpxDu3GHqseegq7REIgx01EzAA3zNMKPPeyJgaoalBYfcrjd7Dk3RiysBXYlGeuqElVoWAOW1K2aAsvST5LCMQWZBuLZDlmgwRc5zq3OTwmmCNw4wcsymvcNvf5QECapIcitDqt32asCT7nY1YzZ2OAymbCybY7HGiNXlK07WLPCMAU7wuoiXC9DhCar+hnb+Qixd1CioldjTEvnzXNqvxlAeL7QHasRdZGyjXLGZ/r/hzhmi2UJhH5MncTxHDpTEdg2uacwDwFZXfHp1COObZSu8tAVir2B5brUsh5sMK1+1XoDU7X0eitWhm5XHC683upwA5MTN2ThuzyeTHiz27JMMyrT4GClpNqNEOuogY6LSJRud9CAjsCH7IDiAtOrBqps33c444CoH5PZW4z5iiY9o1UNZp/i6JP5kYXtxeQ3EilNLNlhbj0q3SBghIhaIPIQo1QYbothaTuNNajPioaytJBdgqWOA7CmMQ/0joPVT5ClB01FSw5th9JAybGL2jSorsPNxxjBe5xAVzS62PYKu39M293iqWCg0irfw+sErkaNyIp+GjNxA6q7mn1nY9gd+DHO2MX3BaNOcx2gkC2qavEsSSMEqsgw+hzDCIZ6zKzKif2IWCSYfcOxbckOHWneoSpBHU5Q4oa5Gw5E2q1WZIXJiUiYmBblAJY8YqLrQW1EX2GN4HCdMzI70trndtPhGu4gxniugdKuERxU51Ase7re4LbcId/dY+S6S7hB5LoL0qONTXrpYOo/X0mMpqXXZKF+S1NECCdEViWtM6c93GGH0Gj3iNmi/HyokHEnupNn/R97H/IwD/Nf3PxDdSc8uBIe5mEe5u87VR/y203LLiiQZcViNKHKJNtox6JfM1XPydSerlZMTR/Jkn1Y0xxdlJJM6gzVjzgmGnS3RFgBbmjgCF0Tb1KbO6TlEroNgbTxbJeiEZjVganncyMN7omRzzKSdzHFI4m9t2mKC2bWW0Tosnia8UPnz/jLf1Xh8YY0fEdcP6XRDtYmYX0shkrxRhgDY+H9aI/cpJja1m4LFnqtEg5Ob9Hk+qQWjHFBX+lqvmQQRQyz5U7X9m16XsQWgV3Q1f0QNd04e+I84jfb14z3FacfP2chTL4jP+Y6zllWOY83c2pDu4wboq4jdwRBl3PvKuSpZHF9ZJqf0csCUR3B0FBF7eT1afsUQ7n0qmRnKta6AW/d84OzOd8KR6hWDo7k7brmr/oVlqNrzH2stCcWKYafcdgceGm7XGrXcl9SeQ2nxpQqek+h73OdM3r3NeXK4sWPTjmfZVSc8Fv1Gd/vTzDkjtl4Si87nMij7gUvNv8Vxzrl7rbn9uXvEOIS7+c70kZgdXPMa4/lvBlcFFNs7uqeL181PPFdvv2Ry36ieCM8RluwIkkUR0Mt4n4rOMYtmdNwoRp2TUZfnA9O6bIXTF2Xi2NDo3JEHfKojtmcN0zvW1ZijsyKAaS4mpQ8aRZcaUdxWGEwwnNi/KyiyA9EToQwdAugiezvUblN29sIzyTSTDHd/tBKQlPzBUqO7i3C8PHkCF/UXCTuwCzT17+cNZSrLaOm5+lizCjYclzNsRrJT74bkF/MhxZDkbtog4FS2hqgIYomSunGuw/R7qbXu11HryGK0gH7w7puGA22thzoqgltWEdHHfSJv3Yv6P9GRxwaMHVCxB0EBx3p0NKCbfb0StHpCkkdcW5aTB2d0LKZbBFSx547xND6MeKxXVBnEX/2347+1s+Hv3vMYVvy7qslnn2JinUVh66tWOBpa3qjF+SMRiP5NETPMfEFlP0RrzNxVEBs+LSBQTV0FbaDxcLUnfddTVlV5J0WKHTVRc7xILkVsEyP7Dc1XRWSCIGhwR0S+lGL280wdL2i51Lo/PysZTxy6I2C1bWLcTwwdUzyvqGeuZRH/ab0+PgPnlOPc0SrGxamVNbg/mDaKsbhhxf19pDyerAu1Uw8RedEKF/DMRZcPv8DPtFZLDWmfvUKO7NBFvTeTvvACJyQ2cQlzSvatsMQAa4SdG4+PE+2H7E3WqI8wTQqul4hJXhSsNxt6QOD08UJQrcd6ufE0FkZnX7psA1L6wb0+nvXF5ABrY4aNOWQh/EsR78VaPuOuhn0KORIMPMnXMoxxyrnV5uYevsbmiIldKaY3l6HDQjaAGXPaY01hlNg+x191iJGMaapqJrlsMDqDl7wEfEezxnRtg6dzGlri1w2tK1HX2pRpqH1WkxfV5X4UHfItEJIiel4KFNvrg52t6PmiNBRAsOlrUGY4+HDsjKzoeLTdLTBzaOPIlotODQjosAaGiN6vxieY58cy9JRgQtc5xUn2rYzndK3e6R+42oRohW4nsRxR0SWTVPefmgOMWKUH6J0qaYyME2Dom6G/JF+s8rOZpu35Cl4vsC3dbxG55zU8CbVwJY+K9lt12yrEtopRtpSNjd8fOYTJgG1sHkkTNyww7W0qthwqA4cNuB7IduqxalHxBdHDCfE7CGuNORFDPktw02xM4/eG9PZ2nKUDX93tbZoNxVNZ2Nqaqtmq1gTlP4Q0vkpS7eD1Bh1Q6OvHRViViPMtkIVUyQZVr/GrPSDzemZYNQ66uBj5Dpj5aNNMA/zMA/zMA/zMA/zX+aUHTirmtWTEe6+RT36itHrj9i3R7z6lKNhE3Qx3RmcBRHHY45VJhylpDzUBCOTzmkxa21XToYqRGEoiiLSXgdcu2Nmj7Bam27WUoY13aYn7C1cxyFUDmGzJbPD4TDrrWFQGxqI+I6NzrcHK37gJnyjEQjLI9vJGzx5js+UcnRkmd+jUp+7q4KnMqDapxiU3OY7mtDnpPEQVcj+ccK8N2CnmQA5Vq8rIX2WxoedYNaGOMJg1+tl3mGs3aqdgdMELCxfG2v5N3+xIWp6/ndPr3Hnksf9xySnKT/9ukWFggtryqpfEupGgoVJsBxRTXZM7x9RB79mVn+Xl6OWs/4JNjldKKmOG3YHn4MVko5TVKHbGzqiiUEQ66Vet4n5HGtJKSSHgz7U2iGLguQY4V3EHN2G09YmiXrcvc2vDtc8sWLOrYRf6sh10qKyA4fSxV1ZhNF73u0CFhsdOf4BX8Sv+H4/xjFHA2MiFZLCDrn75RvWUcbbLyRl2dKNrqGaDPB1ZVpslkc2f70lNS18MefYOnwy9vjBRyGGob/XKcp0EE6F2dvY0hgA8kpXgpoJqtFEigbHgCMpfS/wXRNp1BSHir2oca0Ffp0OXLN1wPD6deMlFFccx0eMdcfKr+mthuvxjqSXyKamVwuKLmfkmUi3xjAThL9CtCad0iKTjSVsmqbQ5nQcDX5sLwZnwepwR9YeSKIPjSSmMaMVkpMzj/R4wNBb/sQh2AoeP58NQP+DaeJlJrLRfAR9T37EbvVOpA8Va6QWFIQ1iDVaQPC1wON2CH32qDc8YSClPmT+sLsamuRva3eBtrJ39L124etlWmC1uq9uoKZhyA+1krLXjnaJIT6IC1J/FdVhiZqeiH4gO+p6SUXUBrhXLj+Inv4e2xwYobwWQy4wir/GyS6pA4HZ9QQatuF0H2B5rT3kSSzbwhXntEWJLDpWvUGtAXqtSWvbtFWA2VXg5EOjg9naHHcZbXEgdD8Q8o+bgmyfY8cWlttQNTHIntEohLqlribEjsZamLhegxVY7FYGmy+XSDnl23OdQ4GiqOjWBu6FxeKFXugTDo2Fr63elaBpFKeux2wS0to9caVt7SZOZWIEAleYWFVI57p0sc3kwuf06QVvdNVjn2IdayrtGhEmfhwQRZL7vEJ0ghM7GC6G9JDjiYTAECRS4qiCWkgsL6GXJmZesC52nM0+YRREg5VFB2H6XmdgxPBm0pAODQnRGTD9rpI6AqFhLE072MMs38cOxKD0aqtOVlUUdUlrCZzYxmhr1rt7quOBQGo1ePtBcR15NGmCNTkiHsc4fUDfKFodMaAiK1KqVYmpzmjuc+yqxo4TkkcnpHeS6pDSp2tGc4fsfUeR6yBDN3AgPJUNEZlWtKjYxEwDaAqaej+IE7Ze4nXWSVSoSAsm/kCmrfTz6mYfLnBNb21MrC5AiQKrCRCjPb2ul0w6uvse/8Qk0jWi0RZRz4m9HGUuCBYlu4MaKhPVtsYdK5puTZOMcLVjQnoYXTtcx11mUKuWpjbwNCiSnnspqXUlTVshdetEa9FJveALRGQOfbmx2FDWIWUqwfIJXInr6SpRG88Y45QW7zYFhSa9ejaZqKFu2FvaDuURTO9ABDh+RzRiuKZTYNSPWSwcNFFxKxusRqG2iuPRGqpXZdqQbjNUY2HbmrVQoAzNltDuKYUoouHv6wrtoLFQVkWf9bSujpeYw4dRrd0sYocRBggNf5GaxeEgMgt52CJNXT/5D/OE9WEe5h/qPLgSHuZhHuYf0+jzqUPSYh/2VNsDxV9aGN8+IVwHpLZBYkM1Hg0HTmlTgYgodxZ1pbPbJplrYromndSHOCGRERPXxeBG7aRHpzvvmyXSlUjX44lKqMMPTs93kyPnt2NoPcKjT3r2kuo4pp7viW7PMCc9P3hmYt2f8t9/8YoLIyVoayrhUpWKiSdotCPBD4iCBmsj6U2b9V1Ef6l4Ml4xjhOubyeUr2tyjVM4XdLtYzhcDOwz164wM5s6syBoqRPBJrMYmTs8YTOWGmonuOsOHNOaeK6rL0N8fAzLZR7bXM1mrLKS/HjgojbZjxwe18HQSjffSKTSh01jSmkwK106oxraz269jGjtUEU7jtmUpBxxEtQ8/eiUqTvh9rDmi/ctW0ez2GpUbtHq2sOyw4pM/JmhO92HhockhIvE5ut9RvVeEHzXRxq6Icyk2lygRr/GWXxK86uC5RC/qHnDW84Xn/Dcd7E08L7sWDdycFIkWcarpWT9sqA67HD7OWK3pQlspAam+wustUl+s+OL0GZ+FfOTb1X80dV8ACzep7vBpXzqW9SGQZfaVKXHOtYij8A1LYywQOYzVklHZFd0kcVp4ZPKFZ45Jc+P9EFG07RUE4Us5jSzO3yvpjy2qFzzFnI2niIQHXLS8XZd4xUmXh3QjHoao2csEnwxw/Iicucet5Fk1pbC9Ai7gFbV1O0a0Xe43fmwptuGi9n3lNxg9h6joMStTrk9XrOSAX88fY6fhDwfj5AaF6A6jM6l0xD0PqYlGg7jB0eBKYf4sW5jcEyLrNX8QAcK7ViwcL0P7nx9nz7IBBqwqHfFYV/U7gMtFCjQ0RctiIl2YC30/9bxoBvxdA+8MfihLZSpWwI1J07rDXq/0geo5uBi0HWDhulgh/pgvv/9iQmSmkl0hn7K9LLmBCGy3JHbPl540BxAzCQitGy8MkaZO3LfQtYeTadr7DSNU5/m5jiVwjQ7XNsgMF0a20LVHvQ5trbxa296dyBKXISMhsVIK5p1EWMbB5wwx6x6TFnhaehLNKZpXPYatJgeaDcHjirkxnvPfePT1iOa4gRjnXF3qDnteyINBUQQ+z1h49D1Ga+rDD/wOH/q0maCtNWihmDiNzimVsFKunRLmoWUWUffQadPulNdn1jiBAYXJy5x0BPlIdnrmrpoaC0TU3kYRo+qauLApxzrqo566AwVjeJuv8O2PZ5PtNXeoFUfFDptYtGCgo410HU0eqH1tIgjkUIhG03k7IeLoalbhO0NtTCm2xNo2ob0SY2WbV7y7k3D+3ephhNgWyaVlw/OB1OYyCDFGH94TSx9AY4N2Da41oya9XChantso1WTWOEnGvvQkosd/bGHmc/UCXEeWwOgpj3sEV1PvXNp9v8LMESrbRV9remhElmmdKWG/cUf8vvoWIuNapbgaDHGoa0Nes1a0KqQ6ulFPlBf6QwsDfJpWwpXUcgRoXbq1Dv6+gpp5rj6dYtNPC263CXYs/fkqc/NjeIidDFlgdXnNFqMqlaUwqPDwaIdAIRawdOvf51tabJ8qDx19XNuCbI6wSxbJnGHh65+yekDn1jXMqLw7TNkteZ6v+RsOkPOBYd8j69s/NZH+R1BfcrViU0ZbQaKatcaNI2P5Rj42h7mVBjRgdxSJPoD2djjzgSTY0OZtRxWDAJHejSppOYkhEMVaNvdDx8mjuYt2B69b9DnNqJrkL5WbjVkA+zunrA7QWqxxs5o9PPq7ui6DlNmGEGAlBpSqZXKh3mYh3mYh3mYh/kvcQJZsfVuMMuPaZ/n2KuPOJ69I+xOqTY16fOMi+METR7Ybo+EjcfRO1DmB/zLUKPyiDUI2g5ooylB6dF3KYUraXT6shakVsSJrjPXsLXaYeJp+lrN5Nixa9eEccKM/5m9P/u1JMvSO7Hftr1tNjvTPXfwKcaMyszK6mJVkWwWIQkEmg1BgCA9CAL09+jf0YPeGpBaDxKbIimSxS7WkFNkxuCz3+GMNg/btrDMkw3pgeySmCyyWXcFAoFwv3793GPDsbXW9/0+yy6pWddbOGeEQYq/kAFAyj/5x98TdCUXywvel5ZzMWHDn6L7J/Qbn3P/gOt8JBPuIP7qhc/f/vRzfpDKVlkYbj27fUMZTayrLXlrmLxyBgb6suUdJBVrmC0KTwnZ+DuqOsX6LYxCXNiwMYY/+n2fL59dEctrayOsGuam87Pr54zpe6piz1Jl/OsnBdevWxJ/YKVy2ujIt/rEM3uJaVrsVOKriOB+zYfzgcBP+MOLLU8yi2dG7GlB2Q+UnqW7Vxz7MzyxqHbJ0A6kcc8yMvR+QPVQQFNT/ng5A/D308AiiEi/arl9dwEUbMI7Wr6kPh7Qi4nivCPb/YTq0x3qm1uylcfL5Y7kVU73bCCoV3z3fsdRWGyFYjle41IPRcTY+ah0wOrjnN5npozfuQz5ez/5hCfPwRs7qmNHP0KUi9C+pagaJuXjpx54DTVH7PAF9RDQL2tW1ZLDRcOLypOWhGJlSE9wEax5H3YE1Z7k4DE6j1BNeGpJ5Rr0rcPTMd10JtM56RuPn2+PbA9r0pPiIvLwU1nKJbPqwSmJSU/ABDN4v23v6W2Bp9a4LsT2msY1yLY6j5czI8RXC/q+w6gNnW3Y5EveFHtUI8/hithP6E3GxdBRhwJFF/h7hu/XQkVEeSHO3EkmCEE0wNDw4VXD9w8HFkNLY0J+/PkN19fSj4slQv4rVAT5Z8R5DjWJwkEGAYJkdIz+hJIJgRNVwjxWmBfsosAWmbtwFMQO4ckAQf4Yo4RRfgTQ0862fCvw0FDoIb+lYYIbZNua0tc/w988YXpo5sbKLXKur1rCdMN5DNGNIylCdmZkmVq2RtGNInMXi35LEJWoyZ8l2nHiiH2f0nrzJM9YLQJ62rOj9EK2T7Zc6YHOFZTKss06zl7AwbaU4zSjK7omZfQMadeRhxNu0iThinwoONY94zGhbx8Yk4GliWjfFrw5BKR+Rbrq2C6vyVKP3aHn3euJL5+tSLdCVO04NhNWtrSexk81AT3dwxu+faW5/e7AsK9RQ8lU7VFhz+pqxfWnC/IYjrszv6TlcCjZ1DGbtSX2Db4oJaIS31uivVQGR3hlx/ui4Iur51xexRAptJUjrJlkyiiqDsEdTr0YRJianrEWeKI0nB6+FiZETzv2mNYn8AKsP6Ejj0WQkdBT3kuqxHuO7/Zy7tCLuEGv8FcVYyQqkTvGKCWWLbbf4S0dYZqzeRLNjXMXSYRPTbIImfwFIx+w7T1K54y5ABwT6Fq8OJ4HDe3JYTtRoMBkOyYtNxWLUgFBqtChwo4ytJHIzx3GZIxNjg3EBiFSnRbVB9jGQyVLlOmo3WnmZQxCyy18oizFS3q8RBQmNSpYEhuxSuzZHw2X5oQqNGl+xXStSZIF3aHn9vUD6cKyWWxY9DF1f2LM6vm1yaQvkNQPeYOMZZN5TIUWEwUmjAj9aVYqKHtETwajM1wX0Pcl1hhMB+V4ZJnIeSgDpACzaHgSxDSlpjtbouVIfB1CoYmSiKR+gp3Ei9VSIFCVATOF1PctjSeWCtgQoNSSfKvRF5bKWvyDxHB6qJcD1dHMjFDreXOU5OQO4p+YUxzGocRNkvAgmNcIrTr6ppknkGoomELhWmiGvMPrEygUpIopCUGOcShDrcd6rMf6K31WPrISHuuxHus/szJ+TuyFnLuaKNiiljXZLieiYbhKqV//gvdlyLQJGIqcYTzSGUm+2ojWncQbyP2YIdB0Y0UbOKxJJbdrtn8WrabpW/LsisQGc8PjWssi1DT7lvtiIntekepLPrTicR9oDkuyheLpC/jF1z1/8mcP/L0/nAiiNVOZ8a4OyU3DTg3oKoBjwkP6kqWwoGqf7VcdP7lqydob3rzpuaFlvb7ke4F7u4iFP7Fb7NB+yLpe0chWN3Q4X3MhnDJv4p3peTYvmjyaoSX3U/7oR89ZZpISMDFJxLc0cr5mWDl+Z/+CNt0w1AVNdc/xOBHIezYcGdya3PkoG2IFuF5OvNUlqrxivCr4yeopX6wuZ3ZXuW94VcveSFF+cLS2wlsYQrFDiwx+SgmyFnV1YO+HM7ti486k0cjtrY/tAoJ1TGdKpjKgvo3ZSgxh3HMK75miJ/TKwLXYqlMeklf8xe0LVvpStP706x3Pf37Nf/+6pR0/sEyWDMJRSJ9TvX+P+UpCC5/RnA642udvPdvwB38Y8+WXG3Zjwe1DRdi0hLklUvIcLmr7aU5X6xLHYVzyYUxYrN6TFyv6sCNOYVVbhm6QJ3JWQzrbKNrFiAos/V3Kp37Ky+kDDUsWfco0vSS/vuHu3GGrgF+lJVcfrmYldBQIQH4gCzwWUUUaKsZhYpTn6z6k8x5QLiB2OSQVdfOBoUowvrTcsozVcz/QtgeiyGH0iroRtc2Jy0VDEn/C28N3sw7g5X3Ofsj57OqaJ8uUIpD+QDP2oj5Yzql9XgBBfKZtQ/7823se/tU7HlTDy9eKs/F5O3n8V9kFzzLoxIctgPjf7JrF2uB5I3pSWGEjSAykNb9RIoiVQVTIH1MrPDm/xM4gUMegQ3TYnsTkia1+FF+zYlQ9jAumUKImf4vDBAGWxGGLbrdEw4Iq0aRWlALyMhOu0pQrP2QaHUfTYtySq9UAScPtURIJZMPeMvTzj4WZCuyosSYh1oLarygHxZ3EPhbjTP5fRopNLjLvG94WKTZLCeXET5+yFPmHAOlGmfjIwEEzvmv4fPWU5CbBtt9wW2UERYYNW8LtxxjC1JWcB8vQp0SLCIyIPD4emFCN+Kan9WVCqUmUJhRVgUjHdUDgDZhxT3vnwa4nFul7IxGRDpMFXNykbLIYHfvoaEezyinbkarquBGoYhLM9gOZDBmZKAUxnvAiziN2ynl2uSUOhfgicifJB7WMTU/XyyTUmyMPO4FnGIETztcckQoJtNzgO3ZNSZ9ZNnJCKUMgN4JA4/yA8b3H7fsDfVvgy2BCJO2BYpoiYsFVrFNBPnCuB3wjp0WHTlqsyP1dRJD4VAKYzMDuHIe6JlAavw/IFsMsiznhYY8li3SiXUB9Z+f4SpF4GVFTSFMqdgV/wkQ5qghnRQfU88VgRIpvK6ZJ/rCZf87J7z7G9mrR0Glc4GbehjTvMjhaTDFLt2PabgnLnuVzj9uT406PZIOaiboLmcKtBvJwC6sd374tqXaK7UaTryRCM6M8WPKVJy07hgQbOybnoa3FyfvkfEIzEIjsqlT4xsP4GW0VUrmBwRny1M4Zw4tRnBweN6sF1pbUO59AR8SjT1PcYaNxjt7caCEYywD2hiY7YwMBpdT0OzNfD9poLsSHZTxklIVAZiYfq4RvsSdZKMyXMek25nzn83BbUNUWXazwXMw0Ntj2hAsjnLZM9YA2wt2QPOIINQkLZIdJc2w9zfaVqU9Jco/RswzjGcYELblKj/VYj/XXXv9TiJl8rMd6rP/8q1VLiL6F4IZEYue0h9n5DHlBdzGQfndNqUayfU9kBlRSszvnxH7AilbQ6NSTLOjMnMZVxhOsL8iEZVWFM9haTwJsrFmtOmye0sgAYjQcho88sL06ktZrIrel9FpePljM6pbIrqleeYzRCvMwcTIjK4HPLeEL8wl3tYH8njz4FFtnJF7K5pOa9bUAw+M5kvvX31esknt+9/mSKz/nXxUFPz13+MdghpoLwqyJPC66kdBqXnopk9hLVcP7IIARlmPKqQ5YZrIFFs243LsdTuLGlWXplmRRyhRteOP9JX+v/ZJd9p4PUQNHSd1ypGyQtWFvK6xnqJ3hi83I5vOQH8Zr2qrju4cJvx54OD/Q72Q4ozgEPdEUEC1j2kXJxRtREGuSG59VC82lRylb81VDvIvp65Kidbh/nRPTM7mKO99xGa355OYPuPtzOVb3DOsdm199wvDpid3hwEKAhJeKTb/hfVNxfNejq2eMeYvtFFXYoBeCxktnEL9xKy42HTeftfiR5vuHD/SDMPM0Ju3xSfngafZRQV77BGOFUwNDsGBMFJ7qWbmJ8mgYZNEp9g+B8NPSmo7yqse9NFgWTBe3vNxY7GEiGyMeNic2teVqStjtbjlHmlQpdpuO7VnPz9lq1NyGDX4bw3gmUrI4nGjSYk4cpPUYZLNvPWwniXENtZUewNHbkWH6qIKQCMUw8+nHCp1W3NmSh79c8pfNkfVQcF8uif/RPZn3nP/tP/gv+eoPM548rTl64zxQ8KnRnsfDYeRfvi359X/zHV3xnnTQuJOhH2L+pXfHJ2nIzQ8Xc2LcbIEQh8L4m2cFb/yNhcHDzUl08rtmHjBIMqDYHWYQnASMTm62R7hBVAst0xTiOQ9rCpDkOrHCyzeug1nZ8lsbJii5WPwOHa0YhhoVVpgqwwQF5zbg7jByuU2pS8f70uGpE2EaMfpLgkD879ILrjh1hq4+kOSSZrD9GB84DAzakjorjESCSJGEMQtvSbQasBJ5InDHruPiIsUEK967gpjTPJWLlymRvDHDwPMLRWBGfnkb0vcrbHDERIaLLyWWMcBOCX4wEWchS+H1eRUPTUf7oCid4VeHA6XnSP2QUCRAQYD2RRwyMlQ9DDnbRYz/4kC7O3L3aid6cVa54dk2ItVy45tYbzf8/cgxlRXZwkdFawZJNjACEQlngB+jREwOvGlarlcZm2UIkvYw34ZGuqrlze5IV1iSRYAfCmxGpPcf4Xpifzi5iWBsUW1PLHmkbc9JJk+dTxqnqFSzqyt+dfeB3cMwS1lYNXPurhBlZUI1SDyOWZG0R/bOMJ5DVNOSLkeqbMDVPa7x6f2R4m5F/+YdbTBSacnq3eNP+ZxKUTcFgkkJNguiuKYLW6YZDhISph5+JFJ7sUtMHy0a6jxfkCoUm8MwJ1VY0ZvIaxRqLhZ/Fc5ZuZK12rk1ozrM0zwkm3W0jBV0Qlq1Pkq3qNpjdfEUpfZEKphhJcdmz2oZEpnFrLaIkoamVBwfSvKFDE3W+LXPcJALuyEJU+JNiM4MvlEEMlhQ/UdLiUrx8xQv8IjSFE9H+F5HFBhs1BGGiitf8nwbPhx2cwrHWC64VD4mdQTIexsy3R7IVhOqMIw6JZXY0WVGXVUUocOPvDnFRAZCcj+ToYaSDyEBdg5i8RkJxKOXJcS5Ir8JCY8T928q6jfTx/jSUW4eI3PupkBjnMO2AqOM5pvlIL4qgXt20PsDQa/mGMpgs8ar21lVYgdRnJz/vR5CHuux/qbUb7Px/zepC48xk4/1WI/1H7vK/h0XSUjpKuq2JXo20e5WYrWme7lnmawpCjj2NeF6Ig0v8IYGJ5siG9IsSzpSpvOG2A3otKBtGsZ2OfObtCkYXMKdVSRqZFIHquRM/O56Bl9fhZpuChinO5Lxgu8uJqrXDVXZ8ib3+LGX80+uc87JO9YEvFEDySTcM8WmC2mTJaekndPZHsyRr6aUJ/sF76qGsWzow4ZbPK68kOCJoy4H9m9KbvIQ8zSiOUBjPYpVz0miwkfN1qtne8Jp9PleVaz5wHN5HhXu2GxjlxhyHyWPYcNIUkbIjs+Njk10w8ZP2HzmceT9rN7Nao+3Xc1n6YJF8oyy7/iRv2C71azjDcU+o6o/0PcNZS/Pbh7HY4N64pEpH703FBL1l45k1wOjCakeLljWmovYcuwCioMjWB/pvm8Yg3FWoiZftnw+WR78NcsVXNiB68znXz0YmveQrfek1SckYcl9dURf+nxRXfInxYNgy/GnI70oHfwN067CBNd0x4CkORAlK8ZFzzduoPo6oJt2bJ/E/OBmiactXStL4QElA4TYUIlMv9dMfsG12LA7QzZKiobHcRgJ+wxxcDdTxXieOF/tuOgu+O7Jjs+PEbpu2LgVdXHk7EmMuwevetYV3FuDXZTUi5rfO2ypakddFdTXfBwQHb7nwpZcpyHRjSTtXeLEbi32clH8Tpp+OjE56XGF8TDRaksWRDPw0HMO343cngv+X79wfPjv/pz+swVFXVG97WhcR3e648v0p+h0zTFccb3QZNGSjnse3mn+9NsD/+Lnd7Svd9x7hhe5j6dbwlvF8K+O/LNVzCc3FU+DtfT8eJOokUUpYWeUwEczg6Qnyto+mGMipW+QkEhZ+irpQeRrtaQBxqjeoH09pwd61sfpeLZKaLH5y+rf83Gt/9sbJgRJB/UCIg3tSIzIryXOLkDVMV3Xsdcl52qkrRSJmTgLdDCJWJoQfTWRi1dDJmhDSG9X9C6bpUwi6egGzSpRXD0T8ISld6IOGDCd0BnL+cYTyoY2zzFDjRZZeiFMg45hDFnEEZeXC2KnUNGJJGiprUaUG9snAddfyIYHmt2COOtZbx0bPTCWFYezIbIZ4uqye0U5jcQrHxMHTKE/HyTbtjwcC47Tgq+++ozzdc5f/OkOZwZiNbJdKJa+hxWuwdTy7OmalcjMy0aYkzMvYIwdarBzusAsPXGapk3ZjQ3/i4uEKPLnJlqyG+Q82Nua7w8VxUlx5QY+v87I84ii6miUI/aEKtpTS8OYB2TEhMNE3w40ZUOdd+Qq5fb9jr/82T3VwRKYjzGeXngkNAGR79O4foZ2+C7ADBpVT5CLUmNJ+eGeyLumkpzgY4MbE1orUqmMsFWz7USdGlRYz5KvyEs4IbBNedfkA8Lh+wrtGzzJS418/GCcZVgS/xhHCZP2adq3s+XDV1uUX6MSN7Mk4mQgCDyKQhQtHVrgJCLRiWWjr2mSE8MY4x803Y3CncDPfTJ/IhBOTtVj5UNoiDhVwu4IWOZXtEXLw4OkFwRk+ohODbtCsy8LonPLss7xNorLlWKRKOLYx+sljtPg594ciRP7Gk+NBGFCHEhkZ8Ii0CxiTagavj4cWE3Ce6g5hj1PwpBM/ICTJhwC4iGgFaLsdGY95LOUTJgH/eqIVwy4TNQpS3Sr6Ae52cpAT2CKBWaUcy2c2Rc2HFHpxOVKUiBC3jz0c6zRpIS9IekS7TwEUTrGmRjfDYz1CRUoet1jTgM6jOUjAe3d09fJzPIwEt0qihHxlTzWYz3W/2RVCo9xkI/1WI/171OfbmP27sx06/AvM4bNN0JSIBClbHPB0dsxDiFtGqBWjukBIrFea8V57OkPEZM3sNCWwLuY6f3Sy/ZiT45q9C7mPJwJbYobI1J/wjUhsl0KY4OONMmx5iGeiHcjp3c91+VEnSrKUvG9svxXLzY0NuFZviEM/zXH9nd4+UXBPzh/wj/t77hLWv5ALMb9A81fJLzJFaW9J7sJcc7nrnJ8KCyXEmd51sSSnJYMVJnC1D5LsaJboWqFXLiKeFQsjDfL4h+E+iWLybDiic2ZnKXtGmJjGMYOP4gZRmnyfKwd5+fjQHlcL57xt23OGDVkfcrylPBZekOeHGi7F7OaVMUafwzYNWfiIOQiG/jpQ8lRbOQX0kgWVPcT7iiefcXgixLCoRcj06i5v+uJNzvKRcLibk34RPHZp5d0U8OLTFTfOZuvSn6sLiA886d/9i3JdMHKbOhqxcPmGy7dl6zXI+fbGldsuGsHTu8atMSV+yeUWtO2JYmkXyQGXcdzNLtXVJytotYBEYZx26H9moMsdudZxmlOoljUA70kwKkNox/j/B15Yam9kLfhiJ9YlEmpzIFaw6LUpHVA8p2eWW951HM1XXA/HekqTdIrou9iqosdyPNsOhAqNfMwPu+XDH3ObfdA6kLGfcb3quCoK7bFxH0FN3bFxdqxTles7Xa2rJyY0KrC9B6uDmfoo9jPe7H4G0epzryub/n2l5rvfnFPJbyPSnHW5azmaZ98wo++GHj+hc/7Ys+//mcJf/zZxO//YMf/4/SWd38S8u7rW4ZfDTwcS94FKeb3YgYCPtu1rN+XvHt34L7tuPGSecAhWuqPGhhZBsqVOoEkQ8ywRRksTLMFws0Gd8E8yDRL1r6ybBQ7hKDmZYggqAE3M9U+whp/o66Rr7Htb2+YEIcxbV3S1pZcPDlDgA0VuYowXkbPe87lxNLA4mrF2HY0tWI4F2L9J9wGZGHMchNQTprO2XmCyTChS0NmQoJ4woQB8eShVUPfV7R9iK/lAGrSC4P2RHIOV0k2v65d6xi7gSCLSSXb1gbUAsFoxAcUYZTh6acLsthwlEzNcSKSG8BKExSK21ZoqQn5JmDMPNapz9p5DMZhnCKcfLRpabuRN2ePo4PLK2mYDQXP0XFNGtaki4bDsaQeeoLlis1WEeQRvZAp5WZY1VS+2A8CBj3NW2OJnLnrepJ1zPX6Au1HDAJblIGSEweGQiuPfo4mgSReEsSGZBSmgpstEWuhn2o1T+qqvqc+V0xC7J/EV9TjnS13rx94/22F6x8IFo5gdUmj1ExM9cOELHjAjiVVlZL5PmPo4UIxYkwcHxqeBTku/YBgEcQKITd2p9OP0I5RfDgNQdDTdT6tMqi2YKgGAiOKkpE0UwxiU5j9HcIEkCMnm3YJfkzmDOJa/HNKMmk9tBZ/3jRPLcWr1nYhTinixURzFHvHOKsftNww/YmwjjAL+ftEMDXR9QXleWCVCSHTkk8jgdNzfKL40NLQ0FsoziLrD1msB0yScxGJV02id3uqh4q2E59bQhoYlsuMrhRJkyUc7Swb6iUqyHk0MrkcC7xoQZhM+HrkIltyM+McPw4BhoXH7bGevUwkErU54hl/jr8RydQ6HDAnj23YYxvFaFN0NOGHDusrdoMVZ+IM4TSd8CdkKCMZuIrCMzSjyJvk/XX4eU80xLQSbVN3KFkdmJn4gaoNVjgfaiTKNcqu8XofT+76Qs1tFzNgcpDYpskSi+ex3f7//QDyWI/1N6X+Q6gS/kN9/8d6rMd6rP9fatEMczNFt5yVwPHdM2rBVVvhayl20zjHfgdhjd96czy5Ee7StmHY93j1EuXV2NTNnngvUIS1ZN4fUDZmyiI0Jeswoo/gYorozxOn0Eq0FX7TMvYiyFdEuqf8MLD5dEV8eeT64opMJ/yv/jjmn339I372dc0fXySEX7Z4V5ISYan3R6LTxfzcsy1WNIXHrX9EdZqlMjPTy1YlXRkRVyE38gy6MLNi1jQ9y0s3K3/Hk2ysU1KR2nctXXOmcxF21c18raI+c5tEtGM9q2xt1HNICl4Mn9JOHfHo0UrKgTRGHtjesSXFiCcj9fh980N8I8qKWzJGKtWy7FdM1pJFA5PvE7mIrS4ZvB5zbalOCfWho3PvycKIbFxjBBqZgpc37OzIeB55vgyJl9Osur78uwn+62x+jn31NsR94ri43nN58PmwXeB+XXKhfH7vj1PeFTcUhU/6dOBoHcX7kVfxLe/uCjg9Y3jS4fqeZKrRqydzgx0XCS5uOOkUVbfo1TQDIkUwn6dbWn+SvTSuF79+Tyg2mFg02d68BBwbTW9zjDmxzxtiSfIwijjy2WcdT2Rb7iz9QTGmii9u1/Rjzb3dQ/dkfg8j/0zTLedo0UPpiPxsbo5FTfH+PLLLW/whIXjfc44tXioKg4FjHTL0Aw/NHZfLjqfSu3Qtg1fN6XTWTfQSXy+cOFn/unHmCpZdwNd/NvHqfQzvHebFBf3hTHMZM8QJOir45EVE/mLF62Ki6lte/mrHz8YPfP3zieLVK653E9ujnLP+HJnaSYjA8zX7vmNzX/IsGLmJpLcQCGXAJOlw86BATiY7949KyYBAXA4f8YxOegdRLYgtYhKFgp1tG5LUpsQCLUR2+dWpxQn7cvKZfIs32yMGJmH4/baGCVMvNH7whMngOZLIMk0daRATJ5bdkGInS5rmeFHK4f2evleUx5YhVuSBRFN480l8kSa0zRmvPdNHi9lusPAPeJIbW/mc+hQXG2I5Id3HzXXirXhyZTntQg4qYxP09EFPZhdoW5FpjTYxndXc3g3c7i7mvNMktnAuONUeh1Z88D55rgmEhSCtbpewCsRmkaGSjM8uPZbW45tSPOMTgSfxLobCXaCSmEwtaceJppeIRpntpCSJTxz4tFXLoWjY6gVF0OIrzRT4KOEXCNivdRiBydge7QW0Rc2hG/jx0wVplqBmLkDL6Hfzn1n5Cb9zfcFmmNjKtjsXmZXFakMmx0KSV4XrEHmsfJ/ENxwQSCXIdCFQso2veHl/ojmdCQJREHhzGoPXJNI1c7jtCeOQQCI6EdjJmrMdaQvHEBfz8RrFt5a1JOGWqtrMU9i6qDiEG6b9SK89lumWNHUM0UB7aBjGkfUiIjQd8WqiKUXe5M+DhKGTOBONJ3GQY4fqgplYK9MwNwqn4SMMJDA9bkppi45IgIY6pRYwozYYp1lcSDrEmfaQUyVHAuEb+CFmOKOba4ruTB80NPqKS0/gkUIp0diqmJUnCnlNNcW4YDEacq8nWwXzh8/7UIYUHgsjN4AWf6MRfZoR4q9y9Icj0XpNnklyyUg7DMS2nwnEVdjRKsUylazWHNVNRFo+XBtGlVH5DZ6rWDu5VVgmI1GQAWXzwFI7Vl1COfmklVwvbk7dSPKYu7HmWLfY0dCJImGeU8nkUGJDM8b+xFCKJWRAmXG+oUR6NVsiRlXPIEx31nMUp4oUth0IylzSltBjhWdldnmB8zqmQc2bAK1bXLx8fOp6rMf6ay4ZHvy7LA5/VaXCoyrhsR7rsf5969gMZH7MeRXQ3LxhUX3Kk/PAy/Qs2t0ZrtieQ/w4J6/amRc2NIooDok9NfvTJ9H/Vh4194RdgutkQ2oJe59+25HEhrDzqYaevdiArSzFPJrKYoa3WPPJ/Ew3lhLcpvmjH214/uyK63xFNBiebxtWbcKrX7xlOq/4r3684LbtZ0igWFnTb1I+rO5Zj1umxYCWZIY6pLp3LCR5Plxg6ohFNvH3F1v+oon5en/HpVvzB08/53Z64BffvcEWJ/rJ8H7s6YKeUJadXT4PPJL4xLshpDlaNmGCE5p+5M/WhMZWjNoS+tIPiRW7wsPnfm9Q0WviMJufc9uuwpkb2q6gscNsIWnHhjgKaaaOY9sRej5JN5HKXtWYWeWtkwXmemIhPIJjyOBGsrhlugw5FSvGRnFctITHhKsn4xzh/tD1+O2O87uJd13HHwyWZ9uU82KgCSbya5/LTzLcX97w8PrP2J2WPFQlbVZTVSWB+SHwHeosivgr3GGkk3SD+jinUdg8I1eSduBzrGvMneaHP+jxQ0sh+8AhxowrVCrpAhX9dD8vD60KOS17Ui3sswA9ZnR5z4tuwW10xyE/8qJ6wqvkjsR4XJUJQ31k2Ye4seaDKEjWJ7zzFZ26p+rdzJ1Las2HooNmT3AR4Frh4QWMyzMLF5E5RbkI5uS8Zmo5Fz73fECVFU4g9KuAiyggnDyyyuCWej7Gh3NBed/xzdcerXfE5TkUhi4ZGM8bnJnwG8X7eqI+HXlYNtycLadq5J/8dx2fnh3P72s+DQLU9MAna8mZW/P124lh0XCuPDZBxo+/DLhcrWGKcaOkNcgzgGxo1dwbfYx1VHi+LAi7eRDwsU8Y5/f140OBpDpoaR1mm4RCuHfSHon1OZqTITBiT5KIV4P3V1An/9XTHA4N6SpjuQ7oy2m2HNDE9CpiGxwZrGacIk61xps66jGkU91M5pcmuSoF+rYniSSqL0axYCgOjLSwSrDOZ2qDmSpobQ1FwslKYkNPHkISRCwCQ2kUfTHR5rLBHliIuMMZXKU/pgbImzjWNEOMnioSNXD/VgB0HegEtfHQUY4bPIZyIGrU7Ifps4DnYcYnec7CxDxM9zw4y6CGWYXh6yVfPN9izZJfNz7+cc+L8MSH+MRSoHw2YbQTnW9nYOKH3mfzMLK+EoDIyBCYOWJPvC2+SE5Uw4fdRBhpnq9DSQaZ7Q9u6FGSGeocOjBcb3KWjPieRsnafJowvsFMwgJoGAW4YSQOMJgbQNEC+PmCVIYrveXnd2e+v2+ZmmYGIU5eTHWUm8fEemM4FD3n2hKtDZvlMLMkxrGgK2J8f+RynXFqd2zCGE9SOcwwp3rE2ZFDL6kU4Rwl4ruENBvxgpq73TgPdpRn8QOHZxPsqLDegLA2ZfMdSm8+9rTOIwh8UmdmVUCr+3lTXwkUJJKonZ7IlYTKQ40yTxNJnEAxM8LBMehIuIRzRmwpgSkTJCNkUUNlDIGoSlzIw23LTTigNim2s6RZyDqT885Suwi/qTgLdLMNif2QxdbSFe089ElCj40og3x/VuI0Y8n50KKHkMlp0tDi+THLIMIbJs5Wzn9F7gTe6GhG4U440oVChAnG1ugwoy1HOl2TuJi2m+YbaTXmGLEcDBVWgJMuYONLVnFKan1eSwRQKsqWkaqr6cRLJnYjz6OvZUI90R4EMNrg6RCtN7ikxtnTHNXJRjNVwXzeyGsROk87AAChTklEQVSd9D1NJ7BO4UEojD8wijUkWBCpmlY388DmsR7rsf4dn4+/ZdXAv/l+/7bv+8hTeKzHeqy/zjr8MCT615r1sqZer+hOlkyP+BJLrQJ8pxl6DauIXoj2o4bIoMYGF9SEY0Y/RoxOnkcDqtJRK4m9XqBagZoH+GtFbRrSMpitoWOo8csA3oPNAupypFk5YpXyhy8Mf/eTa0wWYsKKr7/ec040n38W8L/5+ynfvF5RxS2/futx/m5i6W+woqT2j0Sd4kE7NkOOFdhe/4A+XhMOJ86ngV2T8dknCVcXIa9qx2KZ8eJmzU0ScFeU/OJUQGqwVYiRXUvkGO9j+rybl5vDw5kxDsl1Myd+5UWClWcsZIgw0Y2vMPo5fS/NWo+dYrx+pHP1vMTph3oGU4qs30w9ouEdVctJt9ih4+2x4N2HFqd7rq4jbFbgxWqOcg/aE6XtaRtN8aua7XtHvs4ZA5/vHnaMpxr/dqCvDQ81VHXNtQpJ0om7nxm+24Qk7R3T5oajveX7P3F0f+uBn/zY409+6ijfrqj37/A2azafCUD/wPE+oY19BpHXhw9zH1bat/j+ala3RhIrv/+4DZeV1ake2HYhKzSSAnrW/cweSIuJ0EnC38jK05TJxCRpepWiWsvCs6RqPC7OCXfZyJetjxliovCOuv7bGLtDm2vK4qdU4ROScYtb7tmXDq1DSnsgvL+c2WrO7EnUmm7VEnoLuk1B2nsMO7FglyR+gDIelV/zIRjmBl0VFlfvuQsjLsacy1H6xYD9WPCy3PH+zx1v2j2L1MN5F9iHGvt8RdgeaM2S/hTx/cNEWT3QpQnFuabqR7Y/PfMsm7g6R/iLlimu8In4L5YdD288mmnk8onhq3/4OZ/8rQQlHAqBivaSFNKjnCxq/RmyqGRwN3MURIEwfoyGlARF6Z20KJg/khPEfuRNkhjooVSHEjaCLHylo5ta1OjP7ARlRYn+WxwmBPqKTXYmWeR0+si+yfEzzai7+eJznrg6YuHyo2xDIhEjUTTDFCXEo5cYlaGf0wWi1MckMeez5Mvu57iO2tvQe3Y+oRdupKtrzt1E63uE6UDXe9zdKXonXHtL0y+JpyOROs8naFXp2R9+4YfkK9Cv9wyeJci8GUKyNJpgEcMiYKWXeH3N3b6b5Vi+J7KlkXTjsVtMnGWC43vkPfgC1fAcwXQm1RGezng9N7cln18KCLEj8N18sD0M6zwkijVBoGdLhR0HSXpkVB6T/1EqEvo+VVWzaxVfPIlZ5pvZPyWTI+tJRmz4P1BgJyHTCEl36plK+SqPJBEISMcHf+TLqw0vopBfv37Dy9dnMhNzdbPg5nJBeSp4OLccjhWMBdZFDLVIdEoGAeB0y492AtMQsMEpj6Fv0XlMrHJCEaMIvKM/M52W7IeKKfRI45DFVTrbRJzx55sWwp8Y7Owrk4SNNJE5mcBNJvrSzVItUSPkEUyBTM7kxA1xcoH60sRKAy2JDh1m7OdJd+fmcATCVKZwEj9TM03NnAwRxgnWFrTdgjq8l0habLikbiayRUowFqj4GVF6xq+l4V5ixwYtVGAtaiDLtLQzubZsJ6x/pmwTOgFa2ppszlftuDu0XNiE51cBZhVhx4xc4k9FRNIpemuJjMfCLSHwKdT9rFJwdsXoCtwkoBOhrDq57nHjHpNdE9iOs4VOWBKt2DgaMuWom3JW+vjyoTNVdGpgNaX0vcW0AS/MNTaouO9b7nrFSbJuQ7EFia2ooqpl2ixwGI11Hr2oEWSO5haMY4dnEqbkiD9HFYltxREcPSZTM41LRgG52HFO+uh7YZJ8HAQ91mM91mM91mM91t/MylxE0a2IFr/E+/A5cbuj3sRkJ0u4cpQuRV0X85KjySzRjTSOOU4a28iKi5K2ks18g68jhtkDoFF+xCTi9n4AeZZMZCnlmEyGdQWJANlHuJd4vl7zSZ3y7NlTvrxYEUY5/2L/M1Z9y9vXFf+SFf/HzzTd9YYX0w13/F+Jvt6SmyPmTlGszlzEF3Pctixn/Cgi8yoUMeXbCdW5ean0pz+t8eJ7tNnwNMlZi90UiYh0JBJnOU7koc8zE1MGI/eXGaWDaCzQp4DRKn6pa1anJ1xvI8xk6dVAGi7mlIbeNjN0fLZCaJ986fCGDZUrGKbuIypvGkmiNYHwFSbhTISzDF106K1vOe8aslwAeY74RvPi85FpP1GVKeVY0E415R307yN++HcGbhYHfn2wdK9rjsXHhVaYLTnva/yNPGff8EX6ge+zJTyoOcFO4N/fvrP4heO//t/3/IO//cf8ty9L3pUeRm9Y/4FG/apmnzyZuWkrHXBWC3TBzJrQ0gNm4LolddHOkvwsDPFsRNBGGCHza0Ul/UmviANhq3m4NiYUC4TvUYbFDHKPJkPS+Nx5JxYPl8Sp5XwQRoOb4ywf/IrzcEstHLdzjXnq0Q2ioFfUh4hgkt7Apxz2lC4iFdrAMaRa3RF4oiBWDMIik/e6dXQXASkCdLRMg/0I+V/5lMuevUj0y47e89iPLQcq3jclP3+ZMiUe4+RRPxQzc8zdNqhIEtJqxqKnea/4xbs1a7Phl3cPpMrx40XJi7Mo8IW9FmKSCDs95fXpVxT9gj/88e/wR//LlJ98kbLerOfIdyXXzmxhEJuDdIsyNBA7g5r/ncGnQzwr2IVn5wRcP/eVMlAQL4QkPnxUI8g5Jf3r/P+MCK5RFAvintBIWl382xsm+MsMzXmelnieIvRjknXDylhO7z9GdYTJGeXlJEEMa8GXhgRWEQx29qlLhmXo5+TZAh05gqSl20scjKFzDdY2TPMUZEEVnNFWpiRqlt2XtdykQsxFghHZ9n1FF024ZCBpA2zdcXL+PIzohw7PC7i6jPjkSTiTV1eTw4tH9HLJahXSjQ/clTVX3ZI897C652At3e2JeqgJm4in/oJIhhAiIepH+vqOtt1hDz1B2zHmNYtaY8899VgQhAsuFzJMCEiiCWsEYuFhrRw6QxTa2X+iW4994ZFklk8v14QmwwmIb54qCZylmd8TKzaGYaC1I9XQUBxrEkmkGPy5Ad8k6cx4aJqKh3fv+dVfvqYdEz7/nRs+swn7Y8XLN6+ge4sfy6nmcG1P4PX0kU8znDHaEuc5oRfNg4tpNGiZcB563JjTBSKxF+nLkuH8Dnf250HGcP0p26ctB6/ETBPab7Fzzm6C1j6Bf2ZAhjw+sa7Q8nN714ShpTeiHJGTXWwQPZI6IvGFtSoZpTfWEWK1m+LVDDn0Cag7EfLkLNc7lJARtBynkWY/0UcaVbo54qRnpB9HEuEv+IahlzzdM8la5P4azhV6yOh6mY/uKfsUYwz+MsBKd60skR6w4qHrB4q395zfJVwGT3i2XvB69Dl7MrsTFoKH50s0p7y3AxL20VPjKX/+sKyGE6YX1ciITSeibo2VYUNkCGrJljWEPGGadrRJTCSNf69pomrmGEgKhlWaUyPfv8FK9FC0QCufdirZn1r6qmXcgA5rGklwECiMU0xKXqH4n0q8KZrvMbPMyetxTmP0x5hNbzIEG+hHD9XKsZUPd4N36mi1xm98dP5Xvk081mM91n+E+rfZIR4tDo/1WI/126jNu5z95zXR9wn74B1R7xhNSuxpCSYjMA36eUf9nUT6WYJYllAjakjm58xOtxS9mu23i6GnNRJbLouzZt6qx42jr5t56TJeWaJ+Q1Qo4vVIGyvKYSDIHVdhxCeLFQ/lhN694dftL9maS9YXE98PD/zffhnz8/Alf/flgnM90TcWPzvRFiHG62htxmktsDm4Ezn+6NNbWawVhOIl3iWcvqu4v2jxr86sb1L0FLL/sEcXFkFxfRZAMliuEssmuCBeXPGBhs1LR5KbuZcYupY3B8Nq2c/NXChQ+rqjdz2+d0lPxWA/WsVl+YMkvImPXZpWgaonDVqvZuW02BrSICfvQ8qhJVbDzIFzkVDlR7IwYAwCTrqncRJZ2BN6EtF4RdOIv//A9RPNUk8zK0xPW+InAZ9eizViSxeeGOqUrz7TvFUdsV6wwHKYnvC6fqB7H1L1K7ae4+lnA7tgweZyoqlKmsaniwbCoSZ4FqDvr+blsr8Si7SjPw+IKHYUHljtzRZq7MQwjRw7y+BL8+thmgTrtbR6pAw8JEhsYQxN7/C8iRd1jvNjPvg1tvCI2pHWDnQXE93wMentbhzwHjo8l7HGoytfY8dn1OZM8RBwuYHueEAFz+aodhmaKOMTBTWjsCCECZeFeKM3g/PP/kh/HIiKCRV7EIRs8fH7Hm0V96bA7YRhltB8yDhGPmmwJNAV5Q8U/smgwpG+uSbL3rDfx0yN4WevFb9n/owP73KS5MwfXCwwoiZGE3sRVWt4sxj5R79Y8eUfX/K//j98zhe/vyJ0HWMtC77kNxwEwc+lH1fPXjcjE6XnFIL/vIcWLof0fSL7lq8VZYJYFpwo+RVOlAfyFZOPmsYZayexnPKrEjGpJDJ0jpGf193/zvordwnab2gk2rApMMMFC9VzuYjRfcVJGAKNY4xa0jYhjQPc2qNuPUzp5otZLwQeIrCRgXZoSbTcfCaGyNAULZVtyWQgYVOShYf1V5JYgl6KvwgaXzEIiKLrmOoRbzoTrUZcdDlT/2GHbRMagTh2KS82Kdc3lm0U0HcR9fktqhzwl45c91SnAEdLP0186Azh1LOqWjyRZgnJUvcMEk9j5dBExErTqQMP5TuOpxJPO/p+wvdjtAwNWjvbEiS+BLMAIX6GIWHVM6TiUxebgjTNMJx7yrrn+mnGar2YJ4sywhIZP4PYIuRak8a4n4GOMt2SqD9RGNik59wZnl5u+Mz3+PDLX/Enf/4tL7/bc/t2TzvBuW349p3H/f7Iu9cFvjTuSY7uh9lj44uMPtA43ZAEa9K1j5mgX/TE9ZLeb7DRgNf2+Gtpzid0L42vDHUcbvGRe+BtxE4TzEqMPNS0Q8UQ+1xGK/p6pLKGKY9IJcmiqT5G4uiAvm3pyzOhUYRJjIv9WXZvmm62QDCGhLLdlwhOLFEsgMRE2nTCYEt159Mcenq5ZuwO3ySYiw4r5xUt9b3BX2tSyUs9pwyuY6jPFF6IJxecRKFoTX+Eo3fGZDnBKkJHAlnxsH1E0Tccy5HqaKiKlq83B8wqoMRnp1oibYiFLqwmYkkMlSt3VHKbQQmQkYaWihAZlIk9RZIs5ENDolV3TC6dj+tqgooCEXx5vlh2UmSiIikLcqw853M/FCTOYCReKTjPEqZ92bN71dGKxeNYMEUF1d4wteIz7BkG+XQf8eSmYUZGUenYRqQRoGJs73+8qUisk0xZ7QKykKH+gM8F5twyPu0ZzhOrx1nCYz3Wv7X+usGI/64Bwf/n7z0CGx/rsR7rt1V+LjC21yTNNcvFK5r9gnHXyOMI6d5n+MGBYLzE9xxt088pAiorsc2ELxbmOiH0WpKFmZ+ZQDbwYvvsmLqUqV3gewfIhU8fMLkTRwVR2TIlPtdO4y8M1arioX7gH39/x+9FDT+5eMbUB6w+9fhRU/N/f/tAfHvPL379PTrRTDc9yypnXBpieYbSmka2sn3LORBlwBbtdSwvC6Zeoss98rFluA1nOPrmamK3q3n77ZnMaWL/kieXivu+Zzd4fJparuqRsTkTJYYwStBvFeu6og/OFNNE3vv4TlGFA9MxozE7MpMTx6uPKXNDxSq8YCCZ4wXFRj761aygFdjfaHu6oWSvC149FB9TG1LNgwrwip60GdkXIXu/oOtOTEVAtNIsPpH+Swj9jkZfsHl64Ly7wrFhFTvwTyTbBH2McFNHm6+4Omu2V8McGR77Pfqt4+VG893PWh6a/57KJAR5SHzVsP8uoC0Lkng1J4AdbYW6aogTR/u+o48iugefYHIE2YQOc6bOcWhKdgJFjxxDIKw0iVWEsg1pfItLKvpoxVIWmqeRxu85JiVx5XFFyk4wjmOGWZ45ZT7xNwo7eSzZUL3ZUiV3LNtOHvDxhfeWhVSnmGOxIz5e4H3pMIUsHRU2zOmTjkhS4jpD9bSfrSU3R0Uff2R9GDdSTwlBHWOsZYwm6lBztK2wQYkPjmqI8J5BkI9Ei4jtco0ZWrTNcbXFu9rgAuh3Le9OO9Q//YD5ZMO3dwe+ff6MbBPyaZ+zbx745wfF3io2X13yv/sHP+HLHy9JTEJ3XjL1MIsMGGfbvFwteJX4xkHUQXJRSRM50+TF0iCgSjcPqT6mOiiE8y/wxZldJwoHgY9S4smf9/RvYiSHmesx2RDlyzby311/5TYhF3+QJ1yDD1iBvUkcxiFm0JaTBNK3hsxmZEtD15ZMtp/TEPwpROcKtbT0o8jCpZmThsbM29961LT9eZaeS2MahmqObtTNEiNU2FTiL1p8k+EFIh85ES6imcq5WApd0yeRzXDqz6C5IAxYb56TCjU2Hwg3KXmt+K4YaXaG1bplWwiaIWG7HdC5SMENiS+RfT1TqJiMj3Yi45HG3sMJ1dILiaaMNKm5uvSJ/YnbdzXSj9nIozcxaSB5qQal/LlhTYye4zOtpwj8HmuE5xDw0DV0duJmmxHJWl5AjVM3x3RYIeKKvEjoAFZOFkevJ47nepbPBxPzjTrcNXRnx5/++R2/+IsPFK34raTZtpzvj7x623PYnzF9TLBeoIKSfgzm2FE/SWZiaT0sGXXOMO7oqg4/llv4wDgq4u3lzB+Qu371PkU15ezFibeGcLOcfVme3MDjJaOZSL0AXU/o0RHmHcOkSWphQkhObDRHQXpmmCfUkkwiJ7s0734eYbVmGgRSmIEMrVqRhEmaxZmuFUVJivHFm7VHTRJ3aGmmaabv+smEniR5oBZs7SwjCp1BHCHqVJLFMZH3BBufZRiK6xOU2A+URlwnKmSWP6lGY7wRp1vGIGasypmtYLwEb2p4fbqne18TBkt05pOGAq30CcaewUWMNmDsCxnrYQdDx26+WIdoIlyO6C6mFKldnc43hcQogtSh+gLdx6TjwCjeCbHNyDWuFjiJdZSbhZtoTI0SGGJvKIeGhweBig50kp5Ri+QqwO96UplWztPJZpbuTW2Ocw/oyMC0QAlTJJIElfnNYAri35Baoxl4iczBzg1TvMCFb7HLBYvl/7jE6bEe67H+06pHVcJjPdZj/bYqXXSEL0NKVbHqPuP07B3+bUyTBPLYwOjFdAdDONYkV2JrNrgb6O8Utunw/A0X0UjiV7gwI2ock/QUqVhloXITF74wquJ58XZGcfQrbkhZ+BKxrWDZcls8UFUeZX/GrBUXywXDQ40YPH9n+YRz+1PSV19R9icav+WSC6ow58LdcnQxUd1xEWe8H49EiT8/32+1x7gLUI0kd00sw57TnUK/1nx1kzMkFT/9tqd7gJuLku3zaU4CK2rNLjwQvldExQl/Uc6LmUBiLyOfbTgSmmgGjY8qwt8k7N4osmSYl0xhIrJ+KKcj2bgiMtHcW0UmYxxixmGcrc1eO1Lqhl1c8X3XkpiQNBipWkUjUO2oI0hHLiKP46uIh3PEcOHIlnZWLJR1yOm+48k2hh+mHJMRV3tznOW+e8MX7hMOYcf748B1BHcEHO/eM3oFHBbQBPzzf1QR/aBEPc0Zfc3Q9OgsJSkhWyU0bY8trlDpa7KkZghT3NnDdTUmSojcijrw5wS82rc0nsN4QlwLiKYBP6jpPDG8SALbR47eu+BMPE7z4vCd7vGt4lLsxZklqA1NYri0Mfuhp4oOGNsyngzDpqA/3TBdpYxTy+K8AtOyk6jOTy4w62pm9Kmwx7MjXWNJWo1v+M17bmcL8+hChsVyjrGzfU+RnOilZ9CWoR2JJDo0jRlKR7tp2bwISFKNL0D9VqPyEFe8x+jL2cq9/iKkXbzh9fc73Hcrrq6+48pbc8gaDtELfrC3/D/vLN/XA589X/EH/zPFMQ14/bblOpIkNoUOK0Ity3DJxZhJ/DhhHsimeo6KFBWBLBXkvRVO34xkFK8zno1nFfysSLDCVhjmX3fCUJNBg5OvEVVCOHMGncAbJUFxbgZ/S8OELJAmN6GxIYVrObYiAa9ZvbAEEjeSZ2xWMUNoeX/uZjlLInn2ApTMPdIpoOjNvDVPZ5aDRxT6XGQ+hcikpoJAa6wOKSZ/zgNdpnqWWu8bmZPAdmWJowVmTAgXG9RUchQzgAeL1Q2+BNVoj2RleNX7hK7l82c+SRNyd9jQn31y09B7mig0bPKIzmQIAWSVZgQSBxlMeL7GCA01CGa7hEw6nBlwncciysjSkMHCrTcytWdsq8jzhHUGvY1hKubUiFFkI5E/N9ZazP+6YTwM3Fcd21XIVZyhxI+uZXIoUySBSs6yBAZvwtiA0AycR+FHjMg/FoM9n/jVywdOJ8O7DyWDgCrlTTUDyoazJWJo7wk6ObwGE1QYuRkbH890RP4BLW3nGM3cgaY5MxYLUt+j1j0SzhKtF5hmpHJiU1BM6QY79OTaI1prFu6asf7A0NYEavnxnA5SQjq0WAXSmGI6MchdoBUbiUQIBSRWs8gNQbSagSEih5qb5nGY22Dby/vuEeRLAoknHEX61s3T2dVqRSVgwsCRfZrMJ313FB9ZRXVX4scxjZciIQqx61Bthn9pCFUPmcGWjsbJRC4l8hReUcw2gt41KOvNSSDZImCdiiUlpGoi2qLAF9tD53H+Xs5lx+Z5j6+l0b9gmOJ50qolMkbX9FXEsOg/RpDaa0aJ5wlqzCDwIBkHNgQyLcxT0smfUz+W44WIMfDEpuF3GOMR2AEn75luuXBrKu9MZ0QlYjgPI8ep5+RKjMpJ/GiOf5G02VZkfVgGp2XwP0+LfYFPyKBKBnKTAEXrj14ueV8qsWpIhuwSvx2YYkmnKBg3W0KTMmYBWlIwHuuxHus/aVXCYz3WYz3Wf6gancCiN+xo2BYJ3nNhHCzwjceH/BXZqwuOwYGL5GKOUmydJThJAxRAeMAsSoIxnpcz+COqcZT9hG4FbK2phdPkIpwLaaeWrg5m+4S6DjgZRVNm7Mc3ZPeGfVeSlZqTsrzsv+Gz3ZbD4o6bRUb26y3frmqypc/tbiKSv14J38xRj47UO+P5GWsVsHIhhypG2OKevSDcupmVFntL3tUdD6+PpM9yrvJrbhaOX58euO/uOZ9lL5eQWPGVrzAmYhVNc0qdO4uK+3uGYsnkJHVhw7GtiDJN8Fb8/WIvjtCupR2KWQkRhgnd2GIEJm9H9t0OXwl4rKMzA8dqR5Yvic7ytXa2zbZVjWsFXL6ixyfLWrarCz48TNwfD7g7SYCLOe4GPuxaNqnmeZKx+OKEbgPevdR0pwjUG/hkpD2dKCrLs3TLvfctp9cexXcxreq4XqfU0Ylgk3P51YK3f16yCBVR1lMdUgZbYnRIGFZU1RrJqJDnadNBtIoJkz1jH9AP6dywe7nBjwKyIqaLW9pEozvDqEQVYAg6j8F03OYdLySy0Q6kH0JuVctlrUg3wgKz7D3DRV3xatmyHHxeltBv9qy9mCYQi7rjFFV03ZLu/kjwwpKsO/TOo/MFrD8yvt2jU02WXxJGLYeqIejS+fn7EDc4r2UlTLRI06wKFlVK2moegpbVKZkTBd+teqLNR5u9kv51NLRpBx8CmjjABDnescWoiOTv5CzWDafTSHQ7sd0Ix+2OYv8Zv9p/w9e7BV/9IGTzD0OiMOb7D3e0J8c30QqnU374VTUfI096D8bfPIjI8vGjqn7mIsj5PjMUBARpcWr8zZDByL7z44Bgzo4cZjuE9GCaFb1XY2TRL327Nox6RE/9zLb7rQ0TmnNPtlnQ9eLVaIlFUaESwtqxDGLSyw15XtNaZjlJY0Z83VLe3WOP23mTG/kdZ4nHaxXWGOKNJfEVQQDHYl7x/2ZTruesy6vII/AU7cEjEP+MlxPIBlhiKcOJ6U7etxaXBLSuonU+W7mBBT2enggGH6+ayF2IvOp6Oc4XdKMmgsiwii7IZeKiWpJJLBYy2RG5TUekDMkYYXqhYGoGUzM2drYy7W3Dy7uS3bGehyJT5NgEI366kpcDMuV0Po2x9DJ1CH1C5ILQnAWQ1498erklMsmcTsAgtg3J+xR6v0T2dThRpihpUg2l8BT8kNBUDHVLVRe8uu25+zDMHn0jhFfrzR4Yrdr55jMYg5ckeGIhsPKvR7Sw+L5spnMSIavIydRqtB+iotUM6DuVcvM7zpOq7agItE+6WoDxuL24Ij6VGHOmbFK673Y0g1gcFBdXI2Wf4HuGYNJECRxbDaXsvOV1NNQiw5GBgrIEuWXqgjnFQD50BHY4yMSxjlnEDhFPBPkCP/aouwIlihEvnBUUkXdiGa+Ygo5j6bivK/SU0w0x8YWkjBR405ZGdyTllmhbEnVXNK6mGs5Mkwx8FMWuZCiE0tpjtPi1HOtDRGQDoq2AThZQC6DSzTeY8n2P39Qslym+nxGOjsbK8Wo/SpvinMi3xKFCp2tMM9F5LbZdfBxGWY9YJk7qPZMLqGsLUUQfiocuQFJMY2nmhacSytS+nnkbnSsZ3YAvr1skS4MwgeN5ECPT4cFEeEIUMtMMelST+LnkQ3nAmBovyphMM99m5JsLTWHSEaP6yHoQmSKtJLOAbU5oCScOzrO3UQU9o2TzPtZjPdZjPdZjPdbfyOoOKWlece9fYL035Jml6jXj94b6BhYCe/MHWmWZLkbs3kOf9/TTmjCRhdwDVXtDJ1v74MwQBtTNyOqkuL7MKeOeppww3oAnj82MFJuQB1ty8kJSN/F8n7AaUt6XNWmRcrsv6O6e806JEkDz/lXFy4OGdU0fbnnOiqrYEwaa972b7Zs2STh1DXlzhc4GJEpNkHPTYmSShrZq2Iva00AxRvyLr9/we1+tefpsifUbXu572tJwE0p71rOKQ7YXK74+nCneRTwIkLGMqYU9MMa8mJWmCbXEPT4kpDc9k5EJR835tMFPzqz0RzDjwfV4ZUvNhLZiGXcUxs7bb+sUnrNcDjEf1idOMVQPI9mqoRTbrlex2Th0Lg3gibHxOMvTnidL2hN37zf0yxM3GPKXjvLcUdw7LtOM89VA1NbEv3vBYdCsXsV8fyuPye28vQ/Hl7TP/xD35A61PnB5dUO+6ZiqiTqYKArL4knP8DBg3YbRacZi4vLTidXvLDi+7il/XRC2AZvPshl4P6iKThr+QdHIYs16JLUouy1nIzZrj6DwOAvLoIlRtWOTyvJ9glPAsVOSV8qfJr+iZ0vIgpVb81IfCTtNtnVUb2LMTU87lPSSxjbUDLcLWnNLmORY12HVxGRj1uIyF76Z1xGrhEXsSWsGUyi0TigCVrs1SjXz4Isoww89enk8XifERs+vsdP3ZG04A969ZMIUPuHne+pMEW8Mry7fc33xBfm+4uEXcPjZDq7OuPotP3/dk75IyH5vYrpy6MbxqTiE+iPfv5rYeYrNc5+nnqS/SU+hZ7W2J2wDb5qVzNKTqjlWWtTaAZ6S7lOhBHqvxbog9dFOP/luhpoK7U2S7cQKIQtrAS+Ool6YZKF+nq0Ov71oyCGm7yrKriU3A5eXMAY5adQwifxgNIh7QSQiWZqyDIY5mq7+UFC2Z6rSECQBTqLspoFMS8aDxJMEZENEEAfU4ivXhkh7TIEwCzLiKeImmj76OMaKxvb0xuKdb4ndBZlMNlce1Iqx7Tg6j8ivZ09+ZyT781OG1S2hbiHO8eIAPwjovZaJS1K35zDNmAky7Uhnfb2HJ3mdw0RjW3wB7UksYeNo+o7doed0O+IPEUPcEycQi4oh0pjcEUrixGSZxO4g3AFTo50/e3rK1rJeabaX65mxIL8m1pXBTXL8ZkjlpLXkX2AFNFlZyqYikHgUk8wcBxfKjUgmokfGbmCcYwIaJpczhR1OF6gxRwUTQWIZppDOjihrMb5gVTL8eIerOyaJD2wEvtESqJo+ueJwaFClZvk0nOMLp3TBZVYQbnOq25HqXcT94cxQ+LRDwy6zZCu5iUiUjZmb2raF8RwSDz4u9PAjjzzVhAQzuMSNI4M3Yk3AIlZ4g+FwnhAmisj8fQpkohAFa67jjJ3rOL0+0Z0cOlE0ewvbkMqMeIeSSH9Gl6bk4R02zvDzE2Xd0L0ztEPHdhHPRNX2XcGp3FNJNOkggMEHYnl9zjGOlttDx/1u4mKbsrrMSLcyHVa01cR+GEnsyMKORCojSH16iecUkcLQM3pCYTWC9J2hlCaSwdJyVgq4RuHCDi+JiccXtNU7nF3ixSH9sMd0J5z/fJ6gt6EQiBJGNeJ1PmNwZqnTOWHDDhMHF3Bu7mbYpEz5u9oxRQKElCs6xepxhkmqKUO5kUkLDFV+/zRPwQMvoxl7QYJKYgx+bxi8gtEI/NOb319rB8aiZfQuQW7aj/VYj/X//Zn4qEp4rMd6rL8htdtryuevod5wuG65Puq5cZ3CkOUxZVzWLN8HVIsC9ms8YynGmqH15gWgaCc3SYfyYxqJUheefuKwQUcTVgRDB31MN2hMNpIpDwk2m4qRqOjpx4akukDVCcs2ZnH1hvO3HuNqR3WxJH614SEuMNcbYpErJxWLOuTcTDTC1xr72Q69mBYUIp0XonU7YrRg5Ue6UgDWHudsj9HpvCBaFBHByefd3TuuP+35apXgjyPvW2+2bTfjxNvTkTte8rPjHVk7csomCK5YPnng5uwjfEEragJr2KUNS+Vxro4srn3s/QXj+gOJDai6ipPYIroB5W8p2jeE/gJ/DFgFF9zVBzxlMPGRhfIJLgxvLu/pxorRhrhzx8sT9Kkjf55jY81taWer9pPfXXL6U8v3f/mBanfNZduSXPiEpqEj5nSYWNmJxKw4tO9Raou/fUVSXqF+sKP4aYtZ+BjPMt6mqCindgeSbEP++Xd45ZYprZjKkTyICBcnlPAWshD6njFaMPiOTSXJedJrJXNDuzMFYa9ZND5jFTIqgxdYbDAStB7dSTz9MrTxWEaWo295159pxYpex8TNwBgvZwbYoTVcLjz8nz7Q/d2Iq7rmcGmIXgeM6we4XGNsyvmUkF9l6M5j7x8JViHBkFG3A7cLR9xfzO2VGSDvYnbpmS5tMN0aqoBJdXMaRyuJbElKvzizJ8Yrz4zGkbdLbJjO8Z7RSmTSIXvbkowp9Xhic35B4nX4fy/h/vU76tuQ279YUn2xI/nxF1zdfEaSv+bpQ0o9FTg/lww/fpgbvmkm7u6hujqyFAv9kM3DBDzZQApiP5rRiTIEEEWFkhQ9F/wmmUEgjLJBlt5AhgqxuDlmO8TEBiXLXi0DiuAjM2GYkAgW6REkFvO3p0yYo0vOPAmmmSVwfXNJEK/ovA/Uh5G79g59MkRKJpBmlnL3k2VUwjqoqNuKznr4iZD6HVpYACdNYQNWiU8WR9SFbPsLrlYhN3mKdo6iPjNMPlqNc2yejiO8zmGEvL8OSKo1tT2Rx9vZs/Om+oB5qLnrK66uroiTGDOEPF89RZuSvJOVd0NCx2rwKUJFYwXmUeNcj3YhvgtplERatniRJVZmBq0K0KKtSg77ks76LAVCEimiWNQVAUamAX6AcY5IGubAo1cBRjzqteLYlsh++CfXlyyCmMFJDImwIsAbJT3AzotnkaAIMG/yFCeJkTmWpF5IbDxcauiHuUvFWn+OshH/v2T3eqaclQ2uidBejJdO6MzixvVsr2A6M44aWx5otaACLd4QUIm3Ph/IDw3BUx83rGh3cJaps/aZ7u+o4guWo2FsHfsGMpVzXp2IChkg9AzkWAEISrCIN3A6NfMAZcgUu35PNBiehhE67CTnEi1yNqXwgmG2EYR2lIU7U+AzJcGsXHFnRb1syNZimXEzXHMI1Ty1VvnApfM5RSNtnxHkA5FpSMIVzUKsFO7jwKJoeHgrMNC3bOIbYtnIhwLDfGARPcfT8rMzT9Tl7zhIisG9h/ehphaWhQw3mpYoHFltLOuriDgL58tPKTdPJttk5FR8hPZE6QXRHC3j0aU9Ri0IhFzs5GffzTdvN8j5tSaU1Iu2Qg0ZU2ApXcOxqTBBiz+rGYJ5KBFrD6/3GFONZ850Dz31qcdvS5IkZpJUi26YoY5OCLcCX5wqIpXgfImYHHAqR8k0eDYnCt+hxs9iQdui1RKrjygTz9Yc37aYJsfzG1yz4RSKBOixHuuxHuuxHuux/iZWcZdz7Gu8i4LN288IzYHmUBFGDUNXYQVAGKXY7GGGLYrCchLrgNh8yxa1XJNmHkPlYSsfc5ZewTLFlsNepOX9bEmwZklwntipknCUuDzFeRww3zxluCyohMyeDextgEkX2Pi7Of6P7gn7/DtskfJZmBCpB0bzjKGbSCthbu3o3JZ+Gmn6K4bFz9HxiLr9HLqRqD/Pql2xdgbO4JuApNbcmIDm4LO/q1hua/7Wp4ov+w0/f3XP61PNrV7BYY89K4bVwLLw6Nf3bGIf0w08nC15pFmnG07mFuXFROGaq/YFzVXBW2lJ2lRw8NyQU5qCckiJ0jVBnLMQa7MK0cNEIJB63XNTZOzjks2XEfXRkcryioDglFAKV+sGTB3Q/XpHF9zz7OmS1Reat/9sxf4uYnpx4NJv8PKR823E8XzP2NSE/7xBXeZ4XU/2tyIufx6weH7Fz6VX7f+SvgxZJhvsZcFxX5HFn2GylGdhQDUuKMKfU/qWQIckqUEtaooyozp0hIFPf+nxrjviPRjyOqNTirWXk8lgSTXYxKIlAVTi4XU4L3aN7dG6xkYC4PcZ6yO3n5Y8vX+OXmx4VqS8DN9g9xO7JsG/lOHKE/rdgfbThODKwzt8wnJdEz9c4zaSdPGMfvGO+LQkK1P8655Ca87DcbaAv5dYS5sSO5/wGBCI8kW3eKKI98LZRrA3I0ZSCgdD6bdM+Uh4zAnVZuYq+Oc7tv4VOzJubmNsGLM7fD9Dz915y8OzPclG495MlA/PiS7ekm59vlhWLFUwp9KdO+krRSWcMaUdQaM4vTQcLzKyT0dM8DEBjjnocppjHp1AO0XpPv+aqPxHlAwJRLEwRTPXbVIynpE+QSwO8xZy/tezokoQToIA7cU4XUOdzakcv7Vhwmqt0XtDmErjrWnsgKpCposLtgtDuGjxOoXxS+6riSGQE6HiauvTdBuMAAwjDztOtKXi1Is3RqQuZ1oXshivCFVIae+pq4x+nREEDgFyuqmap5TaX+DcSKwEdtjTdtLIVSyMxhOSvz/wZLGgswM34w2fbq4p9JGjABdjzef6evaWvys163jkNDWcxLc/NSgzfmQK9CPJURa5FX6qSf0FShp0SbaU7FtRhNsWK7AKneBPwcxXkCiRcPLmAcDoh4xDiREnQSw3AZHK9JzKljBa8fTy6mP8nkT+yeS1kwjJ2bgyH2glk4shILSWYrD42s2T1E5HLIKauoXjWc9qCi7kT1o8aeq1YBdCJonGDEpiP8OzAVakO+6Boe/xfX+WGPVFTPREYzaG4ZxRFzVdviC2J7xBo2OBI450xQTFift9Pvv9veqaPn9DWDWMvUcmEaGBolHNDF804zXjIBNGx3KhZxtHKSe7ybjINdb3KHw9xzgK20Wmf5MAYpShCfd45fxT4QfZvB2fyppz0Ao1krGHWgAkY8cURuzbiO5YYfSSJum4kDQNLyMdb2nbNav1C+qm4935gfPdhibf88XnG574OYfqO5qix/NfkC0lgmeiHQ/kJMTLmMgotOkpyoJa4ITLhAuJ0VzmKB3SK8eojlgZZPjpnDoSkM/Mi6jy2SuH6TRx1FIWLXWkiSXiRlISXEyShviDWCA8tJx7+gavODCEEZ1AGO0DQX+BSkLqLkEJ4XascEPFsXrA9yK0cSg/oBtrrCSRuHEOa/BZ0ifjfH7o0WeU4YJxWCexMCPWl6PSz6oWuR5NusTXH4ErkUwqh4RxHOjCjKC8ZxCOx2M91mP9D/WoSnisx3qsv0lVyzPwm5j++g6TXqIjeTb5HlVd4Xk+aQn3UYgdY9x9yzSdCS6TmbEVVlt0V7C5dZwk2vroUB8U02cdTS7DBh911thVTpIW3JYF2sZ02lF2AVeTRyBk/UOCTh1N0GDqz3HPdjxXT6nZUv/oLV/8+od8/T8XuF3MWG8I2wUXn95z3knseA7O4i07dHcm2q3RS2FwTdyFHhdpgGdzcpHQywAkEFbcCZspXB8y3VlqL2H8YkW+HchFiW0yDp0sC0ts7dMvEsah4Bz1/H73OVGUcfYDloGHCqRHWBJFIbmfYrRhX+6J2xU7W1B2MaGdcBeOz0Qg7a5onWNXvaTbr0F3dAIzrDMageB3Pbm3Io9r7o/FDCaXZWHTZhhvh9Il02ZidBHlbc4iaXnxw2uCcmQ07Wwtjw8rlslAOaYUbzzCmwbuxEqccm0WJM/OPG+eUG8P/PzPOhadof18ZMxBP4T44wFPJxzkadOs0P5z0sISEtNSEqtrYQKS9RXhuqc9GIpDxO6p2Am8eYjQex7vJcFCEtLCBhXI4hTyo2UU5W4q8v2GVk9z79cvO8zJ8vD2A+FWY9OeZz9f08YDt+9bps8N7fewz5+SfNvQ/7BFfwjx8mIeRAzRB8ooFY00yW6LnywITYH2FZtjwLVvOC80h6AgrhaYMOYh2RF2E6v6iiaFpnXkdyHjVz31YiTapeijPyutP0RveXpe0qSG0YNl4dDLhA/xEY8XRNFbTCwzhRDKnCK7xU411Tnl9b98y3YsiX4QzGr0XXnDyJnESIJgSmp7Tmpi9xBxfTkR5P1sz569Fmr4jW1ZLAlmTnmQAYLgF52bZiWCsBNEwiwchXlTKul27jdKBU+CAFo8K9MO6QfGGdQvPmgziZLktzRMiLoet9xS2wO6EtVAQ2/v4HCNDoQHIBNKkZIbtl5H5yb6TiQ5gViSCCJI4pFDq6hGkZUH3OSOVZjPE5ss9omXCfHCMbUTbS/ODZ8klqg9i+8MWZwx+Qbna+x4YqxGlPixhA7aeJTTiTQP2GSf8NxI8kTLbdPMkx1b56TK8aa/424/kW967j2RhHSEmxATLJgkHjHQJJLUKcwFsRYMA6aL5gtfkitMnJPGJaYt0f5A0Wt2p5BlrDA6Jh+FBOvRO2+2dMStZHeaWQ51rhf8/hOBVWqsRPZN1RxFKTMfK8mCU41x8Xzw6dpZdtPJAEAJtTNG/iPb9v7YwSDQxY5BrBJ9OCso5IRxgyQiBDgl8vd2bt7HYTHDNpzdoFuHEqikxH7ogE8v4RQqbsOI3iqqeqTzcnQ8sd40BH3EXi0ojxbnt3ySapp74Rjcz8DEMV3BUhEpEd2LJaMkKhXhSmHChEwVs42nKT3KkyHMFEGcYGUKORxmjoA3JDM3w4YJB1swFCX5RpPkHcVe0iQCtEAM65ZYC+W2wTttGTNH2JR0gcIfr1DPLMruieMbQr2Q7FH06o6kCUjGbPYVtXpguTUsks1sg+jdHWHb0vlX80WUxwN57rEMU/zA0nXioLF0fgTVQCBRMFHEYuXPwSldJcRXzSpckSwcx3Dg4U4IEDVrAk5W002SaewY8TnL8cxGtK1nOKf4OtS4xxUpfR6ysDGV+Jpa6IwMgsTG0iPU0sArqQ4+9UnkSBOeXA+UjFQY8UZpNTMa/NbHGxU2ELmcRo/Cp2jwbUTbLWQuQxb4dBJF2m8IVUCn7pjKDCfbBBEkinpjlIjU2/kneazHeqzHeqzHeqy/mZXcvEVvvuD962+oftejP5ckP14y/lNN96ynrSx93eMWkohm0e0GNdwTRpquj8nbPUUjTZpYOzvcokds3n5haZOGqYpZbRx227DWKZcm4dC9w3v/lKNA8cITa2FIpXAZp7T1eU4U89w1YbznfbTnD8PPOVYtu9HjM9fR6IKoF07XPeV4xfTlERemfN7Usw3A+/6aNq/xTT9Hy+eDQpU9ZWBYGj1DEAej0XaY7Z/HcWJ9MKTrBcl65Iuh5ZtzyfB9h6pb+i9yXKxZK8c2ibG6xmVHgu45haSeqZRVtELMBYfTB97t3lGEKeOrmlfDEu13bP9oP8vVn4RrAuWoTEMsC0NPmqgN41gw3tfsNw4/arEnn/1rQ9ueuPzUEq0M5hCgoxYWsnzb0mnRDMf80Y9SwrSg7y/45lVH/7DiRo2UqqbUV1z/MCLYW5R/proL+fZ9TfDkwCdPIh5+9wXd9w+44iPtfxLlwy7ET0vUMsC1LzlGn3Ll7hmyCPMQ4+uI4LOBzNvT33eUpxbvJiX7NOfZduLCTpwFvqnP+CrDqQu8qEMfEiZvTxPvyN0lbS78hxLaiHLruPrlFe+aHfVdh1k63qU1qbrCCNAyfUqwPOOHK0z7Cr7+Aqd29G9rbHPPOlzShgnBe0O4tCxvqnkxVwZnTPgEO4z4zciFMsSdpllOjJK+VogyHHQm8aEaXXt4J4/uicMrFdOuQ+cl8UkSCLv5WLtTx3lzIrL9DOVn85Yn03O+uWzoH15RfXNJOznWwZFz5jO+PeD9qUUnAc9unqG8gq5httJXLaQbj6Lq2Z8O7I4btikYf2BoDdM0EvkaT4siXmCeEhv5bxQJ8cxU8Gbt+MeGc5KFuBK2gtgZ3KxoEHeQE4u+DCN8SY/L0EFHr0Sa8lsaJhgdsMlbHsZoVhDEUUUbKfrTex52Ioe3BGlELIOMSbAfIYMXUltLV02Mg0GbBK0cia6I/RHSFJ8YM0I3DfPv5SZFrWWzLQoEi/xmp/z5+7WjLLgVbXHC6GL2kUvMRdd3HPsdg77E10si0xLFHqdQmkJL4qXcdSPF2dKeB7yDRpkULxMeoFDvRboSoEORgyiCyBH0woj4GPEoRFId+POBylOxYQQ0/XpOn+jtRKtDgrSlrixvzh1tIqkH2Sx9WamIqRk5DJbUW/NiJdtriaNE8kVmaqYoHyShY/TFVSZ5qSLZ6tiXBcPQztGA0kxvg4GIildBi5ajPsboQqZRFmsmxlbj2gGTiIm/oxd6SCyxLtB3YjlpcG1O2nt0oWz54aryCfKSzG4JJXoy3vGmk2GIT90dCbefsBay7gO4fUsbpYRtRPJcAIASr3LCeitMItqklqYZiSWuU2W0YUwSjsTLnu9+feb1+5jrdUh2VWHankyFtJ6j7s4zWHPqIpQeSdX6YzzQeOBh33CRRCwWIYOeWOiG4XbLvq4I/IJaSKVjhEqPxDb9KDvK5H29x5iR0VsR+Dm9f0+exSirZ9XJOr/GXb7nzV1HddSEwVuCOER5Off3LaPpWF4k6OWKm9jH8zR38v26jjxSXHvpHMtzr3eosYYwpRZ6bW2YdE0kiQ1TSNU6Gn9iaRWxH2NFUeBpVCd2i4hrFXOYPswAFDOzOAsUI20Qo5oe4aMEWUg3PdAXDft9QCGQFPF0BXY+TyUKszfT7EmzkyQ7iHKmpJ8UoXb4/oK+2TPJ4EwiIkVV5MRTFZBuL4iSYoblKImUYGJoH1DVZrb9qFrRV//jN5LHeqy/SfVvUhX+OhQKjwkOj/VYj/Ufu9bLV9xsfp/zNwa/8IjuQpbpDdP6xIezPHem2FqRfy3q4ArzRBPVn1A+FEz5HW4yPJhpXoplArQzElce4n8w+PmKKZLEsYoLP+e/WIYE44I/+6XDO0CZTQRxjcluOC3O0FxhbyueTwF33pkgUjyrc3bpkat3lsk4emmYBK5dwOIiITlNNNuAT4eEW05UoYC3IyIX8cWwYh82HOMjqveJmolQFpuZ3OfFLx/Mz6BmaYlzn6d6RRRMnMaOYrhnelawPltqv+W5SfkH9gvycCNPcqyHmNKWbMNL3hYv5+e8vSu4/brkn34QltYbPvyFRCOWuGU8L1H/8eItv7su+eR6Q9puIROgvU/RD5RBRXih2MZnujDg20U6L7GoZLHYo/qK83BB+LQn8CdWpeHJusSEAcV4EI4gSb7hoix4N9YcwksW3o6s80iSiObrl9z1S6bljr2n2duJB5PzWeLz6uISXR9QmxN2esb7Ysd2DutI8NKR4Kk0oB5jVXDeTORqwXgasas1QyGDJuHf+QTv4KQUH7qIi7XPpxc71KAozZLVPRx3FYfKZ4hiPly9JKtTqt7jJAvk/VsOwojIP+U2OxCeerT3Far+GQv/U96YX/FZ92Mewj0v8oyDHhnynP13J/7g8o+oMwHHrzgXv+Lq6YLnXPPQ1oTHA77YFxYdq/Ej46DwHOk5YGFfcJ5OGGu56Ja883qOSU1uVjypIuxR873ZMxYp9njBhyfv2faOu1zT+y3ph5Rp5djYge9+UhN943H8b27o63uIUiZdMUTXUAy81R6ffbeYBxxB4ihZoscaT91xGC5YeyNlNfGz7xw/JGKRTrz70KHHjE+fqHmpaf0BayX2UphvEkiwmvlpkmgiqRSeABVlGzwrECQ5TsYM/jxqEA2D2DgEqKCM8NP0bJ/4rQ0TFukFanhL2N3gZ7f0Z8eqiyn1gXvdzF6j5nQ/AzeiIWCRGlZTzMte5N/V3BxPoyHyxL4wzrLtbprwuhPV5BA45mK2QmxIF/HsndKFx9DvZiWCHyUUkzRpHXqo5T0gNt0MXXwoB4YpZbMISPMSdVrTZQWpiueG621j+ZW/pxN4STNwJ7kuccJVvCUP1oxqwEQ9yoCvY1ww4nRPqHzSMEFnPTaWyMQMQTV4SY+rQ6bKUrsSlxx4Ft8wbQNeFY0kQHIeOg6u5M2oWJXD7P///GaYJTNOPBMyPLESwjjiPA9fNs1ippFt8NQzTqJeUCy9iHIcUTmE8YTthM7q46kW3zfYaqDp75mMbOdXqGFgaiasTNX8lCCJ5xvaVE40w4lunbIIAlYXgsvt6TmhxbqgaoapwTMJ64VBF4q2dqyeDNwVI7Fstb1WYj2Y4f52T5qt6MaPk9tAJHCdQ4UT9ezLuSXyNzzZfi5pwbzLbjnvHY03oYcOPYnQXtF3MgwReX47wy1bq4nimjCMqM4S3ZKRRgFeEGD3awLvHQfJNhEIyxgSDiFD0GObkMLUbNULxtHD9Qvui/vZEvHp1edUwwf0lGLHhkMh8aRLntxcUroTxzvp4iesSJ1ax2gVDx4cugG/ybhaeFyu4GLhODwo3t31DMI/iCHwK7z4Gs9pzmOLH7dknaFQ6ZxcIp+cWoBCcc+gT4xjQiY2FV3PPr46EjzjBh2GqPrMOJwJF1tc/9FKg85QfcmURTRVxf1pR3MaUGNCE7YYIchKQ2MbXODQccI0hnhWzBmiw5sY5KTN/RmuYmVC2QqNSJH4ARexhnDJcFdS1JJJXM3RQ/QOdxoZ+wxfF/++zyGP9Vj/WdZf51DhsR7rsR7rP1ZdH37E9z84s/4spRtzxq8u+e7Xr8g/vaSUWOw3ISqzc9Ri5AI2euR8/Zq2vyIz8kwrwWn+HMvdCOSZBd5yQg0euk1ow4p8TPjbOuTZJye++2nAr3chzxevuT5/ySHz2C9SqugN/W1AftHzVp/IvfWc/JC5p9wlLUk1YGOPknsW/ue8+/6BKF8IGIv4654uLhkEirifCIOTiPHx+wqnQ2wb85C16KnC3W7RAj/MFZVE7JU+6zkuvmcYdnz/fs/373ui8J7p0pDpni+jnMvlFt6lHL0D68Wazopqd+J9eUskkv77O+5uNf+Xf/Rrqs0NP3hRYvwJk1eEzWcU70+cH2DvB/zD36t5fpnQ9z1tIwkTPQtvQfG05qJZERzE7qpJvzhzO27Ynw3ruCP2b+mHgoVbymqJX9mBeDwy3WfQRHxXPrC7i9HDieR3LNNXHj9aL/EfHH/2Vcrw5xfk6xWfJ1/zO8lzeYKfE/C+vF7woWyI9jFP9R2/0oYPzUi6mgiahkjU1MucurCc7nt26vUMxvQ2ksbQMaUZ7cOZ97/YsQxjxu5A38kS73pOIii8HflBojlrpihl6GQgFUDRYyWdURL+vtvwcBoY9B110vHpdsXdy7/Adlestg35P9OUPzjg5NmYa7zTA7m9pFpe0/ktYyfRne9IN1uydEtbFxyjllUYsWgaqiKguPjIYBPpvyy6N1NCrRo+VIoillSElkR4odlAb3vsasV4/wQjQLnwjKcrLoYbivDMpDccc4tbDFzc/YifH39G9E+ec3xdYZYBfvUl8ae/JlyE+JdrdknILzlQnlM2ksjWivrCY5EGOH2a41iJO+6Gd4TjpWAU+dn5zJON4/oiw9hxHhaIakcS4sVLP0kE5DwgECaew5OhgiD/ZYutpP/0sJ4MGySlQmwlYolezAp9VEU4rH97w4S+39F1ImSXZjcgdidCgamMGStlMd2S1dZSa4/mnHLf18Kax080fhCjw4k4lgzOE3XX0ogUOwrxJXquVAQuJojH2TLhxzU69JjOoniosGqJb3KuMHRYhkhznjqC6kx9jgmymBeJo/UrtF5Qz/GTD6QXG2QqUfUxm9WZfRySLBfYpJ0zTOtLi6TgiQT+MjTE2uKsmbNtQ+UR5YbQGHwVzhwBT/kYN8wRg++nAr+D1A9Zan+2DiyXa/7+dYqTiER1ZFw9Y5Pk/J/372h+1nBzdSXhtPSdAED82XevPUl5GGZSrTYpHaIzL+cL1g3D7EUSy8jn6oLn0RW/ePuShw/l7KUSqVj/GzBJqCxx1s/b5tYJSKMhHuI5ZcMlZ5LLzWzZSJYhyyhgI+AP13PqUpQoM6xl7Avyzxe0u4/JFWI0ORztHJlyFvaDq7heZdy/HLl/HbB74XMtUJBJsTITe53g8naOcozCniwIaTyFFztS5TGISiFbcLGIqYcP3J3becC0iBYoX80TPBUanhtLMB15dRaeQIyKe8rjierQc+4rijrHj8Xq4YG/RfvFzIFoVExRjSyynptlRnF6gs8dXfrAQtIbXELZlbRiseiXPLnUfPIk4zrrOVYJ52pLd+hkxIGR5AWvw+0mjicZ86RcPzVwHfC63/HLh5qLxYalMCe8M3WbkrgHsD6df8noegJXz1DFQG9m+OHDcWIpH6JTx3btE+0rqlGUFQMufMBI/CeLj7yMqKAdR6agphOwYhTRvTZ0+5R+f8IzLVPbzwMHqwJGzyOQY+16eoGreCmTQFQmxygkJONhW8U0NnhOcm17Jr9kkCtaxYz+1QyVzGIZTlzi5R0nz2CdDIbO/77PIY/1WP9Z13+oocKjKuGxHuux/lOoe05Mf+FTxQ+E9Q0dmST0sbgbMYTsPmjM8ED8+VtC/0foZMR8csL7NiXeX+PcN/SuJQ5DXONTFkeSAdJ1xrix+LsFz72cTbrkWEa8f+9Iu4beW7F4epD+iYNQ69VIkJ44Zk+JmjuWyQkrSksXzJ7v/koUogHBw2ckSUZw5fimbHnKLQ+HG+pOkhVuKaeUXuILr0beZUfGw4ImmmhCi85uWPnynH5mqHwmO1IGYnswXPp3HAfF1/uRb4d7rvKG6+0N/+Xyq1mRbCR2fNlI+jjH8g7P94mUz9C5GTD+9V/s+OfvJPr7Ha59wjfnO2oNvv9kXv68EybbreKhPfMXdmT5dz+ZrbejcNdFGd5NqHuBRHZUnuFZLWkFMd0XHW9fv+O1P7KaNgzfbXkw3txA2+8V6eAxyBLXnHCvHcWuJn4GpXWs3/l8b+AqGPh9+4TidwXWnhE0a7iuWL1T/JO7I9tPDS4ocH3F6+kpiwTsSiwPI0HvUW197LGmawf6+wirNMoXW/iS7bMNso21Zw+lKoZfa4ZiYv28JVhWZNEF16envBteMUzdbJveEOI9hNSR7M0PNJGh4ZJAFRhZqH77BW51j2cltaJjb1Pq+EvOT/9blv/y7/PLtMIML9HjJX48cDfu56S71WGFuTxy71WU9kBVLYmSmIGYSBtWjZot58WlR9e1FFVLI/g4l8190dokTJOj7kfW+3xmrR3XI6U5sOg2NLXm10mJ61riquPbn3zgx8ffo/cn1v+n57x8846/9wPLz/0tG18R7A3eHyjGH6y5/qmlWxhe/fTXbH70hC5eMrie42gYXI6fDqSeYxNG8xK+K2s+05bLdMXrusXUmkhiNaNh7lk8iYyXwYJESHoSESn6Y7HfCz9BIzJn6w1YYeWJHaZ1OPFCizXD+oxeJq7q394woaplahYQmB2l2qBXjk6gGS6gYcDz9tQElJPGLEXGrWfvRRoHhNKciCViODAeW2yZivl/pqpmOvwIzgtjFpmiVxFDCUEdItj+WG+phXJvj2xXH0/QsulJVcT7IaAZR54I9XUZYX1F914miDIRywhCx9mteHH1HSf/6Rz9slgcuVlccjkmmEWMHpdMfYdfeRzrhodqP0ep3FyEBCsHJsEL5HsLEX+aLROXXYxd3xJmKcmUEoUDbtFR+YYvVk/nJr8se37/5u/w/P/d3n2AyZbndf3/nHOqTuXQufvGiTszu7OB3SWoRF0woCwqioCKgoCIiIjiggERgUdRgqACzyOgwooEFQNZl7CLsLuwaWZ28szNnbtyPOH/fM9S8+/p7Rvq3g5V3e/X89y9O32rq0+dqv6d3/n+vr/vd2VFbxo29cLFdb2wtqVOsy6vGylVTCfFYIbWTzOVToqAqBvIt0KEcaxG21UxSsmPAuWs24XnKgg9dX+/tkIY9BQ0W3JiVzPVnFJ56zuakZPxNOz3Fa5GiqxwZDRQxi8qvVLRoLepTNaRV47luhV58Y6iRlv1Xlv5Wduns6je9R2lcjPJYzpXC1pzV9VL+QpKKTk7nq7khqqc9bRxpSlvNVQzvyVv8aya3Xl5KUfVtKco7mmmuKBUIatGvaZyPatqpapBalvFvBW1DNSofaweQdoqMOYc5QqhclFXbSsCWSmr2V7VoF+X2hnFSwU5maF6tu2j4cjJWfWBguTWNUifU9TpJvUECtk5DdK+CoO6cjlfbyzNqbW9rLX6trxZX/n0QNrylOqlVOuuaVBPafaBtObz8zrjS36+pquDHQ03Okr1POWKeflOpEbthsLI0riWVZkvaX5uRquBr8bA9lF5isJYjUZTQSWtQq6g7LAjN4zkpCwroaeu5ypvrSxjT2EusEwmadNaXFrksKmUW1bG21bHn9FOO1DGCjBau6TAV856E5es5kFGO42Wrru9pNBO1jouyFMQdpLCnHHfes1aYMI6gVj70LTFpBSpl/yWp8Occo6litXlFd2kzU+6XVZrGGow3NQwLCidySptxUNTTaW9soqdLXXnSnJ6S/c4DQFOBzIVAJxE0bWyNl+/rcWNM9oqbcvd2FF5Lq0bL4ZSrajCuYqy23np2lVVHrUaT1kVt4vqhVuqeS2Vozn5c7GG1rq6GydztBm7QffTSabqjBqKgo6eeTbQjfVtPf1SS7PeQLPdil5cKipXsgVER2e6ZxTmytqM83Kc7SRg8MJVX/3clnKprLJOoPUnK+o+8ILq8wNFjQUNKgPVClbbvq3S1kKSGe06bdVDV1fTjta6BaVtESw9n3QXK82sKteywpAVdVOZZEvxTKmvlQc93cjM6r3XN9XYCDVbzen80oreGs0pcPLaaleU0fNaqC4plqdau6mgtaNNx+rdnVWqv6Pfvr4qt9nQYOGc2v5zip47r/TgupziuraXCkpvp9V9Y0vpD1kGcFv11pL8dEpBmJLjDdTItdVqLCudScl1unK8mkqdnM5VHRUXSqr1M6pfyaqzEys9bCljHfYKi0rHm0lWstI5NWuBMpmhZiue4pWBettFOUNPN1JL6l98Rvl2VQuZtLbDx7WZeVZn0q5mz/vKbGxqc9nTwuyyMlcitazQYyGv5tOR+mcD9bZqquR9ZZcLWopSclrWXaKm0sq2Sp9USDqJdf/PQL1moH7NsmgrWjzbTragVDMDaTalYvu8otxVZcO8om5XPdXV8s7L7/WUs0BLtqtu2lUUW0ZJrGw/pWy3aMtwql1eVW6uKm97Vt3hkrLpjyozP6crzzgqLV/TYukRNVotZZ0Ztc5J1eeH8h+4T8rtyKtF6i7U1U2n5FtLia6nYW+YrPJbbfxqKlan2lBfrpphSoOZrMq9JYXumq6c7akmaWdB0qU15aOy1ryG8kFXc859Kvh9LaY31CmG2nhhQWcefEmv+eTP1M5GoOy5SI3LLQWrbQWPRCpkSio8VdDggZx0biAvd1XpLUdrazPKWd2QJbsfLyUBLtsaY/eow7inncaWNtfzcp1I3sBTNltVsZpRsdqTvFnbV58Ut7dCJY6XTbriRa5VVLBGkA2FSavIbJKtEIZ2P+koivqKI0+OpdsfVDChUMlqJy4r19hSJttXP4y1NYhVdbaTNhNrO57yzS0tnruolBWaKMdKhw25wYw6jqtuvKXWYKjAVk1zA3mtSMPtLdVWfOXOnVXOz6i53Uv2uisrdYKy/KihbuQpU7QPflfr3Z7acVq9fkm53FBzsasdP9BWN1R+J1R/cai837HWDVq26gODpgZBS/W5YpIalco/qEo9ktey1h6OSq2UttI93XB21N3qq3Ypr63mptpxQxeW5/T62WWtFIqqnHXkz4dyo4z1rVFBKZ3LV5NOD3HfOhSkFebmtThTSLZnWJXR3/nANTWaH9EnpvvK2x77clbzmWV99Kmefu/6izozH2u26Cr2vaRd4SBoa5iL5XQC9ayqbdhUlPGVGUZKWzX9XFfdbEeVXKxqydPatY56/YHS2Yza7b78oaus5ymdC5VJx+rkcuo5PbnpSOVoVguzjtyUr/WWp15YSLZO5CzFxdpYKi0/nFenvyo5FaWyoXpW/2Ijr3zQTHqutjK+5tNl1Xureiz7Ol0/G6l12SqHzmq+GyvtdNR1hkrHbQ3citx0oFqtq95qW82i7cXKy02lVRtuKQrKqvVSsjKFfi6bFAuxtpel9Jz6LV+DZl7hcF7ZakH5akrljKvN5qp2BraLpyXlFxSl+uqtFZTPd9W2n90ayi/58sNQlzabWhv0dXY+peLMrM74fYU9T8WKlCr5im+UFfQDRf2mohuxtgqBZotDLSwsyfcdbblDrV73tHO9IT8pcJnS/LCneGUoNxepGIZazLXUyoZqdmJ1mxYQmlU0cNXJWSGToQZeRv2gKUu0spKu/aCggrehtNWCaFe04TQ13w818PPKuKFSqZKKtaG6c5ITDRQNbTtQRZ1OKC8aKtpx1dy2D1egYdxWPBgoo4FipZOWQW6vq761D8mX5Pmuhk6gwC/IdSwa3tews6EoSslzz0iWERLaVqOPdaPod6QwqilVL6mf7SkVnUsKPw6KZVUHZQ2qW/c4DQFOl4MIKpCVAGBSdC70NftiS83yWaXzH1Vv7Zy6ywOlL+QVXiur7e0om03LP3NOTdeR17bFpFkpv61MLlS72VMmTqtbc7Vd66swP1Qq8uXt+HJSPdXbA4XFWRVeaqnbHuhcwSrau8o9nJNfbyVt2K27VNsyLRcyOh/1tFDMKLqetnRftSuXFZQeVvG5irzHfk9+9lFtzq6qsG0FBgd6IGX3IYF6QVeFQl/FMJu0CK8PStKiq9zCorrbsXKdRc2HJWVSkeq1jIJeqMX72jrzcEe5uTnVV10VW22dv8/RQ6mqCt6Mmt2ucqlI2UxXwdA6rDmqNwZa3ckqlS2p6LaSe5Nnn7um/ss7Gp6fV+vSjgqPzaoWbWuu8oBa0UtyZ59S5rmC+lbQzavr6dVZ+Z94RXOdh5T3XTWcj+1hL0aXkuLlTs86i1ltOrvP6Om+3KxeHoR672D7Y23qS21161ml+wO5F1qayd0v31oZLlxWpTir15/JamfQ0w13XT3XuhlY+8a+uqGnZmNd269Z05mnl9R9YKAHhgW99NKH5PWKasRzWgyvanPNU+35gTK9UL24qKJvBfCsyGNF7Z3ryj5Qllsq62zlfuX8QLlOTb1cTpvPlRS0W5p/jQWhzqlZbWpddn/jqXquoe2orO41T510X6kgrWa3oZVaWTMpT43ZVfVWtzRIhep0a8otFTVIPaKBLcBtXtaZsw1lhm/UC72+Fu4rqXHDVfn8S9pu+3qT1bHotdQ8t6a8pYmnOyo2Pc3GfQ0sQODY/LmtSn+oHa8nBXmrhK62N1Anm1K7MNC8LQCns0qlQ5U6V7VpxRqvzij3uKvn4oY62aqaXl0FldSWJ289r8+4dkEPOA199MUZzT9eVG7+jfp1f1tn6g1dTV+UN3xcw+GOHr1xUZcr19SrNuTE9+sjszf0+lyoZ14qaXGQlhdEarUHyubqGoS+6s1A7VRGlUxKThxaHzdl/Kwi17LDY6V0QY4TKkrbZzKWEwZJdwbXOg96w6RWgxOVlYqqkjdQbFskMp5CWxD12oq8shzbEmEZQQe2zWHN2j9mNJgrqpyONbAK+YNLGjqz6nuDZPV80F7RVnNHpfKCst2K6u0d9QeWft9K9oRn3Sjp6mBVFBoaqJhaUFVllayDQexofehpMcqpEAyS7ge25cBWdjPhnHIrkcJCUU2rGmj7WGQtFHsa7liLx6JSw4Hm+3l5qaJqM09rLnNOXmdZA/8lLTTnJfe8Ku5QjVag9R27kXL0QG5BS2Fel1M9DeNQi5WOir6n7e2itrY7+vWdKyqFm7p/o6JHHiopX4k1jDxFQVapYFau76o4k1VQkbxqRQ+U59Rv1PXhJz+o//Krq6r/3w/rU954n/7kJ/V19qHHVdCDSSXcj67tKC65cvNFOauBwkVHTsYKajqKwkjtYVvzeQsgRWr6niozvaQrhoIwaZ/iDVzFfVdxOi1lAsXy1Y+somNbXpxSyepV5Hw12qGaYVo9T+qkh5rJnlFJPaVqjsJ+XQ0vVhBImXRe1WJTsTPQYKGkjLUsbEXaytaVDVIaeJGaratarvjKD+eU0oZmsg9qcLamYugrPZtXN7AevguKB5Eiy34YOEoXUkqfmZFrm+VSaVXzFQWqK+4MNZPJKVUYqmOVBIdVqRWrHqS11Qs0X9jSXCpSvmz7wdK6vNHT+iVPQy3Imkfkcn11mymFuZy2rIBJ0FDugVmlC5EW/UCXbuS1c72jwU5Xi3ObKq/U5LrVpIhnIUirHQ2Vy0ZJ4Cf2yqoNbZtDRys5V7OZsqIzJTU6NXW1oyjMyXGG6qfsIrEifxirZ4EQ62gyjDVwAuUz29LA6vNWVOm4CnxPxVxT1XBZXmpHuUqsoONa4omytbLcbCS/N6NCupe0tuz5aW1vzapUGqjatVaOgdLFWNl0oI5rF1rpcq2hG/26wqCtYpzTMJNX392QF9rv1pKcTEnRsJ5sZ1A8q3THOj5Ye8iU1GtLmZbUP6tUtivXjZIWor2+p75Xl7ttkeRzcrOdZAtPzmsoqneUyy/J8a2wZ+te5yHAqbQ7IEBdBQDTKh0+r3rxk/SwLfi9vKTn03Xln3xE/XRHtYc2ld7qys176mdWFe+c0/ogq0zcVlTZkaJl5Qtpla29eqMlz9tSyj2j1a28/MxQWWuBHQw1dC293dpBlrR41rI+OwrWS3p4qapLVxvqNYeaHWS17vvafDDWQmuoeq6uoregldIFXbrQVu3ZptzGGxX4V7RSW1a+7Co3rKm9NaMFv6OdpabWQ1ezrrX7nlclSinv1zUfueoNcurvfKxFe7Tky8lsJC3eU5VFbXQjPfHiVXWHnl43k9XSoqdifUFp11feK6k3bCXbSP2Mo3p9oKuXHKXmryqTdpTvFrTekH7x2ZfU6AzlX5iX+/wLaj8xUP5CTTeu9lTIP6r05u+qbVmmOy21UgsKOmXVuiW9XFjVTEeKC0sK6yvyctdUKgzkOY6uWZv3trWin1XXbiTKV5UuhGqvdZT2faUHdu+wKa1Zcb8N5WcyKuezqqeHavQ+tg33NcEFPZEaqj3b0Xx8Xg9WpE2volKvr/lCqOde4+sTXuzLe+2SnrsaKe7HutHtqtEeqryYlZ+y9uKhQi+tQt+CDQMFs1m1qpuqpktJFsig31Wt2VBoFe1n0wqdeSkfK9VeVT7wNJtb0MBt6kamr6WXlrSa3tRWpakLa/Oqh3VdsyKEWbtVyKqTXZHfrml7O6NoztPyAx/V9aCl9MJF1Wvrqgxayl5oqlgcKuwsKM4tKFv4oK5vPK+hm1JU6+uMX9Z2M1R/eEkzVstsOafCIKNzQUUbs5sqdCLlmlLfj5Lt7r5r82MrUl7SfBCrFwXa8eqykg6L2zk9+EJKlQuP6oXCpmbCJQ3ka3m1pAubaXXrO0qvV/XBuaouPnBVL2w5yq852r4YarEfayO+ppL/iDr1dWX6VmejpkHxqrIvRno6b0G0mhbPObrSyWqmGWsm21awXtZsZajC3LqyTkGdbqztwFM5bZ0IcwrCjHZqDWVKqaTeRX/oK1TnY538VE6CUbKsC4UKbMHamgF4PYX2uxk9aJuek3psdg8QDw6wZoKtdoapThIZ6TZtZX9bDZU1N5NTIerLzbvqud2kAGAhWFWUKiqdtJezaOSconCoIJtWJ7KAwECDaKhMGGvQDNX0OkqVHfneUO1hWn47r+JMSqlsRqmap4aldtdK6qYGijq2r7ylkuOoF2XUsoIRQVfZTk2DlqtgKVTRuaDCihR1LF08r7UXHfXzawo8V51mSX57S7Uw1ovLLQWzOYVdR2HVUy/bTiKKK4sVPaaSap2WXn52Xb/x21t6erOitz62ovOFtFLprpxoVkErlqolVWYWNVPJJy0sr29s6fJ6Sg/m5rV1Y1VP/PRVPf+LPZ15y7WkXkFqw9cnfMZr9Sfe9FbV61396gu/q/laSwsXFlV083IGrgqFghYqs9ps1ZXqdVVOzSsb5DTw1vVsvamX13fUiSJVciVlBo7CfF9Bxpdj7QurLYVOXlE/p7jnKooiDXN9bV/zNbCOG1azobWhlnWJKJ7VTNRUPFPQejslJ5xTdb2jqNhSqx7ICXJKlRxlGo6G3aFeWu+ocq6oFxbmtHSmJreZ10K1pF4/UL+bURQEylZ9LVXP6qHlvjYjX1vrbW11dlTNFZJ2ig3bl5N2lanF6m9V1Qq2pNmawnxe25tNaVhQ0V/UYCbSWntb7bUrGm5G6tbXlU8XND+7IjfnaGhFBF0pX99R7D1iFRF09mxZi+W2at2Chs2UPKtVkNlQvTuvYTaW03OVCzxl7PfG8TXIFVRx+yq4Q7UHoVpXPVWWHd1nAYvH87qyvaRO3dppZhSHNdVaW6putjTwCklDxjBIKZUJ5ZcXFdvzDKXB0CKvZaWCijqBK8fav1rdhHJahYY0tP1RUaBCeSh5ZQ0GobzQglSX1GzPK50UJx0odipy1FCsqtLeuqLejpyutZQsynerGg668tJVZZyUgiCtwOsqyntyLdBQGyhyLLLoy2tEirO+otxFBX0/KbTpOK7KoatcuqyONhRldxS1rPjRnCpBWp1cqNRsJHf7hjpRRfnhuXudhwCn3jjZCmQlAJgkC/Vl7ZQ29ULUUzd9RtGDTyl6z2V55bp6kTQzP6dBsK7oWjFZJQ9f09agOafMzqKK3baic13Var7yF9K64L1GnZ0ZhcHL0qCjTqWgqDhQPp/W+XOLataG2n5hXcHZnoLOvKJBW1knVOZioFY0pydnntP8+x5Q4QFfc6VQz1jmaut1elOzrecfe0mz7Z4arcWkflQpjFRs5bV15ppy7ZwyqsrtDBXHXYVOVu1BJH/DV9hrqrYWqGP7xrM9FaOsMg94igeBLmXWtDX0FG1KD+RCPZw9I6/jK3StE5yj7sC2hqYUOkXVV9OKCjdUORsl+9h76ms9PdS713e0/UxZaWeg3uXn5b6xqMyaZQnbQl9aO81npPJbVD6/qe71q0pu82Y31Rhu6uXqnJ55Ia/XZja0vFBXL+xrGKWT1t/VVFqt9IJaA1dhZ0tRs6+ZQVnpXE4Fa7P4QE+Nmqt0uKSsk5fT6iq9fFH5rVU9ub6RFHCPK1m9aW5Ja25P25sZzWpdj849rPf1N9WYdVX3Xlbdq6rvn1P6zIvqPL2h4ic+ovv0ghqvu6D01YZmQk8vBEWFVig/lN66WFXpkfPqxyk1cr7CdlpuOaP8Y0XJXdPWphVIT6uTmtfwsYwW1usqBkUNhiUV3EAXG0UNm1XFbkr5RqQot6ZemFLmSloz1bR2sl0tlRtaLc9q7omCzuk+bc+1leqe0WrnRZW8ZXntqjZu7MifTSvtLGj1vprCq/O6Lyqo22rLz6V1OWtdC9Kas1XXINam01T6aUeZdNV2WVt/PWXSOcX9tM52enKsPV7aFg1j9VXQ4kZBL4Zbaq2Gun+1oFw1UOPBrnJbkaJnsxo6LbXDoXrzA21udJVXWtW4IS+7rLCxrEKmpXahotRsSRtXnlIlvajcw1flViPdt72ol67lFaWu6YX5rmaffoMazrryubzi2UBdr6OgPaP+cKhS1lU67imvWMNOVe3+ULWir3Iprez8QEk9dyvyb/USvK6csJy0gbcogq1Fe15WUbonv/dgUozRmhcMeoFSAwtMDA4umGB3QrlmTqXFXNK30nVddaM5bV+qKbJepqmOomhWuVyogVNVYbBhC8YKc7aC2tdQls4t9bvbCnaGKocpRfNZbRaCpLVI2Z/XrG+pMrGCoUW8uoqDjLK+Ly+6oRuNlipxUY8UZ9QrugozNYWNWPfN5dX2A7W3I613thV1clpZWVKp4ynOt7WwOafnmk8o6q3oigaa726r2fSkfE83tlrK+Xm9WUNdDiJd7ntJoCN0huqmWjobdZS2fUKLHfn5QLlsRlHVU60fazYOlE57kpNXMT+jbC/Q5saGnl/blr/kaNnaLJ5bUOHZ69rZ6Kv+bEc3cjPy10Ode91DCluxhs2Otrs91es97QybKiye15K1hyzm5bld5eOC8q6jrGUtDD3V622tr29ou5NSXAzUSzXU7fvKZ9IqnZtRvhwmwZr6qi+v3VR6dqDFXKx8rqhWz1d72250B6r7gYadSFnnuipnZzQoNORseaqtBxosRQp2Cio0t5U9Y21AHWWCripRWtdXPRW3Owr9oTrVrGY9T7my7ckKVK8/rLBxSV7V00Il1NCNdXVrVc2mm/QYzsSBltNDpUNX19fburTWVKvZU9qtyO8sK9C2ctmc/JnFpKDkoBGqspZWzllQw9tWf2ZOgebUbK0rM/SUKZSUGg6l9JI6wYYGA9ub1UhSdlbm2ir4WXk5q91QUTzMabuzrn7OUbGaV2yBheGWZrMPSJ6bdLHIFCzbINClQUeLhbRK81UtFUtq1jdUDNaSgiqNflFrsa98GCoX2A26bVMJFfc61v5WA3WUt89Ds6OtTqTZiqtzwXySYtRL5+SnVpJ2qrm2tJPdUWErSFpwzpXyiga+ugVPqXpXRaekwPqlWmTQG6qxmdFaoyQnO1DcXFc/1Vc4DBU2rXxiLNcZKiqXFQxdOc22bVpJukdY0wtLv7AijrF1FGn2lbLii6mUeuWtjxXHqS/IHbSVaecUnZ9RNKwq1VmTOzivTuGG8lFT0YBK9cBBoa4CgGnzXMlT/YWXlZtz5GZi3f/8BV0+ZwXhLqh45bJSwzWF8QW5czWlw7QWrs9r3blkBdDUtvlaJqdiu6hy9LG26muFhgbejsLrOQ1aKyqt9LRYGeoNSxVtvHag5z7aUSG1mCyGzeaH6sQ9DfqzanV9FefKWnooUD6IVIvL6jzY1uM3mtq+sq37g6r6/Q2VyhfU2LmsjdmC4lRBD9WWtd3zleo4qma6WpWv2XwodxCov1ZQuxXq4qy1N2xomCtorZ9VM+hofdhSfTWnx4rZ5NhmCnPys1l1e7Wk/ba1crfi1Y1+I9ly7Wy6ymZbyqUqinxf1zqb+kX3soabZ9SdvSrvvmUtPtLT+e0H1Zrf1JXKIyo1hmqvfkDDj26oaRmmnq2mP6Ps5qLOdi5q1Y81O+vqt+Zb+qTr53R/pqhhVE+KnPvFvkK/rXyc0bY/UKE3q9fFM7p+tq3G/Jb8XE9zO7Pq2WJcYSBnNaur2ZeVf7ejzWxF15/b1Oz5QTKHrCxW1RheSTptXG5vJ135gkFLM89lVdSs8tGmZjbm1f20yxo21xSunNPilZSG8ynNdgsqZyOdfczVh67c0Mvukv6Y/4DOZXy9V0/od+fbyvVzeqA41PlPmNPq1UizPekR2857I9RmVEtugMNoRs+WGsoOMyr1aqr7sXpOVvkVXxeuebp8tquad0ODtbpWCo+pPnxGjWvLmru4rk5hM1kwbD3l6dznrmind1WZi6GaqwNdfO2cmu8aKv9ArOhiSqnrgWpBqHTnovKVF5MChdVMRddrkTZqPZXmHBWKQ/XS1mLRUeyFaqT7GmiYZA/P9cvK+CldObOtMGgqtXZRz8Ud+b2hUs9l5ZQcnbnuKy60VZ2v6uWlSItDR1G8qejignRN6g6e0GbvPvmFsuKdS7JGeG8qh3ohPaf6y8tqLl5VebGhVjiv6IWunOBJlefn1Wz78gc9NbNZzVVbcoKUes2SKuVIgf2e+DU1Bzm991JTq5GnP+hnla1sKgpW5A6s0YCf1Epw1Vfsekr5KaUGAw3DalKMMZIFG7JJSYK4m0u2rR9YMGG58KiaqQ+rOvOQCtUrutYsqFWvyV8s6Fr0koqB3aRIw9BXbzVWb7asYdVTMZ1Tyu2rGrVULJTVKZRVSncV1+rKW0ZO5azm5xaUycTa2NlWN+7LSafVjUJ1eztaqVY1n32tsuVVhVsZDbJ9Zdya+kFaGb8k3+2pVHU1zC7rykZJsbuUFH7s5Pqq1dvyuxmFcUVtN9YfyEdad/LabN1Qv1ZWKdXWB5o7+oh1M4gHSvuOCrGjQdjVR63to5vXWx9c0hsfyCRtIfPOnAbFnoZlK1rnq9mpaXvQUPb6trY7nrZ6O8qHWT2aX9DOgwOtd0NtlRaVejlWx9pm1mO1eqH+6y/9uj5yuaGlM6F8J9BMKa/7U02tX+popziv7ExB9XJe3WhHixlfcgPdqK3rerOlqBlrpeoqdgqqD6wHqafMbFb+rNU6cFWNrIVKSt2gpmIcq5qpKizMa8YaxJzLJVsP7m91tJbrJ+lC28FQ+Y6nYnGgxoqj7f5lNV++oNL8jFbcjoqVQtKK8pwVBXxkRlHY1IIaag2XlFmsyqu6Wh6WlO2mVPekamZembKvQT+nxo2m4m6otL1fg6yGKqsTR9qp19S43lW/2bKMIYVpX07R2lWWNZfJKUzXtG7FMGvb2uqXNWxaJVJXHf+qFvwZRZlYM/fPqLu6ITd1nxR/WKl+Wo0nN+Sc76swV9XCmY4a7Yrs1rp8JqezW0va3mhq2wnlB6GCYSzP9t4V7fz2kl+FfqqlOds7tePr6g1X+aKrYianYbgstWO5jYG22001s2Vl8lIh11Mua3HAigqhq3a8mXRZCNs99dyUtnc8pQs78uqh/OEFKRvL2wl0o59P9gIOsymlcmvajOZVzAaa6YTq5a2eQUaKd9QJq/Kiunb6rjotT90N69xxRmlnTSmL1KWqSrtnFFt14ygrt7+ptrOl0KKNg7RCzwrH9KRhLumn7OaaijuRBoGTVKH1wx0NLm8pM7+keGVdXtRUmC6r308p529KrZKiYl3d7Oa9zkMA3GFQgawEAJMmlc7qDWdfrxcam5ovPKMb/qeo9sCzOvfcWQ22CsoNq+o82lB6K6doxlU9rmnBuU/lhbr8blVR31d/aUtN11PnekuRVYOr3qfYH8rt1+R3y6ql8nqv1nXeO6duzuY6G0oNWnq6sKxsblXVKKOloKH0tTNaWgy1uXZdW1np9b+VUevNPbXbdrOWVyZ2NFzb0vmZWZU8X88/+rK2n1tWP5CKuZ62Q1/VlUDRDbvZsxvskjLzLWUfzqtUXNCVZjvZOlxzHHnOsj4xX9S5cl8pS2t1Q0XDQJHjqJjJyPeyanYCbXUaOpMtqfRYWo3+iq51N/R8/GG1h6/Rm58+r/fI0eKfL+h1wQX1M08pXAp1oV7W8HxKrZkdPf7h1+n69ed1vTUnf2ALRDktLp3X00t9zV7dVJBb0iNby3omuKJMaVbLjquU7dUNHC1Y560tT14tr+5MX9FMQ3M1Kbd2VpmFgq7NxNrIrGpxI6PN3EAX7YbxDxdUe3FWy52BLpyvKP/IrLR4Q8vBOS2mXT130dH55wINUimVhmW15OrFN3RUipRsWS99ZF7eedt60VdjXeqUB3r9a8/rNUu+Hls8p0trW8rOPS/PeVgPPjunHT+tS36oK4tdFYZ1hU5GYbus9TnrBemoUJ/RjrVnd25IBVtUltI7RWWrQxUWKnIaReVmanrEyevaMK8NpVQ7l9Pbdi7o+YcDbV6b1RtaTbnhnN7/5p6ataaG0Zz6qy+punxRm+51FVfm1X1kS7UXCyrNlVS51le2fEX1uKKsF8nvNz/WkWSmrGa5Jm+YVcHpqZjaUrtT1SCOFOcLirqO6plApZmsznTO6MX8qoZeQ6WUo65T0tbsqh7tPaja2ZLmclek8oKe9RuaGw61uVLSZzdS+pDTUTiTV6XnqbPQU7TuK5ee1XsHkUqrkZrVS4quteWvFOT4HW1drWl7XbrYzmn2YqhwkNPA7uwy11TKlDXTSSm0jiFzvuLyjnK1porXK2pfT2lzIdYDJVf92Bb9LavbtjqnlLQc0TDZ8jCQBUwieeFQTiYj9dMa+E35rmVJO7cfH+50IBnGO6o6D2lYjLR1JSd3J1J+Pq2qH8kfvElpt5EU8xs2PfVnOuoU5nTG8VRxU2pkYnXDodxMpIrvSp2BbqR78vJpZedaciqBbmy7+vBLDYWdVS0UY8X5JXVzsVadG/KyXS0PZ9WYCbRR6yrrWOq3q244ULd/Q8t1XzOZT1BhZku1wbaaxUgvb6TltHoq9zeVjuoqpyItLZ5XvWdbNTI603NVa8yo80xbQdDTrB8pO5NVt+Qo2GrI25HmX3teFx57VHlL82mta6ezqnJvTvfnFtUKGtroN7Wz3dVvPHVDBRtU8o5y/px03lcUnJfzwoek3rYyLUedXEqLuay0XFbJ6h+0NpRzK3rdQ0vK93y9vLquX3nxms7cn9Jfui+vRmdHcdhTruSrvebr8saG5ryi3jAX6v3Nuq5t9zRsRco4Q1WGKYVX69roR/L9odIVKZ637Rtz8qzaa7SmTtGXbykugTQsZpT3ckp3YnX6We0EUilwNec0VKs9JDcbK3D7WrthxToC9c5WNFO6pvhyT+vZc3IKNaWcjvqbZe20bF/+FXluRXPLM3porqrAi3V9Z0uFYiQvGyrlDFXvSsPNnirVWDMlqVctys04yuXyymZjpVopKVtSqtxTf62r61d62mzNSp26orChYJDRXHxOy+UNxbllnV8KFFRm1Bh2deOptMJmV+nKQ2q7LS37Oa0snlVme0erq3Wtrw7lDCPNVIuqbfXUDIaaz6aTVJ5uqi438NVZCxVa4RE3Ly/fVTczkJ/LKSp01ehZe1JHXqUsP1+Rlx8o9Ha0bbUTLIvDqylfGMp23FzZcDSTL2q5L3XVVqM3K0UbyvUtUr2uTi2j4kN9zTXz6izGytTOyoZFV/O67gVJsZmSYgWtqqL0UMViVl67q/6lbhKwCfy2QrcgV5WkNamsbkjqioI4o1TGzqm9x7GigSfXD+X4PYWBtR9NKbSLYCGWk84r213QoDmvoXd/UlMh3Wtr4BXlF1oq9yrq5i8rY9sbelUl+zcAHAoyFQBMuk7U1dNra3pL4UE96TQUdBt6/NeK+nC5r35cV3Z5UYVqRrnlHT2YnVOns6Tr/oautSrKdjaV9yOFzbT6MwP5PV+11UD1HU+Lzqzml4eKF5tqbgWqv3dWO+FTuq8U6frqslZTl3X/VlXhjfO6cs46XMUqlZ5Xfruk/nZHyw++Ri/PtTV/dWgbGNT1e9r2luTe/yH129Vk+6rTXtG5ywNdLrl68uwVzbfPKnomr9iLteCkNfvWji7n+rpyKa2m21Un11Nl6OnRkq/c4lBzdt8SnVUvtI5uAxUyBVXSC0kguDvoyXGHWpldTNLh/V5Fl156Sc89tqnZq/fJiTKqP9bSXKut1tmizl2J9MJLsdZ7RYWPvEvl4WOq7swpvjhU8ROz8p4/o8FzTyjdnVeueFX5F0rKPXi/mi+1Va12VXu0oec3pO36nBaz65rL55RpF6VsV8p3lR5mlEmVFVSlG9m2cvGWzq/OqVfx9Gy+pcrGvPJxSk7e1f2PDVR64IIqD2VV6af0/GBOqexQL+brevPmRb3n4ge1cv1xpeOWnl5eVXHLUZBzNejPq33GVTdrmcLb6nfzUrmo5ofW9ExhXpXX1PTIfQ/qarejX9n5kN7Y8zVbHup6ta/OZk5hOK8LpZzOa6hW1jrbucoPQqW9rHJRUV5YULPY0dMPdJWzlujpTQ0qa7qQfqs2thu6OluXd/miWg+/W83BjDJbr9egsKUbg7r8pYFaT53RA/ev61q+pkFuXtINRddyKixn9cmraT3pb+qjDV/3bRXV96qqrbQV9ttKNdLaenBWM5EnNdqqVTJyB0tSy0ophrq/bwvKfV2bHcrt+nLtvra3pZLVlSu0NBi4msl5em6xqN5WU/Ptpu5Ln9eGbRNJFVRM1TXjPKxfG6wrXb8iLd6f1AEcptvq9jf1+uqjeia6qlwxq+xCqIp7n3pOTtHwBWWv5rS5ntLTV7f05sKMCvNN+Vlfs5szyuZ9hdYtLq4pux0pW8+q1Uur1cmq6gXKODn1w7Ri1eWkC4rTG4p6F6TIl8K+oiBMahE6Q2sDPyOnHymwjO32ijw3VmRdEQ4qmJD2cqrnd+StfWw1tlEMlclktJrZVCnjKt/JKAwGapcyGgZ1zcRSdhCrn+pJvYEVXVBt2FUzaMizQiXhQHGwqHQ/q41rm3pxVYqaQ+WzFWXmCgrToWa9kgqZvDKDjLrDjuKgLjfOqBUtqBx1pEyoyFlRI3Vd6fBZeYUFOUFG+c1I5dhVIXdBW4s1LbQfVb7c1U7OUbXl6I2FsxoUXpTj59RotrXT6arpLqvTyCqvjrK5cvLzqwsVlfOunrm6po88saHlQlGPPzJUNNhWMIjl5tJJa8wgbScy0py3oMX7qpqbKSufjfXUUl4/E39E6+tZLTl15Qtb6jmRLhTmtfTgWfWXA1XyK8kK9+9dly4EPa1kPJXLZcX+puajkgZeU883LRsgr9c8VlAzrujJ/qq6l7fUbgWKczk9u51V2mko5bWVXpxXzipwbrWTiv69lZxKYV1e84Zy1YvqeFk1YiuqkpOXGWhn01OtZavfWWXKeaXLDc2cTalf97Wdm9e1zeu6eKaoh8sP6F2thjYG71PBW9Ry9s3KnVtVa6OjG81QuWxTmaWZpArvsDXQjVZGwU6gajlSuryiYNjT0C9qJZNSb9lTq7WlYi8nL29Rr0jKDZVLtxVEsS4PQ22sp5Osk1w10kavr8jLKCp56gQZpQpnVF1Mq1vIqPtCQ57jqpEeaNZvqtPMKlr0tbm+Kq90RudV0MDtqpVuKTfraKZyXqnWjnZiaeg78ttFRaGrfNhUN8pomIrU2Wkqk7IMmaZcr6BMKqsw01TYbKkT9LWYKumsP6vtjvSMbTvwehr2c3JLjsrDlLq9gcKFjEp+RWkrPNML1NUNDeKhqpWsZtoFdavX5GycVT6VUhAV1Z6JtNzKquf7cm3LkJtJiiEO+m3Vo64i24OYKynVt4BbU3E+pSjlKeqWFfTKSrWk0M9JcVluKlYqb78rAwVOWa7aCr26+lFOuXJOC2dizZfPqxoM9Uywrusv+Bp2cwpvWNuOkjrFllLBBaXO+XIvleV71+51HgLgNshIADCpzravqf/geW18eEt+9YKqcuTNbKlY6Ks811X5rCsv2FG329dLedur3dV9lwb60M6mGuWuFqq2p7+oOMqqk99RUNhR7uK6+itL6lzJKX+5qcL8rELbVtkvqhRldGF2oO7l86rbKvEnudKNWe1kh8qXrYh7WZcqBT162VE/87QaSw/LW3f00OyCPpj9kB7cfFwb7Z5K7pbyTlPvm5tRdSbQG4dnVZ9pyrkxJ+dMU6X7MvL8sqLNrHY0VH3meRWdgmZyJZ0rVbRQPKN+kuYdKxVam7xCUrQ8iEJ5bkpx3Jfr9LQ885D6QVtPrD+h54YdeasplbrbCn1L2S5o5bFI/d8N9GJ9TVe2z6oUSFv9s3J/qaxMpaGF+0KV/9CyHip7ev6DRfUfH6p8fkGptBXBvqaZ0LqphXr4Rkqd1UhPLG/LK/Z0v5PXYzORUoM5Ra2svGhV9SBWUJ9TuX9O8cyGNrI7eig8o4uh9FJ/Xe1yVx3fSbZzdwuLatX7anStuGFPJe+MLkQpfai+qYvdiwpcVx8u1/XY04/pyv1rWmleVb67oGvtvOKVNbXXZ3QuXFanGmnTb+lac6DZNVeX5zd0vhHq/vW8Ii/WY85Fva6d07P9Vb0/elmhHyg/s5wUiIzbA7V7vlpxV/XCdpIl7FYGWk5XdX3W1SATa2H7IV0rXlHQKqm4LvVe/5TOfPQRbaVt13+odGGgempGrUsdlcs7mr0/q+1wSSu/u6b6Q4+ovNRVZ7ipj6iv7pqjVGtOVxd2NF/cUba9otrgPi3NhHq0Y0XwrUbkGcW5kvphXe7Q1cC1uXpbQV1JjYulnqeNXqBmKqXlmnQ1ndJcMKfeMNRMZ02O39b6bKwXbxSUTb9ZD8w/p63ZnMr/r6DgTdc0k/80raWe1OB6S6liRun2grbchh4qPqTnb3xIXnFB65nLGjzjqHu9rE29pEHaCqy/Xi/WN1XInpE6H1GhtKBis6CKk9FKaV5d22KfHaqatQVNqZefU3Y2KzmWsTyryJrKh1bhv5sECTzPShc4SrkthWFWcfJd1tjUk+O6CrNthbb/4jacmBLTAAAAAABgDFbKEQAAAAAA4I4RTAAAAAAAAGMhmAAAAAAAAMZCMAEAAAAAAIyFYAIAAAAAABgLwQQAAAAAADAWggkAAAAAAGAsBBMAAAAAAMBYCCYAAAAAAICxEEwAAAAAAABjIZgAAAAAAADGQjABAAAAAACMhWACAAAAAAAYC8EEAAAAAAAwFoIJAADg1Lrvvvv0J//knzzuwwAwgWPDX/krf+WV//61X/s1OY6T/D2pxzgN7Bz+zb/5N+/6+1utlhYXF/UTP/ETOko/9mM/lhz7+9///kP/WU899ZRSqZSeeOIJTTqCCQAA3KEnn3xSf/Ev/kWdPXtWmUxGZ86cSf7bLvwnwW/+5m/qz//5P5+8Pt/3ValU9Mmf/Mn6p//0n2ptbS15jE2m7uTPJE24AUyX0Y3b6E82m9VrXvOa5CZ0NBZNi5//+Z/XP/kn/+S4D+PE+L7v+z6VSiX9hb/wF1752o0bN/SOd7xDn/VZn5X827Rcg975znfqe7/3ez/u66997Wv1uZ/7ufrH//gfa9KljvsAAACYBv/1v/5XfdEXfZFmZ2f15V/+5br//vv18ssv69//+3+vn/mZn9F/+S//RW9/+9s1rWzS8m3f9m164IEHkpUu+7vX6+l3f/d39a/+1b/Sf/gP/0EvvPCC/tN/+k+v+r7/+B//o37lV37l477+2GOPHfErAHDSWCDTxlobi9797nfr3/27f5fcnNuKbT6fP9Jj+fRP/3R1u90k0DoOO95/82/+DQGFAzAcDpNgwtd//dfL87xXvv7MM8/on//zf66HH35Yr3/96/X//t//0zR45zvfmXyW//bf/tsf929//a//df2JP/Enkuvugw8+qElFMAEAgNuwi/lf+kt/KbnB/o3f+A0tLCy88m9f93Vfp0/7tE9LMhQ+/OEPJxPfo9TpdO55Um2BEAskWFaCBQX2Tpa/53u+J/lj7HXu9tu//dtJMGHv1wHgXv3xP/7H9da3vjX5/3/tr/01zc3N6bu/+7v1cz/3c0lwdz/tdluFQuHAT77rukmGBI7P//pf/0sbGxvJtWq3t7zlLdra2kqC/Rbc/3N/7s9p2r3tbW/TzMxMEsi3oNqkYpsDAAC38V3f9V3JTfsP//APvyqQYObn5/VDP/RDyT5Oe9yIre7bfta9LN3VUjD3+vEf//FkQpTL5ZIJkaVwXrly5VWP+czP/Ew9/vjjSbaArZJZEOGbv/mb9aVf+qXJcdiqzV6f8zmfo0ceeeS2WQn2/ZZlsd+qm213OMg03dGe2Z/+6Z9O0jntNf+BP/AH9JGPfCT5dzufDz30UDJxt9dsGSB7t2PYZPHChQvJdpPz588nK1W2arjb6uqq/upf/as6d+5c8riVlZUke2Tv8+1lkzfbr/r3/t7fO7DXDODe/eE//IeTv1966aVXxtlisZgEfG0V11Lcv+RLviT5tyiKkhTy173udclYsrS0pK/6qq/Szs7Oq54zjmP9s3/2z5JxwsZUS5W3LW173axmwu/8zu8kP9tu/CyI8YY3vCFZPR8dn2UlmN3bNkYO+hj3Y+Od/cx/+S//ZXIsFhS357Brg11j7LktmGzPbWOxjZHb29uveg4L3ljavW3ts7HUVsrte8IwfNXjnnvuOf3ZP/tntby8nLwee067ltXr9Vseo702C9Z8//d//y0f99//+39Prqt7V+rtfbfr5r34yZ/8yeQabM9VLpeTDIfR+7hbv9/X3/k7fyeZCxQKBf3pP/2nkwDHXv/23/7b5H0dbYn8mq/5GtVqtVf+3a5t//t//29dunTplc/F7jlDOp1OHmPnfpKRmQAAwG38z//5P5OLvGUg7Mdu7O3f7XE2gRjXt3/7t+sf/aN/lKy22OqbTUxsUmXP+4EPfEDVavWVx9rqi63W2QTNsgFs8mkTGttu8Eu/9EuvKiZoN9P/9//+X33Lt3zLTX/2s88+m/yxn2uT8qNiAYH/8T/+RzLBMt/5nd+ZHPs3fuM3Jufwb/yNv5FMqP/Fv/gX+rIv+7LkdYxYEMKCO1/91V+drFS+973vTc7X1atXk38bsUmtTbi/9mu/Nnl/1tfXkyyKy5cv7xvoMRYwsvRSC9LYBBfA5LCggbHf+5EgCPRH/+gf1ad+6qcmN8yjTC27KbfaCxZQ/Ft/628lAYgf+IEfSMbU97znPcnN2iiYar/rFhCwP7/3e7+X3GgPBoPbHo+NJzZuWaDSstTsJvqjH/1osoJu/23HcP369X23gh3VMY5YwUJ7vI2HFiywsdWuORagsQDJ3//7f1/PP/98Mpb+3b/7d/UjP/Ijr3yvHaNdH+wm2v628diOqdFovBJEt+e298Futu1n2Lm4du1aci7sJtqC0vv5h//wH+o7vuM7kiDyV3zFV9zyNfzWb/2W3vzmN+ug2ftjmS5/5I/8kWS7hLH30d4Dex93s9dmgSO7rr788stJMMiC45bhN2LB92/91m9NsgvsOmXbMGyLzvve975X3td/8A/+QRJksevWKPNv7zXYghsWTLDzbAGOiRQDAICbqtVqsV0u3/72t9/yLH3e531e8rhGo5H895d+6ZfGFy9e/LjHfcu3fEvyuJGXX3459jwv/vZv//ZXPe4jH/lInEqlXvX1z/iMz0i+9wd/8Adf9dgwDONz587FX/iFX/iqr3/3d3937DhO/OKLL970uH/u534uec7v/d7vfdXXoyiKNzY2XvVnOBx+3Pd/zdd8zatez52wx2cymfill1565Ws/9EM/lHx9eXn5lXNovumbvin5+u7Hdjqdj3vO7/zO70xe66VLl5L/3tnZSb7vu77ru255LPYefe7nfm7y/7/v+74veY5v+7ZvG+v1ADhYP/qjP5r8/v7qr/5qMvZcuXIl/smf/Ml4bm4uzuVy8dWrV18ZZ+1x73jHO171/b/5m7+ZfP0nfuInXvX1X/zFX3zV19fX12Pf95MxwMa8kW/+5m9OHmfPP/Kud70r+Zr9bYIgiO+///5kDLHxZrfdz3WzMfIwjnE/Nnba4xYWFpLr2d6x9Y1vfOOrxvYv+qIvSn5er9e75Zj7VV/1VXE+n3/lcR/4wAeS5/vpn/7pWx6PPcbOifmGb/iG2HXd+Md+7Mfi27FjtPHZvudW7Ofvfp/uxNd93dfF5XI5eU9v95l829ve9qr34eu//uuTa/jo3I7er8/5nM9Jrs0jP/ADP5B8/4/8yI+88jV7T/ebJ4y8853vTL7nd37nd+JJxTYHAABuodlsJn9b6uOtjP599PhxCjtaqqutEG1ubr7yx1Z1rJjUu971rlc93lImbRVrN0sPtdReW+nf/fNtJeoP/sE/eMs6Drbisd+KiK2YWBrn7j8f/OAHdVBsBWh3doB1jRhlE+w+16Ovv/jii698zVJxd++PtvNlr9PmqbaiN3qMbdmwFbe9KcP7sVU6W4GyVSlbKQNw/Gxl18Ye28pk2Vg2Tv23//bfko4zu9nq726WoWQr4Z/92Z/9qnHVVnrtOUbj6q/+6q++slq/e/vBfgXx9rKxxjIJ7LG7s8fMflvZ9jqKY9zNtobtzg4Yja2W4WbbunZ/3X6eZRXsN+baNcaO0zL1LEPs6aefTr4+em7LkLOv34qN1baab9sIbIufbdW7HcumsO+zrICDZu+fXUssQ+F2vvIrv/JV78OnfdqnJds9bLvC7vfL3h+7No9Y1oVlF9jWhjs1eq12vicV2xwAADiAIIH9u00wrPbAOGyPqU2QLHCwn1Ga68iobeNef/kv/+XkRtgm2vb/La3Saiv84A/+4B29Pqv5sJtNZkcTq1/+5V9+VT2Ig2D1DnYbTUTtpmG/r+8OCNg2BUuxteDJ3kDBaG+uBV3sfHzDN3xDshXkUz7lU5J0ZDs3FqjZ7dd//deTCZ6l+VInAZgctsffWkLaza79Hlv9l903aMb+zfbm7x1XbSxYXFzc93lty5MZ3QDuHX8tgHG7m9bRlgurY3M3juIYD2rMte1iFmS17Q2jAPTeMdeC1rYNwgpkWiDbbrI/7/M+LwlW7N3iYNvy7Jpjqf83K6R5Mx9Lbrg7FpDYvTXEgiR2bLat7qd+6qeSLYR2jbUtJBbg/2N/7I/d9jzO/P57MDpfo/drb60iu25bvYrRv4/zWu8kOHVcCCYAAHALNtGw4knWqeFW7N9tQju60b/ZxX9vwSrLSrDH/sIv/MKrWl2N7M0Y2L1CtJsVMrQVLVvlsRtm+9uOZW/V670effTR5G9rT7V3gm6rgsb2dB60/V7rrb4+mlTZ+bOVPJsU2s2/Hb/VjLBVNCt2ZudzxFaG/tSf+lNJ0S5bLbO6FFabwSbEn/AJn/DK46xIlu3ptT3Ntof5qDtyANjfJ33SJ73SzeFmLHC4N8Bg44DdpNtN7X72FtI9Dkd9jHc75trY+Bmf8RnJqrp1FbDih1Zc0eo22Bi8e8y1NsI2Dts+fwtCWx0IG3Ot68/ugM8f+kN/KMl0s/oQdo26k+KJ9hi7Vt5JptnN/Jk/82eS4PGIZURYPQh7H+x47Dph12L786M/+qPJtdQK8o5zvg7S6LWOu0hxlAgmAABwG3ZDasWhrM+5Ffnar5igFWKyVZndqxW7KzeP7F2VsImZTULsBtZW4O6FTXzsGG7cuJH0r7bq27dbubLVE1vxshtuKyR1GC3VDpJ1fLCCkTbBs9c7crP0VDu/lp1gf2wl8E1velMy4bVgy4hN1KydmL23tv3C3mcLIAGYTvZ7b+nmdtN6swCsuXjxYvK3jQ22ajxiRXBvd9M66ihggdhR4HU/NwssH8UxHgTbKmaFf21LnhUFHhl11NjLuiDYH8tksIKJ9vosQ253QVvr1mNby6xbga3+/5//839uu5XQAtx2zm72c++Ejf27z9nucd6C73attz8WILFsBbvuWxDajvdOXfz998uyA3e/X5YRYce++7Nyu4wDe7wFyu51bnCYqJkAAMBtWGVrqxBuq9Y2qdrNVsit+r+t2tge0BGb9Fj65+6MBrvJt20Ie1dKbKXDKj/vXdmw/977827F0kVtcmJ7/63GgKWX3gmrPG17Mm1P537tJQ9jxeVujVaFdh+T/f+9Lbxsz26v13vV1+w9sQmrVRvfy1bNbGJv7SUt82Gc8w5gsthqt2UxWfvCvaz7wyjQazd2tpXMOhjsHlMssHo71lXAgsD22L2B493PNQrQ7n3MURzjYY25dmO8t3ORbX+w497Nggp2M7zfmGstNH/+538+6ZpgN/B7W/vux1oIv//977/r12LZe3Y+R38so8/sHe/tmO34zH7Hfitve9vbksDEv/7X//pV58xaL9ucwIL8uz8bt2qbaVsVLXPuZp0wJgGZCQAA3IatStgeT7tZt8nRl3/5lyeTSMtGsAmCrXRYj+rd6fFWLMxSQK0HtaV62s2t7Q+1FQZLD919g2srNt/0Td+UPN/nf/7nJze8tiJhgQcr9mTBjDthabG2ymOFvayg1O5Jy6188Rd/cbK6Zumo1mbRjt1eixWksq//5//8n5NjOozCV+OybQ12zuyc2NYGC+L87M/+7Met0Fn2gmUZ2ITdJoy2qmXnc21tLXl9N3ufLTXXVsusxZlth5jYdlwAbsrS8i34a2Oapa/bHni7IbfVfRsfLfj4BV/wBcmYaWPJqDWttV20woqW5n671HK74bQx3W6ELePJCuNai0grSGg1BixlfnQDa+w6YOOK3ZzbGHQUx3gQrLitjf22JcBegwWsbUvY3iCzjZcWULdCj3ads8CCPc5erxXW3Y/VsrEtEfaa7LVahtzeOkG7vf3tb0+e08b3vav1o8wHO/fGHmdZZuZ2RXWtNbItDFibTAssWwahBW/sfX3sscc0joWFheR6bgsEdj22uhGWpWDBl0/8xE98VZDfPhvWUtIyCu3fbFujfZ6MBfZtS4ZlSEy0424nAQDAtLB2jV/8xV+ctC+0dlZ2Gc1ms/GTTz657+N/+Zd/OX788ceTNlGPPPJI/OM//uMf1xpy5Gd/9mfjT/3UT40LhULy59FHH03aZz3zzDOvag35ute97pbH+FM/9VPJ83/lV37l2K/v137t1+Iv+IIviFdWVuJ0Op20ynrrW9+aHPONGzf2/Z67bQ05ag22t33Z3laOo3Zsu9uNPfXUU0l7rmKxGM/Pz8df8RVfEX/oQx9KHmftu8zm5mbyM+w82vmsVCrxJ3/yJyfn52atIUesDVepVIo//dM/fd+WaAAO16gN3/ve975bPs7aItrv98388A//cPyWt7wlaSdpv9Ovf/3r42/8xm+Mr1+//spjrH3ft37rtybjnj3uMz/zM+MnnngiGRtu1Rpy5N3vfnf82Z/92cnz27G84Q1viL//+7//lX+3doNf+7Vfm7RmtNaGe8fLgzzG/Ywztt7s3L/nPe+JP+VTPiX52WfOnEmO75d+6ZdedT6sBfGXfdmXxQ8++GByXZydnY0/67M+K2nvebvx31oUWytka2+8u53iXv1+Pxnz92vfa897sz+38zM/8zNJK8fFxcXken3hwoWk9eXu697NPpPvusnnwlpB2vXHrqVLS0vxV3/1V39cC9FWq5XMKarVavIcu9tE/sIv/ELyteeeey6eZI79z3EHNAAAmEaWrWDFpmylwf7/JLBVHstu+I3f+I2kmjYAACeFbQux4oiWwXGzYognwed//ucnWSB7t0ZOGoIJAADcA2s/+I53vCNJa/yO7/iOYz+XlgZre1Cff/75iW4nBQDAuKylpBU2/J7v+R59yZd8yYk8gR/96EeTLZW2/eVuW48eFYIJAACcAFazwYo92r5a22tre1sBAAAOC8EEAABOAMtCsOJNX/iFX5i04bKCgwAAAIeFmQYAACcAJZAAAMBRco/0pwEAAAAAgKlHMAEAAAAAAIyFYAIAAAAAABgLwQQAAAAAADAWCjACAG7bJeAoRVF05D/zbgseuq479cUY7+R13MnzTfL5OA32vkcH9X5Q2BPHNR5P6mdvnN+tSXgNjM24F7f7DBNMAABMFJukTcIEbNomZxaEOeiJ/zjvg/1ce/wknpuTbr/3afR+jP6d9wQAcNC42gMAJs6kBhMm+WbZjuluAjF20zkKROx+jXf7Hux9Phy/UWCB9wUAcJAmbzYEADj1JjE7YRREmMRAwm53G1C4lwDCfs/Hjevk2f0+8/4AAO7VZM+IAACn1iQFFCY1G2GSzx2r4UfjXjJICCoAAO7F9MyMAACnznHfFE/ytoZJP3cjZClMNrIVAAB3a/pmRwCAU+U4buR3BxGmMZAwQkAB4yBbAQAwjumdIQEATo2jXGE/CUGE3QgonFyH9Xtx0DU0AAAn08mYKQEATrSjuiGe1i0NtzMpr4mUegDTbtq2bk3b8WK6pI77AAAAuNMbYpsQ2cToMJzUQMLu13dY5+5eJrgn+ZwDOL3I7MFp+IxyBQcAnOoMhWkusjgp2R330lGAFbOjPefAtOAzfnAYa7F3znNQv18ne+YEADhxDvKm+KTVRziuYMzoee/muSn6B2A/0zwuT2IghIDC6RYfUh2c6f0tBQCcWgcxyTwN2QhHFYwZPe+9BhXIUrjz8w7g+DBeYVrEh1xM9/TNogAAJ8K9XBxPayDhIAMKNzuH9xJUYIIOYO84M20m+ZgZY0+X+Ag+i6d3JgUAOHU3xKelPsIkdMi426AC2x6m90YFOGjTNFbTThWn8VoxPb+hAADcww3xaauPcJgBhXECMnd7zllBAzAabybR7la3k3qMOJ3iI/w8MqMCAJz4G2KyEe7t/N3rubyXbg/2vdRSuLfzCEyzw86iOm0I1J5s8RH/rhBMAABMvVvd3BJIuLPzd6cTkOOYiDL5BU43AgrAZCKYAAA4EfbeDFMf4XADCneaMcCK4sHgPOK0u5duMXg1ArQnU3wMvxsEEwAAJy47gfoI934ODyKocBgtKAGcXnsLuxJYmG5sYZt+qeM+AAAADopNLO0GF5zDk2Z008TnG3h14HPvDSm/I9M1ptn7R7B4ejkxIT0AwK0uFFN2c87E5GDO4bjv+37ZA2QmHLzRjdO0/V5iek3bZ213cGHajv0oHXfG1+7rw3Efy0kQH9P2H4IJAIBbXyiYjJ1KdxNQ2D0pJJBwuAgq4KhM8zXgbsex0+K4buL3q3FEMGE6gwmEgAAAwMdPEO5ygjmqo4Cj3zvOeQc+/vcEk4ex6uCRmQAAmEis6pxex72qx2rV+MhYwEGb9msAN643Py/HGWwZXV+O+zhOkugYrtm8cwAAYP9JwgFuV8DxZCwApxm/A5OL68vJOKfUTAAAnOhVKUznagerVQeDYnQ4zdcAggk3Py9kA5xc0RFes2kNCQAAbskmnXc6OaGF4eS30Jvmm0NgEgIJB/ncBGpxnNfse0UwAQAA3PPkZDS5Ht28cuM6eXhvcFocRiBh93Me5Ko+2ROY5i0PbHMAANz6QsEqJnbZL6Bwq5TZuwkqkIJ7NNgCgZN2DTjMIMJhbQs4ymACY+vpEh1BdgLBBADAiZlI4uircN/pJHucoAIT3qNHJgmm+RowjUGEkaNKR2dcPZ2iQ/58EUwAAEz9RBLHM0G5m0n27VbDmfAeL4IKmKZrwGGt6h/1OHTY2QmMq6dbdIgBBYIJAICpnUji5N24MumdDAQVMOnXgGnORrjZzz2s56VzA6JDCigQTAAATOVEEifH7mwFJr2TheJwmNRrwEF/No8zkHkYN3oEZnEUn7Pj+Y0BAAD4fTaBJ4gA4LQGuUaV9+/1dY2eg0AC9nMY11laQwIAgIlAQAHAcW1vOO7xZ2/r1r1utaLMdgbcKfusHGR2AsEEAAAAAKfSJAQSdrtdm91xvgfY77NykNsdCCYAAAAAOHUmLZBwK9NynDhdAQU+lQAAAAAm3kmrlQBMe3CKYAIAAAAAABgLwQQAAAAAADAWggkAAAAATh3bM36rwoYAbo1gAgAAAAAAGAvBBAAAAACnEtkJOI3iAypmSjABAAAAwKlFQAG4OwQTAAAAAOi0BxRstZYaCsCdI5gAAAAAALuCCgQWcFLFB7TFwaQO7JkAAMCxsJU012V9AAAOI7Cwl32NMRcgmAAAwFQbTXRHK2lMcAHgeIIMo7GYcRinISvBsIwBAMAJmRRQRAwAjhfbJHBaAgmGYAIAAFNmlIUAAJhcFHXESUcwAQAwdU5zte3bBRHITgCAycK4jON2WAsQBBMAAFN3QTytE7M7nQyc1vMDAJOKcRknMZORYAIAYCrYzfHuC+Jpm5iNMxkYFQA7TecHAAAc7XZIggkAgKlpfXicBQeP88b8bgIJhoACAEyO0xYEx8mvqUQwAQAwFYEEs19A4SRvrRhnUnCr1pBMXgEAOF0ZnEeBYAIAYCLZBXF3IGFk738f5k3+3pv5owwo3E02wn6BBPqdA8DJRKAYu43mAWQmAABOtVutso/+fbeDvsm/VUbAUQQUDiIbYTe2OwCYdrTDffW5OM3FiHFro4ACNRMAAKfOndwgH2b9hOOesI4TSLhZNsJ+CCgAmFbHPS5Piv1uEAko4HZZCnRzAACceKML3p2stB9WQOG4Wy+OG0i4G6xiAcD0udX1wa5Jo62BwK2CCgcdWHBiQn0AgFtdKBzn0M/P6FJ0NzfJ+13GDup57uR7DqImwd12a7gbo8kmtRRwp583nG5HcQ04TZ/Bo7g+HdS1CSdTNEbQ6Xa//6kDOB4AAI4lkDD6vnud7N7tZHWUoXAvk7ajDCTs3u5wr8cNAIftpAUSjsooU2GE4AJ2G+faf7vfQWYRAIBjsTvd7l4mOvt9351uQziIlL972fJw1IGEEYIIACbZURWPmwYHcR5GwYXdf9gSgYNAMAEAMPWYdALAycB4fjSos4CDQDABAHCsK04Hlbo/bjHGg5yw3k12wnFlJezGyhSASUE2AjB9CCYAAI7M3hvog07dv9OAwnGvfE1CIGH0nAQUABwnggi3PjeHjdaSuBcEEwAAxzJZPIyb5Dupn3BYk7M7mZCNO2k+7KJZ9txMJAEctcNqU4e7w3UAd4tgAgDgUO0XRDjMm+T9Jqe7J0qHOXm91YRs3CDCUVXfHnXDIEMBwFGMNwQQJhPXAdwNggkAgENzs2yEw15tv1VA4Wb/fpgTsrvJRjiqjguj88FEEsBhIYgAnEwEEwAAU7ut4WZuFzA4zIDC3tc5SdsabuawAywATi/Gluk5bwSVMS6CCQCAA3WzgodHfZN8u/oJh3EDfS+v87gCCSPUTwAAAOMgmAAAOFB306bxsNyufsJBBhSmOZCw+zhYmQJw0OMK/n+TPsZO+vFhshz/zAUAcOLcSVeFozqOowgo3CwYcCfPOymBBEP9BACHMa5gPARgMC347QYAnOjJ0GEHFE5CRsJuo+NhdQrASbseTDoKVWLaTNYMBgBw4rc72NdOQobCvbZvnMRAwsjoPBBQAHAQKPJ6sF1/DhtjP+7UZM5iAAAnwp3cxB/lseznbgIKt2vfeLvVpUkOJBgm/gAYV47OJAUSgHFM7kwGAHAiTFJA4U4mbLe7kb5dIOB23zvpgYQR6icAOKxxBf9/pt6kng+yE3AnJn82AwCYepMygbzTwMbNHnerQMCdZiNMQyBhhPoJAA5jXJnkm2gAd256ZjQAgKk2TR0edj9u9NjbBRJuZVqyEfZD/QQAB20UWCWgMNnITsDtTOfMBgAwlSZlu8M4AYXRY2/W+vEkBxL2nismlgAOa3wBMH2md3YDADgx6a2TWpDxVo8dp1DjtCOgAOAoxhdMHoLIuJXpn+EAAKbKJKW33uwYbjV5utO9viclkDBykl4LgMkyKdcE7I+AAm6GmQEAYCImj5O03eFm7vT4TlogYYTtDgAOCwGFyUZAAfs5eTMdAMDUmOSAwqht194aCqd50rX79Z/U1wjg+ExDQGGUnbb7D3BaOTG/AQCAW10oHOfQz8/eS9FxrOzfSVtHYzfQ+50Te8zer5+0DIXd5+ikvTbsj2kijuIaMKmfu/2OY79xb3dg9TjO11Fi7D9d4tv8LqaO7EgAALiJ/W7EJ+kYRqvwN6v3MJpc3SzQcBIQSABwlOPNcY6lo/HuTgOmux93kq8De6+HAJ8CAMCxm+TtDvsZPW6U4jqaVO2dXJ2UrQA3e70AcBiOc4wZjXF3ewzTsFXjXu23DRCnE7MBAMBEmJSAws3sPp7Rse434ZyEtpeHFUi4lwk2ANzN2DONGCdxWjAjAABMjOMOKIwzeb3ZZHG/ValpDSjsDSQAwFGZ9jFnmoMhd4LrAsx0/5YCAE6c40oRvd3PHGfidBLSXAkkADhuRz2OHuQN8km4DtwMgQSMEEwAAOi0tyC82YRvd+uvcSeYx51lcS8IJACYBNOenTDtx78fAgnY7eR9wgEAJ8JR3YjfKpAwqhFwUIW4Jj2gsLd3+kmcCAOYLtO+uj/txz/CdQH7YZYAAJhIx3kjftCprrtNakCBQosAJtG0BzVPwnYHCvDiZqb7txMAcKId9iRsv+c+jBX5SZ9Isq0BwCSb9DH0pAZEyEbA7UznJxsAcCoDCge5qn+Uk9NJ3u5AIAHApJvWm/FpDYjsDiKchHOPw8OnAwBw6gIKxzGpm8SAAoEEANNimm7Gp3G7w956OQQRcCcIJgAATlWHh+OczE1SQIFCiwCmyUm4uZ3EgMLeAMJJOM84OnxaAABT414nYXfy/Yd9gz8Jk0lWnwBMo+MeOw/CpNyscx3AQXDik/BbCQA4NHZzPUnsRn90TOMUSxz3cnfYrRF3H89RtmGkoBbG/bzgdJvka8BBO6qx+DBfw52g9S9Gn4N7NRmhMQAADrF+wt1cMO257fsOK0vhOLY7EEgAMO0mZWV/WjPUCCTAHNTnb/p/GwEAp85hdXjYz2E9/1HXTyCQAOCkOAkZM8cRUCCQAHOQnzuCCQCAEz0Ru5eL5mHfgB/VZNKCFEwiAZwUk1B7ZtpeB9cAmIP+vBFMAABMrdFN/s1W9e81kHAUla0PO8vCno8K3QBOmpMUUDhsBBJwWAgmAACm2s1uxO92knkc2wEOK6AwCiQAwEk0GjtHfwAcLbo5AACmqpL3YVbGPu7Vm4Ps8EAgAQf9mcTpNA3XgJG9gdhxjv04x//D/D077usaJstBdxJJHdgzAQAwxemuJ2XCRaFFAKfV3jF8d3BhmoIiwLRsD5r+WRMAACdkBfUkvAYAmBSjejG32w5x3MHkwxr7j/t1YTId5OeNbQ4AgFtfKKZoNedu0/cmacK1+zWMc1y7V+Am5bVg+hHgwjRdA+7UaLy01zYp4/9h/K5NymvDyd3uwKcLAHCq0/cmbbJ1N8UYd3dsmKTXAgCTaHe2AmMmTiP3gLY7kJkAADhxq1J3eoGc5InknWYoUGgRh4nMBEzjNWAaHfTv2iRf3zA5brdgcbvffwowAgBOHJtE3e4COOkTLTu226UhEkgAAAB363bzoNsFuSZ3FgUAwCGk701Tt4PRMe633YFAAgBgP9NyjcP041MGADg1AYXRBGuaJln71U8gkAAAJwtbijCNpmc2BQDAPQQUpnWlZr+gyDS+DgDAzR3UuD6t1zpMJz5pAIAT7SRU7D4JrwEAcLjZCVwncNSYlQAATryTcBN+El4DAODw2/UBR4WZCQAAAABMcUCBrAQcB4IJAAAAADBhAYU7DSoQSMBxSR3bTwYAAAAA3HRr2962wKPuPiMEEnCcCCYAAAAAwJTUy9kdYKCeDo4TwQQAAAAAmBIEEDApqJkAAAAAAADGQjABAAAAAACMhWACAAAAAAAYC8EEAAAAAAAwFoIJAAAAAABgLAQTAAAAAADAWAgmAAAAAACAsRBMAAAAAAAAYyGYAAAAAAAAxkIwAQAAAAAAjIVgAgAAAAAAGAvBBAAAAAAAMBaCCQAAAAAAYCwEEwAAAAAAwFgIJgAAAAAAgLEQTAAAAAAAAGMhmAAAAAAAAMZCMAEAAAAAAIyFYAIAAAAAABgLwQQAAAAAADAWggkAAAAAAGAsBBMAAAAAAMBYCCYAAAAAAICxEEwAAAAAAABjIZgAAAAAAADGQjABAAAAAACMhWACAAAAAAAYC8EEAAAAAAAwFoIJAAAAAABgLAQTAAAAAADAWAgmAAAAAACAsRBMAAAAAAAAYyGYAAAAAAAACCYAAAAAAIDDQ2YCAAAAAAAYC8EEAAAAAAAwFoIJAAAAAABgLAQTAAAAAADAWAgmAAAAAACAsRBMAAAAAAAAYyGYAAAAAAAAxkIwAQAAAAAAjIVgAgAAAAAAGAvBBAAAAAAAMBaCCQAAAAAAYCwEEwAAAAAAwFgIJgAAAAAAgLEQTAAAAAAAAGMhmAAAAAAAAMZCMAEAAAAAAIyFYAIAAAAAABgLwQQAAAAAADAWggkAAAAAAGAsBBMAAAAAAMBYCCYAAAAAAICxEEwAAAAAAABjIZgAAAAAAADGQjABAAAAAACMhWACAAAAAAAYC8EEAAAAAAAwFoIJAAAAAABgLAQTAAAAAADAWAgmAAAAAACAsRBMAAAAAAAAYyGYAAAAAAAAxkIwAQAAAAAAjIVgAgAAAAAAGAvBBAAAAAAAMBaCCQAAAAAAYCwEEwAAAAAAwFgIJgAAAAAAgLEQTAAAAAAAAGMhmAAAAAAAAMaSGu/hAAAAAABg2sVxfE/fT2YCAAAAAACnSHyPgQRDMAEAAAAAAIyFYAIAAAAAAKdEfABZCYZgAgAAAAAAp0AURQf2XAQTAAAAAAA4BVzXJTMBAAAAAAAcT0CB1pAAAAAAAJyygEJ0my0PjuPc8t8JJgAAAAAAcAoDCrdyu+wFaiYAAAAAAICxEEwAAAAAAABjIZgAAAAAAADGQjABAAAAAACMhWACAAAAAAAYC8EEAAAAAAAwFoIJAAAAAABgLAQTAAAAAADAWAgmAAAAAACAsRBMAAAAAAAAYyGYAAAAAAAAxkIwAQAAAAAAjIVgAgAAAAAAGAvBBAAAAAAAMBaCCQAAAAAAYCwEEwAAAAAAwFgIJgAAAAAAgLEQTAAAAAAAAGMhmAAAAAAAAMZCMAEAAAAAAIyFYAIAAAAAABgLwQQAAAAAADAWggkAAAAAAGAsBBMAAAAAAMBYCCYAAAAAAICxEEwAAAAAAABjIZgAAAAAAADGQjABAAAAAACMhWACAAAAAAAYC8EEAAAAAAAwFoIJAAAAAABgLAQTAAAAAADAWAgmAAAAAACAsRBMAAAAAAAAYyGYAAAAAAAAxkIwAQAAAAAAjIVgAgAAAAAAGAvBBAAAAAAAMBaCCQAAAAAAYCwEEwAAAAAAwFgIJgAAAAAAgLEQTAAAAAAAAGMhmAAAAAAAAMZCMAEAAAAAAIyFYAIAAAAAABgLwQQAAAAAADAWggkAAAAAAGAsBBMAAAAAAMBYCCYAAAAAAICxEEwAAAAAAABjIZgAAAAAAADGQjABAAAAAACMxYnjOB7vWwAAAAAAwGlGZgIAAAAAABgLwQQAAAAAADAWggkAAAAAAGAsBBMAAAAAAMBYCCYAAAAAAICxEEwAAAAAAABjIZgAAAAAAADGQjABAAAAAACMhWACAAAAAADQOP4/ituwvKi2Cg4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def tensor_to_rgb(img_tensor):\n", + " \"\"\"Undo normalisation and convert [3,H,W] tensor to [H,W,3] RGB numpy.\"\"\"\n", + " img_np = img_tensor.detach().cpu().permute(1, 2, 0).numpy()\n", + " img_np = (img_np * np.array([0.229, 0.224, 0.225]) +\n", + " np.array([0.485, 0.456, 0.406]))\n", + " img_np = np.clip(img_np, 0, 1)\n", + " return img_np\n", + "\n", + "def visualise_few_shot_example(encoder, train_dataset, test_dataset):\n", + " encoder.eval()\n", + " rng = np.random.default_rng()\n", + "\n", + " # pick support from train, query from test\n", + " si = rng.integers(0, len(train_dataset))\n", + " ti = rng.integers(0, len(test_dataset))\n", + "\n", + " img_s, mask_s = train_dataset[si]\n", + " img_q, mask_q = test_dataset[ti]\n", + "\n", + " logits = one_shot_predict(encoder, img_s, mask_s, img_q) # [1,2,H,W]\n", + " pred_mask = logits.argmax(dim=1, keepdim=True).float().squeeze(0).squeeze(0).numpy()\n", + "\n", + " # convert to numpy for plotting\n", + " img_s_np = tensor_to_rgb(img_s)\n", + " img_q_np = tensor_to_rgb(img_q)\n", + " mask_s_np = mask_s.squeeze(0).numpy()\n", + " mask_q_np = mask_q.squeeze(0).numpy()\n", + "\n", + " plt.figure(figsize=(12, 6))\n", + "\n", + " plt.subplot(2, 3, 1)\n", + " plt.imshow(img_s_np)\n", + " plt.title(\"Support image\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(2, 3, 2)\n", + " plt.imshow(mask_s_np, cmap=\"gray\")\n", + " plt.title(\"Support mask\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(2, 3, 3)\n", + " plt.imshow(img_q_np)\n", + " plt.title(\"Query image\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(2, 3, 5)\n", + " plt.imshow(mask_q_np, cmap=\"gray\")\n", + " plt.title(\"Query GT mask\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(2, 3, 6)\n", + " plt.imshow(pred_mask, cmap=\"gray\")\n", + " plt.title(\"Predicted mask (1-shot)\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "visualise_few_shot_example(encoder, train_base, test_base)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9.3. Visualising a K-shot episode\n", + "\n", + "Finally, we visualise a **K-shot** episode (e.g. 5-shot) to complement the numerical results:\n", + "\n", + "1. Select a random query image from the test set.\n", + "2. Select `K` random support images from the training set.\n", + "3. Run `k_shot_predict` to produce a predicted mask.\n", + "4. Plot:\n", + " - the query image,\n", + " - the ground-truth query mask,\n", + " - and the K-shot predicted mask.\n", + "\n", + "Qualitatively comparing this to the 1-shot visualisation helps us see where additional support images improve the segmentationβ€”typically in challenging cases such as partially occluded rooftops or unusual roof materials.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def visualise_kshot_example(encoder, train_dataset, test_dataset, K=5):\n", + " encoder.eval()\n", + " rng = np.random.default_rng()\n", + "\n", + " # pick query from test\n", + " ti = rng.integers(0, len(test_dataset))\n", + " img_q, mask_q = test_dataset[ti]\n", + "\n", + " # pick K supports from train\n", + " support_indices = rng.choice(len(train_dataset), size=K, replace=False)\n", + " support_imgs, support_masks = [], []\n", + " for si in support_indices:\n", + " img_s, mask_s = train_dataset[si]\n", + " support_imgs.append(img_s)\n", + " support_masks.append(mask_s)\n", + " support_imgs = torch.stack(support_imgs, dim=0) # [K,3,H,W]\n", + " support_masks = torch.stack(support_masks, dim=0) # [K,1,H,W]\n", + "\n", + " # prediction\n", + " logits = k_shot_predict(encoder, support_imgs, support_masks, img_q)\n", + " pred_mask = logits.argmax(dim=1, keepdim=True).float().squeeze().numpy()\n", + "\n", + " img_q_np = tensor_to_rgb(img_q)\n", + " mask_q_np = mask_q.squeeze(0).numpy()\n", + "\n", + " # Plot\n", + " cols = max(K, 3)\n", + " plt.figure(figsize=(4 * cols, 8))\n", + "\n", + " # first row: support images\n", + " for i in range(K):\n", + " plt.subplot(2, cols, i + 1)\n", + " plt.imshow(tensor_to_rgb(support_imgs[i]))\n", + " plt.title(f\"Support {i+1} image\")\n", + " plt.axis(\"off\")\n", + "\n", + " # second row: support masks\n", + " for i in range(K):\n", + " plt.subplot(2, cols, cols + i + 1)\n", + " plt.imshow(support_masks[i].squeeze(0).numpy(), cmap=\"gray\")\n", + " plt.title(f\"Support {i+1} mask\")\n", + " plt.axis(\"off\")\n", + "\n", + " # query image & masks to the right (replace last columns if needed)\n", + " plt.figure(figsize=(12, 4))\n", + " plt.subplot(1, 3, 1)\n", + " plt.imshow(img_q_np)\n", + " plt.title(\"Query image\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(1, 3, 2)\n", + " plt.imshow(mask_q_np, cmap=\"gray\")\n", + " plt.title(\"Query GT mask\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(1, 3, 3)\n", + " plt.imshow(pred_mask, cmap=\"gray\")\n", + " plt.title(f\"Predicted mask ({K}-shot)\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "# Example 5-shot visualisation\n", + "visualise_kshot_example(encoder, train_base, test_base, K=5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9.4. Comparing 1-shot and 5-shot performance\n", + "\n", + "Using the evaluation function above, we can now compare:\n", + "\n", + "- **1-shot IoU**, where only a single annotated support image is available, and\n", + "- **5-shot IoU**, where we provide five labelled support images for each test query.\n", + "\n", + "We expect performance to improve with more support examples, as the prototypes become more representative of the diversity of rooftop appearances. This experiment illustrates a key trade-off in few-shot learning between **annotation cost** (how many labelled examples we need) and **model performance**.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1-shot mean IoU over 53 test samples: 0.466 Β± 0.209\n", + "5-shot mean IoU over 53 test samples: 0.487 Β± 0.237\n", + "10-shot mean IoU over 53 test samples: 0.509 Β± 0.215\n", + "20-shot mean IoU over 53 test samples: 0.558 Β± 0.225\n" + ] + } + ], + "source": [ + "# ============================================================\n", + "# 9d. K-shot inference on test images\n", + "# ============================================================\n", + "\n", + "# 1-shot using the same function\n", + "ious_1shot = evaluate_kshot_iou(encoder, train_base, test_base, K=1, num_samples=None)\n", + "\n", + "# 5-shot\n", + "ious_5shot = evaluate_kshot_iou(encoder, train_base, test_base, K=5, num_samples=None)\n", + "\n", + "# 10-shot\n", + "ious_10shot = evaluate_kshot_iou(encoder, train_base, test_base, K=10, num_samples=None)\n", + "\n", + "# 20-shot\n", + "ious_20shot = evaluate_kshot_iou(encoder, train_base, test_base, K=20, num_samples=None)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9.5. Discussion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "COMPLETE HERE\n", + "Ideas:\n", + "- difference normal ResNet and pretrained ResNet\n", + "- the slow performance increase with higher k \n", + "- general implications of few-shot for our usecase: are other methods more suitable?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10. References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Alsentzer, E., Li, M. M., Kobren, S. N., Noori, A., Undiagnosed Diseases Network, Kohane, I. S., & Zitnik, M. (2025). *Few shot learning for phenotype-driven diagnosis of patients with rare genetic diseases*. **npj Digital Medicine, 8**(1), 380. https://doi.org/10.1038/s41746-025-01749-1\n", + "\n", + "- Castello, R., Walch, A., Attias, R., Cadei, R., Jiang, S., & Scartezzini, J.-L. (2021). *Quantification of the suitable rooftop area for solar panel installation from overhead imagery using convolutional neural networks*. **Journal of Physics: Conference Series, 2042**(1), 012002. https://doi.org/10.1088/1742-6596/2042/1/012002\n", + "\n", + "- Chen, Y., Wei, C., Wang, D., Ji, C., & Li, B. (2022). *Semi-supervised contrastive learning for few-shot segmentation of remote sensing images*. **Remote Sensing, 14**(17), 4254. https://doi.org/10.3390/rs14174254\n", + "\n", + "- Finn, C., Abbeel, P., & Levine, S. (2017). *Model-agnostic meta-learning for fast adaptation of deep networks*. In **International Conference on Machine Learning** (pp. 1126–1135). PMLR. https://doi.org/10.48550/arXiv.1703.03400\n", + "\n", + "- Ge, Z., Fan, X., Zhang, J., & Jin, S. (2025). *SegPPD-FS: Segmenting plant pests and diseases in the wild using few-shot learning*. **Plant Phenomics**, 100121. https://doi.org/10.1016/j.plaphe.2025.100121\n", + "\n", + "- Hu, Y., Liu, C., Li, Z., Xu, J., Han, Z., & Guo, J. (2022). *Few-shot building footprint shape classification with relation network*. **ISPRS International Journal of Geo-Information, 11**(5), 311. https://doi.org/10.3390/ijgi11050311\n", + "\n", + "- Jadon, S. (2021, February). *COVID-19 detection from scarce chest x-ray image data using few-shot deep learning approach*. In **Medical Imaging 2021: Imaging Informatics for Healthcare, Research, and Applications** (Vol. 11601, pp. 161–170). SPIE. https://doi.org/10.1117/12.2581496\n", + "\n", + "- Lee, G. Y., Dam, T., Ferdaus, M. M., Poenar, D. P., & Duong, V. (2025). *Enhancing Few-Shot Classification of Benchmark and Disaster Imagery with ATTBHFA-Net*. **arXiv preprint arXiv:2510.18326**. https://doi.org/10.48550/arXiv.2510.18326\n", + "\n", + "- Li, X., He, Z., Zhang, L., Guo, S., Hu, B., & Guo, K. (2025). *CDCNet: Cross-domain few-shot learning with adaptive representation enhancement*. **Pattern Recognition, 162**, 111382. https://doi.org/10.1016/j.patcog.2025.111382\n", + "\n", + "- Puthumanaillam, G., & Verma, U. (2023). *Texture based prototypical network for few-shot semantic segmentation of forest cover: Generalizing for different geographical regions*. **Neurocomputing, 538**, 126201. https://doi.org/10.1016/j.neucom.2023.03.062\n", + "\n", + "- Snell, J., Swersky, K., & Zemel, R. (2017). *Prototypical networks for few-shot learning*. **Advances in Neural Information Processing Systems, 30**. https://doi.org/10.48550/arXiv.1703.05175\n", + "\n", + "- Sung, F., Yang, Y., Zhang, L., Xiang, T., Torr, P. H., & Hospedales, T. M. (2018). *Learning to compare: Relation network for few-shot learning*. In **Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition** (pp. 1199–1208). https://doi.org/10.1109/CVPR.2018.00131\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dl-tutorial", + "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.10.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/tutorial_few_shot_learning.ipynb b/notebooks/tutorial_few_shot_learning.ipynb new file mode 100644 index 0000000..f9cb2f7 --- /dev/null +++ b/notebooks/tutorial_few_shot_learning.ipynb @@ -0,0 +1,463 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Few-Shot Learning for Rooftop Detection in Satellite Imagery\n", + "### GRAD-E1394 Deep Learning\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/hertie-data-science-lab/tutorial-new-tutorial-group-1/blob/main/notebooks/tutorial_few_shot_learning.ipynb)\n", + "\n", + "This tutorial demonstrates few-shot learning techniques for semantic segmentation of satellite imagery. We focus on rooftop detection using high-resolution satellite images of Geneva, Switzerland.\n", + "\n", + "### Learning Outcomes\n", + "- Understanding few-shot learning concepts for image segmentation\n", + "- Working with satellite imagery and segmentation masks\n", + "- Implementing and evaluating few-shot learning models for rooftop detection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Table of Contents\n", + "\n", + "* [Memo](#memo)\n", + "* [Overview](#overview)\n", + "* [Background & Prerequisites](#background-and-prereqs)\n", + "* [Software Requirements](#software-requirements)\n", + "* [Data Description](#data-description)\n", + "* [Methodology](#methodology)\n", + "* [Results & Discussion](#results-and-discussion)\n", + "* [References](#references)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Memo\n", + "\n", + "Few-shot learning for satellite image segmentation is crucial for urban planning and disaster response. Traditional deep learning requires thousands of labeled samples, but few-shot learning enables rapid adaptation to new geographic regions with minimal labeled data.\n", + "\n", + "**Policy Applications:**\n", + "- Urban development monitoring\n", + "- Disaster damage assessment\n", + "- Property tax assessment\n", + "- Solar panel installation planning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Overview\n", + "\n", + "This tutorial introduces a few-shot learning approach for semantic segmentation of satellite imagery. We demonstrate how to:\n", + "\n", + "1. Load and preprocess satellite imagery\n", + "2. Build a few-shot segmentation model\n", + "3. Train using episodic learning\n", + "4. Evaluate segmentation performance\n", + "\n", + "By the end, you will understand how to apply few-shot learning to detect rooftops in new satellite images with only a few labeled examples." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Background & Prerequisites\n", + "\n", + "### Prerequisites\n", + "- Basic Python programming\n", + "- Familiarity with PyTorch\n", + "- Understanding of convolutional neural networks\n", + "\n", + "### Key Concepts\n", + "\n", + "**Few-Shot Learning:** Learning from a small number of labeled examples by leveraging prior knowledge.\n", + "\n", + "**Semantic Segmentation:** Classifying each pixel in an image into predefined categories.\n", + "\n", + "**Prototypical Networks:** Learning class representations (prototypes) and classifying based on distance to prototypes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Software Requirements" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Install dependencies (if needed)\n", + "# !pip install torch torchvision numpy matplotlib pillow scikit-learn tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Import standard libraries\n", + "from pathlib import Path\n", + "import os\n", + "import sys\n", + "\n", + "sys.path.append(os.path.abspath(\"..\"))\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Import PyTorch\n", + "import torch\n", + "\n", + "# Import tutorial package functions\n", + "from src.few_shot_utils import (\n", + " FewShotSegmentationModel,\n", + " load_dataset,\n", + " create_dataloader,\n", + " preprocess_image,\n", + ")\n", + "\n", + "# Set random seeds for reproducibility\n", + "torch.manual_seed(42)\n", + "np.random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Data Description\n", + "\n", + "The dataset consists of high-resolution satellite imagery of Geneva, Switzerland with corresponding binary segmentation masks for rooftop detection.\n", + "\n", + "**Dataset Properties:**\n", + "- Image Type: RGB satellite imagery\n", + "- Labels: Binary masks (0 = background, 1 = rooftop)\n", + "- Resolution: Variable, resized to 256x256 for training" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Download\n", + "\n", + "Download the dataset from πŸ€— and store it in cache." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/elena/miniconda3/envs/.venv-dl-ps1/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "Fetching 2111 files: 100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 2111/2111 [00:00<00:00, 47765.91it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "420 52 53\n", + "(8, 250, 250, 3) (8, 250, 250, 3)\n" + ] + } + ], + "source": [ + "from huggingface_hub import snapshot_download\n", + "\n", + "# 1. Download dataset\n", + "HF_TOKEN = \"XXX\" # Replace with your Hugging Face token if needed\n", + "\n", + "dataset_path = snapshot_download(\n", + " repo_id=\"raphaelattias/overfitteam-geneva-satellite-images\",\n", + " repo_type=\"dataset\",\n", + " token=HF_TOKEN,\n", + ")\n", + "\n", + "\n", + "# 2. Load splits\n", + "train_data = load_dataset(dataset_path, split=\"train\", category=\"all\")\n", + "val_data = load_dataset(dataset_path, split=\"val\", category=\"all\")\n", + "test_data = load_dataset(dataset_path, split=\"test\", category=\"all\")\n", + "\n", + "print(len(train_data[\"images\"]), len(val_data[\"images\"]), len(test_data[\"images\"]))\n", + "\n", + "# 3. Create simple numpy-based \"dataloaders\"\n", + "train_batches = create_dataloader(train_data, batch_size=8, shuffle=True)\n", + "first_batch = train_batches[0]\n", + "print(first_batch[\"images\"].shape, first_batch[\"masks\"].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show example image and mask\n", + "plt.figure(figsize=(10, 5))\n", + "plt.subplot(1, 2, 1)\n", + "plt.title(\"Example Image\")\n", + "plt.imshow(first_batch[\"images\"][0])\n", + "plt.axis(\"off\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.title(\"Example Mask\")\n", + "plt.imshow(first_batch[\"masks\"][0], cmap=\"gray\")\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Demonstrate preprocessing on sample image\n", + "# TODO" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Methodology\n", + "\n", + "We implement a few-shot segmentation approach using prototypical networks. The model learns to segment rooftops by:\n", + "\n", + "1. Extracting features using a CNN backbone\n", + "2. Computing class prototypes from support examples\n", + "3. Classifying query pixels based on distance to prototypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model Architecture" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create the few-shot segmentation model\n", + "model = FewShotSegmentationModel(backbone_name=\"resnet18\", num_classes=2, pretrained=True)\n", + "\n", + "print(\"Model architecture:\")\n", + "print(\" Backbone: ResNet-18\")\n", + "print(\" Number of classes: 2 (background, rooftop)\")\n", + "print(f\" Total parameters: {sum(p.numel() for p in model.parameters()):,}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create synthetic data for demonstration\n", + "# In practice, use actual satellite imagery\n", + "synthetic_dataset = {\n", + " \"images\": [np.random.rand(256, 256, 3).astype(np.float32) for _ in range(16)],\n", + " \"masks\": [np.random.randint(0, 2, (256, 256)).astype(np.int64) for _ in range(16)],\n", + "}\n", + "\n", + "# Create data loaders\n", + "train_loader = create_dataloader(synthetic_dataset, batch_size=4, shuffle=True)\n", + "val_loader = create_dataloader(synthetic_dataset, batch_size=4, shuffle=False)\n", + "\n", + "print(f\"Number of training batches: {len(train_loader)}\")\n", + "print(f\"Number of validation batches: {len(val_loader)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Training configuration\n", + "# Note: Using small number of epochs for demonstration\n", + "NUM_EPOCHS = 2\n", + "LEARNING_RATE = 1e-4\n", + "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "print(f\"Training device: {DEVICE}\")\n", + "\n", + "# Train the model\n", + "# history = train_model(\n", + "# model=model,\n", + "# train_dataloader=train_loader,\n", + "# val_dataloader=val_loader,\n", + "# num_epochs=NUM_EPOCHS,\n", + "# learning_rate=LEARNING_RATE,\n", + "# device=DEVICE\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Results & Discussion" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Evaluate model\n", + "# results = evaluate_model(\n", + "# model=model,\n", + "# dataloader=val_loader,\n", + "# device=DEVICE,\n", + "# num_classes=2\n", + "# )\n", + "# print(f\"Mean IoU: {results['mean_iou']:.4f}\")\n", + "# print(f\"Pixel Accuracy: {results['pixel_accuracy']:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Visualize predictions\n", + "def visualize_prediction(image, mask, prediction):\n", + " \"\"\"Visualize image, ground truth, and prediction.\"\"\"\n", + " fig, axes = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + " axes[0].imshow(image)\n", + " axes[0].set_title(\"Satellite Image\")\n", + " axes[0].axis(\"off\")\n", + "\n", + " axes[1].imshow(mask, cmap=\"gray\")\n", + " axes[1].set_title(\"Ground Truth\")\n", + " axes[1].axis(\"off\")\n", + "\n", + " axes[2].imshow(prediction, cmap=\"gray\")\n", + " axes[2].set_title(\"Prediction\")\n", + " axes[2].axis(\"off\")\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "# Example visualization with synthetic data\n", + "sample_image = np.random.rand(256, 256, 3)\n", + "sample_mask = np.random.randint(0, 2, (256, 256))\n", + "sample_prediction = np.random.randint(0, 2, (256, 256))\n", + "\n", + "visualize_prediction(sample_image, sample_mask, sample_prediction)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Limitations\n", + "\n", + "- This tutorial uses synthetic data for demonstration purposes\n", + "- Real satellite imagery would require more extensive preprocessing\n", + "- Performance depends on the quality and quantity of support examples\n", + "\n", + "## Next Steps\n", + "\n", + "- Collect and annotate real satellite imagery of Geneva\n", + "- Experiment with different backbone architectures\n", + "- Apply to other geographic regions and segmentation tasks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# References\n", + "\n", + "- ...\n", + "- ...\n", + "- ..." + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": ".venv-dl-ps1", + "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.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..90c024c --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,154 @@ +[build-system] +requires = ["setuptools >= 69.1.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "few_shot_utils" +version = "0.0.1" +description = "DL Tutorial 2025: Few-shot learning tutorial on satellite imagery for rooftop detection." +readme = "README.md" +authors = [ + {name = "Tutorial Group 1"}, +] +maintainers = [{name = "Tutorial Group 1"}] +classifiers = [ + "Development Status :: 3 - Alpha", + "Intended Audience :: Developers", + "Intended Audience :: Education", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3.11", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "Topic :: Scientific/Engineering :: Image Processing" +] +requires-python = ">=3.11" +dependencies = [ + 'numpy>=1.24.0', + 'pandas>=2.1.0', + 'matplotlib>=3.8.0', + 'Pillow>=10.0.0', + 'scikit-learn>=1.3.0', + 'tqdm>=4.66.0', +] + +[project.optional-dependencies] +dev = [ + "ruff==0.8.2", + "ipykernel==6.29.3", + "nbformat>=5.9.0", + "pre-commit==3.6.0", +] +torch = [ + "torch>=2.0.0", + "torchvision>=0.15.0", +] + +[project.urls] +Documentation = "https://elenaivadreyer.github.io/tutorial-group-1/" +Source = "https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1" +Tracker = "https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1/issues" + +#Global ruff configuration +[tool.ruff] + +#global exlusions as defined in original template version +exclude = [ + ".git", + ".hg", + ".mypy_cache", + ".eggs", + ".cache", + ".tox", + "venv", + ".venv", + ".env", + "_build", + "buck-out", + "build", + "__pycache__", + "dist", + "nssm", + "obj", + "out", + "packages", + "pywin32", + "swagger_client" +] + + +# Line length configuration +line-length = 120 + +# Ruff linting configuration +[tool.ruff.lint] +select = [ + "E", # Pycodestyle errors (PEP8 style) + "F", # Pyflakes (code errors and issues) + "W", # Pycodestyle warnings + "I", # Import sorting (isort replacement) + "D", # Pydocstyle (PEP257 docstring conventions) + "ANN", # flake8-annotations (function type annotations) + "UP", # Pyupgrade (modern Python syntax) + "B", # flake8-bugbear (likely bugs) + "S", # Security checks (bandit replacement) + "N", # Naming conventions (PEP8) + "PL", # Pylint rules +] + +ignore = [ + # Docstring requirements - relaxed for flexibility + "D100", "D101", "D102", "D103", "D104", "D105", "D106", "D107", + + # Docstring formatting - avoid conflicts + "D211", # Conflicts with D203 + "D212", # Conflicts with D213 + + # Style preferences + "COM812", # Conflicts with formatter + "D203", # Conflicts with formatter +] + +# Allow underscore-prefixed unused variables +dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" + +# Per-file exceptions +[tool.ruff.lint.per-file-ignores] +"scripts/*" = ["S"] # Disable security checks in scripts + +# Jupyter notebooks - relaxed rules for exploratory work +"*.ipynb" = [ + "T201", # Allow print statements + "ANN", # No annotation requirements + "E501", # Allow long lines + "F401", # Allow unused imports + "I001", # Relaxed import sorting + "PLC0415", # Allow imports outside top-level + "PLR0913", # Allow many function arguments + "S105", # Allow hardcoded passwords (often placeholder values in tutorials) +] + +# Training/evaluation modules +"src/few_shot_utils/train.py" = ["T201", "PLR0913"] +"src/few_shot_utils/evaluate.py" = ["T201"] +"src/few_shot_utils/models.py" = ["PLC0415"] + +# Import sorting configuration +[tool.ruff.lint.isort] +split-on-trailing-comma = true + +# Pylint-compatible settings +[tool.ruff.lint.pylint] +max-args = 5 +max-branches = 12 +max-locals = 15 +max-returns = 6 +max-statements = 50 + +# Ruff formatter (Black replacement) +[tool.ruff.format] +quote-style = "double" +indent-style = "space" +skip-magic-trailing-comma = false +line-ending = "auto" +docstring-code-format = true +docstring-code-line-length = "dynamic" \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..d5aadee --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +torch==2.2.2 +torchvision==0.17.2 +huggingface_hub==0.23.0 +matplotlib==3.8.2 +pillow==10.3.0 +numpy==1.26.4 \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/few_shot_utils/__init__.py b/src/few_shot_utils/__init__.py new file mode 100644 index 0000000..af16e7c --- /dev/null +++ b/src/few_shot_utils/__init__.py @@ -0,0 +1,55 @@ +"""Tutorial Group 1: Few-Shot Learning for Rooftop Detection in Satellite Imagery.""" + +from typing import Any + +# Relative import from the same package +from .data import create_dataloader, load_dataset, preprocess_image + +NAME = "few_shot_utils" + +# What this package exposes at top level +__all__ = [ + "NAME", + "FewShotSegmentationModel", + "create_dataloader", + "evaluate_model", + "get_backbone", + "load_dataset", + "preprocess_image", + "train_episode", + "train_model", + "calculate_iou", + "calculate_dice", + "print_evaluation_results", +] + + +def __getattr__(name: str) -> Any: # noqa: ANN401 + """ + Lazy import for torch-dependent modules. + + This is called when an attribute is accessed on the package that + isn't already defined above. + """ + if name in ("FewShotSegmentationModel", "get_backbone", "create_model"): + from . import models # relative import + + return getattr(models, name) + + if name in ("train_episode", "train_model"): + from . import train # relative import + + return getattr(train, name) + + if name in ( + "calculate_iou", + "calculate_dice", + "evaluate_model", + "print_evaluation_results", + ): + from . import evaluate # relative import + + return getattr(evaluate, name) + + msg = f"module {__name__!r} has no attribute {name!r}" + raise AttributeError(msg) diff --git a/src/few_shot_utils/data.py b/src/few_shot_utils/data.py new file mode 100644 index 0000000..101f1af --- /dev/null +++ b/src/few_shot_utils/data.py @@ -0,0 +1,122 @@ +"""Data loading and preprocessing utilities for satellite imagery.""" + +from pathlib import Path +from typing import Any + +import numpy as np +from PIL import Image + + +def load_dataset( + data_path: str | Path, + split: str = "train", + category: str = "all", +) -> dict[str, Any]: + """ + Load Geneva rooftop satellite imagery dataset. + + Args: + data_path: Path to the root dataset directory (e.g. snapshot_download path). + split: One of 'train', 'val', or 'test'. + category: One of 'all', 'industrial', or 'residencial'. + + Returns: + Dictionary containing: + - "images": list of HxWxC numpy arrays (RGB) + - "masks": list of HxW numpy arrays (label masks) + - "filenames": list of image file names (optional convenience) + + """ + data_path = Path(data_path) + + # Geneva dataset layout: + # //images//*.png + # //labels//*_label.png + image_dir = data_path / split / "images" / category + mask_dir = data_path / split / "labels" / category + + images: list[np.ndarray] = [] + masks: list[np.ndarray] = [] + filenames: list[str] = [] + + if not image_dir.exists(): + raise FileNotFoundError(f"Image directory not found: {image_dir}") + if not mask_dir.exists(): + raise FileNotFoundError(f"Label directory not found: {mask_dir}") + + for img_path in sorted(image_dir.glob("*.png")): + # Build corresponding label filename: add "_label" before .png + label_name = img_path.stem + "_label.png" + mask_path = mask_dir / label_name + + if not mask_path.exists(): + raise FileNotFoundError(f"Mask not found for {img_path.name}: {mask_path}") + + image = Image.open(img_path).convert("RGB") + mask = Image.open(mask_path) + + images.append(np.array(image)) + masks.append(np.array(mask)) + filenames.append(img_path.name) + + return {"images": images, "masks": masks, "filenames": filenames} + + +def preprocess_image( + image: np.ndarray, + target_size: tuple[int, int] = (256, 256), + normalize: bool = True, +) -> np.ndarray: + """ + Preprocess satellite image for model input. + + Args: + image: Input image as numpy array. + target_size: Target size for resizing (height, width). + normalize: Whether to normalize the image values. + + Returns: + Preprocessed image. + + """ + img = Image.fromarray(image) + img = img.resize(target_size[::-1]) # PIL uses (width, height) + result = np.array(img) + + return result + + +def create_dataloader( + dataset: dict[str, Any], + batch_size: int = 4, + shuffle: bool = True, +) -> list[dict[str, np.ndarray]]: + """ + Create data batches from dataset. + + Args: + dataset: Dataset dictionary with images and masks. + batch_size: Number of samples per batch. + shuffle: Whether to shuffle the data. + + Returns: + List of batch dictionaries. + + """ + images = dataset["images"] + masks = dataset["masks"] + + indices = np.arange(len(images)) + if shuffle: + np.random.shuffle(indices) + + batches = [] + for i in range(0, len(indices), batch_size): + batch_indices = indices[i : i + batch_size] + batch = { + "images": np.array([images[j] for j in batch_indices]), + "masks": np.array([masks[j] for j in batch_indices]), + } + batches.append(batch) + + return batches diff --git a/src/few_shot_utils/evaluate.py b/src/few_shot_utils/evaluate.py new file mode 100644 index 0000000..af0d62e --- /dev/null +++ b/src/few_shot_utils/evaluate.py @@ -0,0 +1,3 @@ +"""Evaluation metrics for segmentation models.""" + +# TODO: Implement evaluation metrics such as IoU, Dice coefficient, etc. diff --git a/src/few_shot_utils/models.py b/src/few_shot_utils/models.py new file mode 100644 index 0000000..f0818f0 --- /dev/null +++ b/src/few_shot_utils/models.py @@ -0,0 +1,174 @@ +"""Model architectures for few-shot segmentation.""" + +from typing import Any + +import torch +from torch import nn + + +def get_backbone(name: str = "resnet18", pretrained: bool = True) -> nn.Module: + """ + Get a backbone network for feature extraction. + + Args: + name: Name of the backbone architecture. + pretrained: Whether to use pretrained weights. + + Returns: + Backbone neural network module. + + """ + from torchvision import models + + if name == "resnet18": + backbone = models.resnet18(weights=models.ResNet18_Weights.DEFAULT if pretrained else None) + # Remove the final fully connected layer + backbone = nn.Sequential(*list(backbone.children())[:-2]) + elif name == "resnet34": + backbone = models.resnet34(weights=models.ResNet34_Weights.DEFAULT if pretrained else None) + backbone = nn.Sequential(*list(backbone.children())[:-2]) + else: + msg = f"Unknown backbone: {name}" + raise ValueError(msg) + + return backbone + + +class FewShotSegmentationModel(nn.Module): + """Few-shot segmentation model for rooftop detection.""" + + def __init__( + self, + backbone_name: str = "resnet18", + num_classes: int = 2, + pretrained: bool = True, + ) -> None: + """ + Initialize the few-shot segmentation model. + + Args: + backbone_name: Name of the backbone network. + num_classes: Number of output classes. + pretrained: Whether to use pretrained backbone. + + """ + super().__init__() + self.backbone = get_backbone(backbone_name, pretrained) + self.num_classes = num_classes + + # Feature dimension from backbone (ResNet variants) + feature_dim_map = { + "resnet18": 512, + "resnet34": 512, + } + feature_dim = feature_dim_map.get(backbone_name, 512) + + # Decoder + self.decoder = nn.Sequential( + nn.ConvTranspose2d(feature_dim, 256, kernel_size=2, stride=2), + nn.ReLU(inplace=True), + nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2), + nn.ReLU(inplace=True), + nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2), + nn.ReLU(inplace=True), + nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2), + nn.ReLU(inplace=True), + nn.ConvTranspose2d(32, num_classes, kernel_size=2, stride=2), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Forward pass. + + Args: + x: Input tensor of shape (B, C, H, W). + + Returns: + Output segmentation tensor of shape (B, num_classes, H, W). + + """ + features = self.backbone(x) + output = self.decoder(features) + return output + + def extract_support_features( + self, + support_images: torch.Tensor, + support_masks: torch.Tensor, + ) -> torch.Tensor: + """ + Extract features from support set for few-shot learning. + + Args: + support_images: Support set images. + support_masks: Support set masks. + + Returns: + Prototype features for each class. + + """ + features = self.backbone(support_images) + # Compute class prototypes by masked average pooling + prototypes = [] + for c in range(self.num_classes): + mask = (support_masks == c).float().unsqueeze(1) + # Resize mask to feature size + mask = nn.functional.interpolate(mask, size=features.shape[-2:], mode="nearest") + masked_features = features * mask + prototype = masked_features.sum(dim=(0, 2, 3)) / (mask.sum() + 1e-8) + prototypes.append(prototype) + return torch.stack(prototypes) + + def predict_with_prototypes( + self, + query_images: torch.Tensor, + prototypes: torch.Tensor, + ) -> torch.Tensor: + """ + Predict segmentation using class prototypes. + + Args: + query_images: Query images to segment. + prototypes: Class prototype features. + + Returns: + Predicted segmentation masks. + + """ + features = self.backbone(query_images) + # Compute distance to prototypes for each spatial location + distances = [] + for prototype in prototypes: + dist = ((features - prototype.view(1, -1, 1, 1)) ** 2).sum(dim=1) + distances.append(dist) + distances = torch.stack(distances, dim=1) + # Return class with minimum distance + predictions = distances.argmin(dim=1) + # Resize to input size + predictions = nn.functional.interpolate( + predictions.unsqueeze(1).float(), + size=query_images.shape[-2:], + mode="nearest", + ).squeeze(1) + return predictions.long() + + +def create_model(config: dict[str, Any] | None = None) -> FewShotSegmentationModel: + """ + Create a few-shot segmentation model from configuration. + + Args: + config: Model configuration dictionary. + + Returns: + Initialized model. + + """ + if config is None: + config = {} + + return FewShotSegmentationModel( + backbone_name=config.get("backbone", "resnet18"), + num_classes=config.get("num_classes", 2), + pretrained=config.get("pretrained", True), + ) diff --git a/src/few_shot_utils/train.py b/src/few_shot_utils/train.py new file mode 100644 index 0000000..1693a83 --- /dev/null +++ b/src/few_shot_utils/train.py @@ -0,0 +1,209 @@ +"""Training functions for few-shot segmentation.""" + +from typing import Any + +import torch +from torch import nn +from tqdm import tqdm + + +def train_episode( + model: nn.Module, + support_images: torch.Tensor, + support_masks: torch.Tensor, + query_images: torch.Tensor, + query_masks: torch.Tensor, + optimizer: torch.optim.Optimizer, + criterion: nn.Module, +) -> dict[str, float]: + """ + Train on a single few-shot episode. + + This function implements episodic training where the model first extracts + prototypes from the support set and then uses them to segment the query set. + + Args: + model: The few-shot segmentation model. + support_images: Support set images for prototype extraction. + support_masks: Support set masks for prototype extraction. + query_images: Query set images to segment. + query_masks: Query set ground truth masks. + optimizer: Optimizer for updating model weights. + criterion: Loss function. + + Returns: + Dictionary containing loss and metrics. + + """ + model.train() + optimizer.zero_grad() + + # Extract prototypes from support set if model supports it + if hasattr(model, "extract_support_features"): + prototypes = model.extract_support_features(support_images, support_masks) + # Use prototypes for query prediction (prototype-based few-shot learning) + # For now, we use standard forward pass for training + _ = prototypes # Prototypes can be used in more advanced implementations + + # Forward pass on query set + outputs = model(query_images) + + # Compute loss + loss = criterion(outputs, query_masks) + + # Backward pass + loss.backward() + optimizer.step() + + # Compute accuracy + predictions = outputs.argmax(dim=1) + accuracy = (predictions == query_masks).float().mean().item() + + return {"loss": loss.item(), "accuracy": accuracy} + + +def train_model( + model: nn.Module, + train_dataloader: list[dict[str, Any]], + val_dataloader: list[dict[str, Any]] | None = None, + num_epochs: int = 10, + learning_rate: float = 1e-4, + device: str = "cuda", +) -> dict[str, list[float]]: + """ + Train the few-shot segmentation model. + + Args: + model: The model to train. + train_dataloader: Training data batches. + val_dataloader: Validation data batches. + num_epochs: Number of training epochs. + learning_rate: Learning rate for optimizer. + device: Device to train on ('cuda' or 'cpu'). + + Returns: + Dictionary containing training history. + + Raises: + ValueError: If train_dataloader is empty. + + """ + if not train_dataloader: + msg = "train_dataloader cannot be empty" + raise ValueError(msg) + + if not torch.cuda.is_available() and device == "cuda": + device = "cpu" + + model = model.to(device) + optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) + criterion = nn.CrossEntropyLoss() + + history = {"train_loss": [], "train_acc": [], "val_loss": [], "val_acc": []} + + for epoch in range(num_epochs): + # Training + model.train() + epoch_loss = 0.0 + epoch_acc = 0.0 + num_batches = 0 + + for batch in tqdm(train_dataloader, desc=f"Epoch {epoch + 1}/{num_epochs}"): + images = torch.from_numpy(batch["images"]).float().permute(0, 3, 1, 2) + masks = torch.from_numpy(batch["masks"]).long() + + images = images.to(device) + masks = masks.to(device) + + optimizer.zero_grad() + outputs = model(images) + + # Resize outputs to match mask size if needed + if outputs.shape[-2:] != masks.shape[-2:]: + outputs = nn.functional.interpolate( + outputs, size=masks.shape[-2:], mode="bilinear", align_corners=False + ) + + loss = criterion(outputs, masks) + loss.backward() + optimizer.step() + + predictions = outputs.argmax(dim=1) + accuracy = (predictions == masks).float().mean().item() + + epoch_loss += loss.item() + epoch_acc += accuracy + num_batches += 1 + + avg_loss = epoch_loss / max(num_batches, 1) + avg_acc = epoch_acc / max(num_batches, 1) + history["train_loss"].append(avg_loss) + history["train_acc"].append(avg_acc) + + # Validation + if val_dataloader is not None: + val_metrics = _validate(model, val_dataloader, criterion, device) + history["val_loss"].append(val_metrics["loss"]) + history["val_acc"].append(val_metrics["accuracy"]) + print( + f"Epoch {epoch + 1}: Train Loss={avg_loss:.4f}, " + f"Train Acc={avg_acc:.4f}, Val Loss={val_metrics['loss']:.4f}, " + f"Val Acc={val_metrics['accuracy']:.4f}" + ) + else: + print(f"Epoch {epoch + 1}: Train Loss={avg_loss:.4f}, Train Acc={avg_acc:.4f}") + + return history + + +def _validate( + model: nn.Module, + dataloader: list[dict[str, Any]], + criterion: nn.Module, + device: str, +) -> dict[str, float]: + """ + Validate the model. + + Args: + model: The model to validate. + dataloader: Validation data batches. + criterion: Loss function. + device: Device to run on. + + Returns: + Dictionary containing validation metrics. + + """ + model.eval() + total_loss = 0.0 + total_acc = 0.0 + num_batches = 0 + + with torch.no_grad(): + for batch in dataloader: + images = torch.from_numpy(batch["images"]).float().permute(0, 3, 1, 2) + masks = torch.from_numpy(batch["masks"]).long() + + images = images.to(device) + masks = masks.to(device) + + outputs = model(images) + + if outputs.shape[-2:] != masks.shape[-2:]: + outputs = nn.functional.interpolate( + outputs, size=masks.shape[-2:], mode="bilinear", align_corners=False + ) + + loss = criterion(outputs, masks) + predictions = outputs.argmax(dim=1) + accuracy = (predictions == masks).float().mean().item() + + total_loss += loss.item() + total_acc += accuracy + num_batches += 1 + + return { + "loss": total_loss / max(num_batches, 1), + "accuracy": total_acc / max(num_batches, 1), + }