diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..cdd2f23 --- /dev/null +++ b/.gitignore @@ -0,0 +1,177 @@ +# data and log +.data/ +lightning_logs/ +*.npz +logs/ +outputs/ +/data/ +/notebooks/data/ + + +#cache +cache/ + + +# 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/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +.idea/ + +# VSCode debug launch file +.vscode/ \ No newline at end of file diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100755 index 0000000..58d8296 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,25 @@ +fail_fast: true + +repos: + +- repo: https://github.com/psf/black + rev: 23.3.0 + hooks: + - id: black + args: [--config, pyproject.toml] + types: [python] + +- repo: https://github.com/charliermarsh/ruff-pre-commit + rev: "v0.0.272" + hooks: + - id: ruff + args: [--fix, --exit-non-zero-on-fix] + +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.4.0 + hooks: + - id: check-toml + id: check-yaml + id: detect-private-key + id: end-of-file-fixer + id: trailing-whitespace \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..799cc5b --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2024 AI4CO + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..38cf1f2 --- /dev/null +++ b/README.md @@ -0,0 +1,106 @@ +# PARCO + +[![arXiv](https://img.shields.io/badge/arXiv-2409.03811-b31b1b.svg)](https://arxiv.org/abs/2409.03811) [![Slack](https://img.shields.io/badge/slack-chat-611f69.svg?logo=slack)](https://join.slack.com/t/rl4co/shared_invite/zt-1ytz2c1v4-0IkQ8NQH4TRXIX8PrRmDhQ) +[![License: MIT](https://img.shields.io/badge/License-MIT-red.svg)](https://opensource.org/licenses/MIT) + +Code repository for "PARCO: Learning Parallel Autoregressive Policies for Efficient Multi-Agent Combinatorial Optimization" + + +
+ + Autoregressive policy (AR) and Parallel Autoregressive (PAR) decoding +
+ +
+ +
+ + PARCO Model +
+ + +## 🚀 Usage + +### Installation + +```bash +pip install -e . +``` + +Note: we recommend using a virtual environment. Using Conda: + +```bash +conda create -n parco +conda activate parco +``` + +### Data generation +You can generate data using the `generate_data.py`, which will automatically generate all the data we use for training and testing: + +```bash +python generate_data.py +``` + +### Quickstart Notebooks +We made examples for each problem that can be trained under two minutes on consumer hardware. You can find them in the `examples/` folder: + +- [1.quickstart-hcvrp.ipynb](examples/1.quickstart-hcvrp.ipynb): HCVRP (Heterogeneous Capacitated Vehicle Routing Problem) +- [2.quickstart-omdcpdp.ipynb](examples/2.quickstart-omdcpdp.ipynb): OMDCPDP (Open Multi-Depot Capacitated Pickup and Delivery Problem) +- [3.quickstart-ffsp.ipynb](examples/3.quickstart-ffsp.ipynb): FFSP (Flexible Flow Shop Scheduling Problem) + + +### Train your own model +You can train your own model using the `train.py` script. For example, to train a model for the HCVRP problem, you can run: + +```bash +python train.py experiment=hcvrp +``` + +you can change the `experiment` parameter to `omdcpdp` or `ffsp` to train the model for the OMDCPDP or FFSP problem, respectively. + + +Note on legacy FFSP code: the initial version we made was not yet integrated in RL4CO, so we left it the [`parco/tasks/ffsp_old`](parco/tasks/ffsp_old/README.md) folder, so you can still use it. + + +### Testing + +You may run the `test.py` script to evaluate the model, e.g. with: + +```bash +python test.py --problem hcvrp --decode_type greedy --batch_size 128 --sample_size 1 +``` + + +## 🤩 Citation + +If you find PARCO valuable for your research or applied projects: + +```bibtex +@article{berto2024parco, + title={{PARCO: Learning Parallel Autoregressive Policies for Efficient Multi-Agent Combinatorial Optimization}}, + author={Federico Berto and Chuanbo Hua and Laurin Luttmann and Jiwoo Son and Junyoung Park and Kyuree Ahn and Changhyun Kwon and Lin Xie and Jinkyoo Park}, + year={2024}, + journal={arXiv preprint arXiv:2409.03811}, + note={\url{https://github.com/ai4co/parco}} +} +``` + +We will also be happy if you cite the RL4CO framework that we used to create PARCO: + +```bibtex +@article{berto2024rl4co, + title={{RL4CO: an Extensive Reinforcement Learning for Combinatorial Optimization Benchmark}}, + author={Federico Berto and Chuanbo Hua and Junyoung Park and Laurin Luttmann and Yining Ma and Fanchen Bu and Jiarui Wang and Haoran Ye and Minsu Kim and Sanghyeok Choi and Nayeli Gast Zepeda and Andr\'e Hottung and Jianan Zhou and Jieyi Bi and Yu Hu and Fei Liu and Hyeonah Kim and Jiwoo Son and Haeyeon Kim and Davide Angioni and Wouter Kool and Zhiguang Cao and Jie Zhang and Kijung Shin and Cathy Wu and Sungsoo Ahn and Guojie Song and Changhyun Kwon and Lin Xie and Jinkyoo Park}, + year={2024}, + journal={arXiv preprint arXiv:2306.17100}, + note={\url{https://github.com/ai4co/rl4co}} +} +``` + +--- + +
+ + AI4CO Logo + +
\ No newline at end of file diff --git a/assets/ar-vs-par.png b/assets/ar-vs-par.png new file mode 100644 index 0000000..46b0e62 Binary files /dev/null and b/assets/ar-vs-par.png differ diff --git a/assets/parco-model.png b/assets/parco-model.png new file mode 100644 index 0000000..9213fc4 Binary files /dev/null and b/assets/parco-model.png differ diff --git a/checkpoints/hcvrp/parco.ckpt b/checkpoints/hcvrp/parco.ckpt new file mode 100644 index 0000000..b7ba79c Binary files /dev/null and b/checkpoints/hcvrp/parco.ckpt differ diff --git a/checkpoints/omdcpdp/parco.ckpt b/checkpoints/omdcpdp/parco.ckpt new file mode 100644 index 0000000..807fff4 Binary files /dev/null and b/checkpoints/omdcpdp/parco.ckpt differ diff --git a/configs/__init__.py b/configs/__init__.py new file mode 100644 index 0000000..56bf7f4 --- /dev/null +++ b/configs/__init__.py @@ -0,0 +1 @@ +# this file is needed here to include configs when building project as a package diff --git a/configs/callbacks/default.yaml b/configs/callbacks/default.yaml new file mode 100644 index 0000000..f0ab33a --- /dev/null +++ b/configs/callbacks/default.yaml @@ -0,0 +1,19 @@ +defaults: + - model_checkpoint.yaml + - model_summary.yaml + - rich_progress_bar.yaml + - speed_monitor.yaml + - learning_rate_monitor.yaml + - _self_ + +model_checkpoint: + dirpath: ${paths.output_dir}/checkpoints + filename: "epoch_{epoch:03d}" + monitor: "val/reward" + mode: "max" + save_last: True + auto_insert_metric_name: False + save_top_k: 1 # set to -1 to save all checkpoints + +model_summary: + max_depth: 5 # change to -1 to show all. 5 strikes a good balance between readability and completeness diff --git a/configs/callbacks/early_stopping.yaml b/configs/callbacks/early_stopping.yaml new file mode 100644 index 0000000..59958b1 --- /dev/null +++ b/configs/callbacks/early_stopping.yaml @@ -0,0 +1,17 @@ +# https://pytorch-lightning.readthedocs.io/en/latest/api/lightning.callbacks.EarlyStopping.html + +# Monitor a metric and stop training when it stops improving. +# Look at the above link for more detailed information. +early_stopping: + _target_: lightning.pytorch.callbacks.EarlyStopping + monitor: ??? # quantity to be monitored, must be specified !!! + min_delta: 0. # minimum change in the monitored quantity to qualify as an improvement + patience: 3 # number of checks with no improvement after which training will be stopped + verbose: False # verbosity mode + mode: "min" # "max" means higher metric value is better, can be also "min" + strict: True # whether to crash the training if monitor is not found in the validation metrics + check_finite: True # when set True, stops training when the monitor becomes NaN or infinite + stopping_threshold: null # stop training immediately once the monitored quantity reaches this threshold + divergence_threshold: null # stop training as soon as the monitored quantity becomes worse than this threshold + check_on_train_epoch_end: null # whether to run early stopping at the end of the training epoch + # log_rank_zero_only: False # this keyword argument isn't available in stable version diff --git a/configs/callbacks/learning_rate_monitor.yaml b/configs/callbacks/learning_rate_monitor.yaml new file mode 100644 index 0000000..eddad48 --- /dev/null +++ b/configs/callbacks/learning_rate_monitor.yaml @@ -0,0 +1,3 @@ +learning_rate_monitor: + _target_: lightning.pytorch.callbacks.LearningRateMonitor + logging_interval: epoch \ No newline at end of file diff --git a/configs/callbacks/model_checkpoint.yaml b/configs/callbacks/model_checkpoint.yaml new file mode 100644 index 0000000..4b3bd7c --- /dev/null +++ b/configs/callbacks/model_checkpoint.yaml @@ -0,0 +1,19 @@ +# https://pytorch-lightning.readthedocs.io/en/latest/api/lightning.callbacks.ModelCheckpoint.html + +# Save the model periodically by monitoring a quantity. +# Look at the above link for more detailed information. +model_checkpoint: + _target_: lightning.pytorch.callbacks.ModelCheckpoint + dirpath: null # directory to save the model file + filename: null # checkpoint filename + monitor: null # name of the logged metric which determines when model is improving + verbose: False # verbosity mode + save_last: null # additionally always save an exact copy of the last checkpoint to a file last.ckpt + save_top_k: 1 # save k best models (determined by above metric) + mode: "max" # "max" means higher metric value is better, can be also "min" + auto_insert_metric_name: True # when True, the checkpoints filenames will contain the metric name + save_weights_only: False # if True, then only the model’s weights will be saved + every_n_train_steps: null # number of training steps between checkpoints + train_time_interval: null # checkpoints are monitored at the specified time interval + every_n_epochs: null # number of epochs between checkpoints + save_on_train_epoch_end: null # whether to run checkpointing at the end of the training epoch or the end of validation diff --git a/configs/callbacks/model_summary.yaml b/configs/callbacks/model_summary.yaml new file mode 100644 index 0000000..b1fa2ad --- /dev/null +++ b/configs/callbacks/model_summary.yaml @@ -0,0 +1,7 @@ +# https://pytorch-lightning.readthedocs.io/en/latest/api/lightning.callbacks.RichModelSummary.html + +# Generates a summary of all layers in a LightningModule with rich text formatting. +# Look at the above link for more detailed information. +model_summary: + _target_: lightning.pytorch.callbacks.RichModelSummary + max_depth: 1 # the maximum depth of layer nesting that the summary will include diff --git a/configs/callbacks/rich_progress_bar.yaml b/configs/callbacks/rich_progress_bar.yaml new file mode 100644 index 0000000..bd58cde --- /dev/null +++ b/configs/callbacks/rich_progress_bar.yaml @@ -0,0 +1,6 @@ +# https://pytorch-lightning.readthedocs.io/en/latest/api/lightning.callbacks.RichProgressBar.html + +# Create a progress bar with rich text formatting. +# Look at the above link for more detailed information. +rich_progress_bar: + _target_: lightning.pytorch.callbacks.RichProgressBar diff --git a/configs/callbacks/speed_monitor.yaml b/configs/callbacks/speed_monitor.yaml new file mode 100644 index 0000000..020f782 --- /dev/null +++ b/configs/callbacks/speed_monitor.yaml @@ -0,0 +1,7 @@ +# monitor speed of training + +speed_monitor: + _target_: rl4co.utils.callbacks.speed_monitor.SpeedMonitor + intra_step_time: True + inter_step_time: True + epoch_time: True \ No newline at end of file diff --git a/configs/debug/default.yaml b/configs/debug/default.yaml new file mode 100644 index 0000000..1886902 --- /dev/null +++ b/configs/debug/default.yaml @@ -0,0 +1,35 @@ +# @package _global_ + +# default debugging setup, runs 1 full epoch +# other debugging configs can inherit from this one + +# overwrite task name so debugging logs are stored in separate folder +task_name: "debug" + +# disable callbacks and loggers during debugging +callbacks: null +logger: null + +extras: + ignore_warnings: False + enforce_tags: False + +# sets level of all command line loggers to 'DEBUG' +# https://hydra.cc/docs/tutorials/basic/running_your_app/logging/ +hydra: + job_logging: + root: + level: DEBUG + + # use this to also set hydra loggers to 'DEBUG' + # verbose: True + +trainer: + max_epochs: 1 + accelerator: cpu # debuggers don't like gpus + devices: 1 # debuggers don't like multiprocessing + detect_anomaly: true # raise exception if NaN or +/-inf is detected in any tensor + +data: + num_workers: 0 # debuggers don't like multiprocessing + pin_memory: False # disable gpu memory pin diff --git a/configs/debug/fdr.yaml b/configs/debug/fdr.yaml new file mode 100644 index 0000000..98eba22 --- /dev/null +++ b/configs/debug/fdr.yaml @@ -0,0 +1,9 @@ +# @package _global_ + +# runs 1 train, 1 validation and 1 test step + +defaults: + - default.yaml + +trainer: + fast_dev_run: true diff --git a/configs/debug/limit.yaml b/configs/debug/limit.yaml new file mode 100644 index 0000000..cc28852 --- /dev/null +++ b/configs/debug/limit.yaml @@ -0,0 +1,12 @@ +# @package _global_ + +# uses only 1% of the training data and 5% of validation/test data + +defaults: + - default.yaml + +trainer: + max_epochs: 3 + limit_train_batches: 0.01 + limit_val_batches: 0.05 + limit_test_batches: 0.05 diff --git a/configs/debug/overfit.yaml b/configs/debug/overfit.yaml new file mode 100644 index 0000000..d1f63e8 --- /dev/null +++ b/configs/debug/overfit.yaml @@ -0,0 +1,13 @@ +# @package _global_ + +# overfits to 3 batches + +defaults: + - default.yaml + +trainer: + max_epochs: 20 + overfit_batches: 3 + +# model ckpt and early stopping need to be disabled during overfitting +callbacks: null diff --git a/configs/debug/profiler.yaml b/configs/debug/profiler.yaml new file mode 100644 index 0000000..e18df1c --- /dev/null +++ b/configs/debug/profiler.yaml @@ -0,0 +1,12 @@ +# @package _global_ + +# runs with execution time profiling + +defaults: + - default.yaml + +trainer: + max_epochs: 1 + profiler: "simple" + # profiler: "advanced" + # profiler: "pytorch" diff --git a/configs/env/default.yaml b/configs/env/default.yaml new file mode 100644 index 0000000..7a45387 --- /dev/null +++ b/configs/env/default.yaml @@ -0,0 +1,2 @@ +_target_: parco.envs.hcvrp.HCVRPEnv +name: hcvrp \ No newline at end of file diff --git a/configs/env/ffsp/ffsp100.yaml b/configs/env/ffsp/ffsp100.yaml new file mode 100644 index 0000000..2bfcab8 --- /dev/null +++ b/configs/env/ffsp/ffsp100.yaml @@ -0,0 +1,15 @@ +# @package _global_ +defaults: + - _self_ + +trainer: + max_epochs: 200 + +env: + _target_: parco.envs.ffsp.FFSPEnv + name: ffsp + + generator_params: + num_stage: 3 + num_machine: 4 + num_job: 100 diff --git a/configs/env/ffsp/ffsp20.yaml b/configs/env/ffsp/ffsp20.yaml new file mode 100644 index 0000000..5cf1f8b --- /dev/null +++ b/configs/env/ffsp/ffsp20.yaml @@ -0,0 +1,15 @@ +# @package _global_ +defaults: + - _self_ + +trainer: + max_epochs: 100 + +env: + _target_: parco.envs.ffsp.FFSPEnv + name: ffsp + + generator_params: + num_stage: 3 + num_machine: 4 + num_job: 20 diff --git a/configs/env/ffsp/ffsp50.yaml b/configs/env/ffsp/ffsp50.yaml new file mode 100644 index 0000000..83bd14d --- /dev/null +++ b/configs/env/ffsp/ffsp50.yaml @@ -0,0 +1,15 @@ +# @package _global_ +defaults: + - _self_ + +trainer: + max_epochs: 150 + +env: + _target_: parco.envs.ffsp.FFSPEnv + name: ffsp + + generator_params: + num_stage: 3 + num_machine: 4 + num_job: 50 diff --git a/configs/env/hcvrp.yaml b/configs/env/hcvrp.yaml new file mode 100644 index 0000000..a69ddb3 --- /dev/null +++ b/configs/env/hcvrp.yaml @@ -0,0 +1,27 @@ +_target_: parco.envs.hcvrp.HCVRPEnv +name: hcvrp + +generator_params: + num_loc: 100 # max locs + num_agents: 7 # min locs + +data_dir: ${paths.root_dir}/data/${env.name} + +# Note that validation is not used for guiding training and this is already the test set +# so we can directly check the progress here! +val_file: [ + "n60_m3_seed24610.npz", "n60_m5_seed24610.npz", "n60_m7_seed24610.npz", + "n80_m3_seed24610.npz", "n80_m5_seed24610.npz", "n80_m7_seed24610.npz", + "n100_m3_seed24610.npz", "n100_m5_seed24610.npz", "n100_m7_seed24610.npz", +] + +# Note: we take the number of agents "m" from here directly! +val_dataloader_names: [ + "n60_m3", "n60_m5", "n60_m7", + "n80_m3", "n80_m5", "n80_m7", + "n100_m3", "n100_m5", "n100_m7", + ] + +test_file: ${env.val_file} + +test_dataloader_names: ${env.val_dataloader_names} \ No newline at end of file diff --git a/configs/env/omdcpdp.yaml b/configs/env/omdcpdp.yaml new file mode 100644 index 0000000..6d5a243 --- /dev/null +++ b/configs/env/omdcpdp.yaml @@ -0,0 +1,24 @@ +_target_: parco.envs.omdcpdp.env.OMDCPDPEnv +name: omdcpdp +reward_mode: "lateness" + +generator_params: + num_loc: 100 # changed to accomodate the new data + num_agents: 30 + +data_dir: ${paths.root_dir}/data/${env.name} + +val_file: ["n50_m5_seed3333.npz", "n50_m10_seed3333.npz", "n50_m15_seed3333.npz", + "n100_m10_seed3333.npz", "n100_m20_seed3333.npz", "n100_m30_seed3333.npz", + "n200_m20_seed3333.npz", "n200_m40_seed3333.npz", "n200_m60_seed3333.npz", +] + +val_dataloader_names: [ + "n50_m5", "n50_m10", "n50_m20", + "n100_m10", "n100_m20", "n100_m30", + "n200_m20", "n200_m40", "n200_m60", +] + +test_file: ${env.val_file} + +test_dataloader_names: ${env.val_dataloader_names} diff --git a/configs/experiment/ffsp.yaml b/configs/experiment/ffsp.yaml new file mode 100644 index 0000000..cf331eb --- /dev/null +++ b/configs/experiment/ffsp.yaml @@ -0,0 +1,92 @@ +# @package _global_ + +# Override defaults: take configs from relative path +defaults: + - override /model: parco.yaml + - override /env: ffsp/ffsp20.yaml + - override /callbacks: default.yaml + - override /trainer: default.yaml + #- override /logger: null # comment this line to enable logging + - override /logger: wandb.yaml + + +# Model hyperparameters +model: + _target_: "rl4co.models.zoo.pomo.POMO" + num_augment: 0 + num_starts: 24 + policy: # note: all other arguments (e.g. embeddings) are automatically taken from the env + # otherwise, you may pass init_embedding / context_embedding (example below) + _target_: "parco.models.policy.PARCOMultiStagePolicy" + num_stages: "${env.generator_params.num_stage}" + env_name: "${env.name}" + agent_handler: "highprob" + embed_dim: 256 + num_encoder_layers: 3 + num_heads: 16 + ms_hidden_dim: 32 + feedforward_hidden: 512 + bias: False + normalization: "instance" + use_pos_token: True + scale_factor: 10 + init_embedding_kwargs: + embed_dim: ${model.policy.embed_dim} + one_hot_seed_cnt: "${env.generator_params.num_machine}" + context_embedding_kwargs: + use_comm_layer: True + num_heads: ${model.policy.num_heads} + normalization: ${model.policy.normalization} + feedforward_hidden: ${model.policy.feedforward_hidden} + bias: ${model.policy.bias} + dynamic_embedding_kwargs: + embed_dim: ${model.policy.embed_dim} + scale_factor: ${model.policy.scale_factor} + val_decode_type: "sampling" + test_decode_type: "sampling" + pointer_check_nan: False + use_decoder_mha_mask: False + use_ham_encoder: True + batch_size: 50 + val_batch_size: 100 + test_batch_size: 100 + train_data_size: 1000 + val_data_size: 100 + test_data_size: 1000 + optimizer_kwargs: + lr: 1e-4 + weight_decay: 0.0 + lr_scheduler: + "CosineAnnealingLR" + lr_scheduler_kwargs: + T_max: ${trainer.max_epochs} + eta_min: 0.0000001 + # lr_scheduler: + # "MultiStepLR" + # lr_scheduler_kwargs: + # milestones: [80, 95] + # gamma: 0.1 + + # NOTE: this should be done on the model side + metrics: + train: ["reward", "max_reward"] + val: ["reward", "max_reward"] + test: ["reward", "max_reward"] + log_on_step: True + + +# Logging: we use Wandb in this case +logger: + wandb: + project: "parco-${env.name}" + tags: ["parco", "${env.name}", "communication"] + group: "${env.name}_n${env.generator_params.num_job}_m${env.generator_params.num_machine}" + name: "parco" + + +seed: 1234 + +# Used to save the best model. However, we are not using this in the current setup +callbacks: + model_checkpoint: + monitor: "val/max_reward" \ No newline at end of file diff --git a/configs/experiment/hcvrp.yaml b/configs/experiment/hcvrp.yaml new file mode 100644 index 0000000..6540bdb --- /dev/null +++ b/configs/experiment/hcvrp.yaml @@ -0,0 +1,74 @@ +# @package _global_ + +# Override defaults: take configs from relative path +defaults: + - override /model: parco.yaml + - override /env: hcvrp.yaml + - override /callbacks: default.yaml + - override /trainer: default.yaml + # - override /logger: null # comment this line to enable logging + - override /logger: wandb.yaml + + +# NOTE: other hparams are in the env file +generator_params: + num_loc: 100 # max locs + num_agents: 7 # min locs + +# Model hyperparameters +model: + policy: # note: all other arguments (e.g. embeddings) are automatically taken from the env + # otherwise, you may pass init_embedding / context_embedding (example below) + _target_: "parco.models.policy.PARCOPolicy" + env_name: "${env.name}" + agent_handler: "highprob" + embed_dim: 128 + norm_after: false # true means we use Kool structure, which seems slightly worse + normalization: "rms" + use_final_norm: true # LLM way + parallel_gated_kwargs: + mlp_activation: "silu" # use MLP as in LLaMa + context_embedding_kwargs: + normalization: "rms" + norm_after: false # true means we use Kool structure, which seems slightly worse + use_final_norm: true # LLM way + parallel_gated_kwargs: + mlp_activation: "silu" + batch_size: 128 + val_batch_size: ${model.batch_size} + test_batch_size: ${model.batch_size} + train_data_size: 100_000 + val_data_size: 10_000 + test_data_size: 10_000 + optimizer_kwargs: + lr: 1e-4 + weight_decay: 0.0 + lr_scheduler: + "MultiStepLR" + lr_scheduler_kwargs: + milestones: [80, 95] + gamma: 0.1 + num_augment: 8 + train_min_agents: 3 + train_max_agents: ${env.generator_params.num_agents} # max agents is the number of agents + train_min_size: 60 + train_max_size: ${env.generator_params.num_loc} # max size is the number of locations + +# Logging: we use Wandb in this case +logger: + wandb: + project: "parco-${env.name}" + tags: ["parco", "${env.name}", "communication"] + group: "${env.name}_n${env.generator_params.num_loc}_m${env.generator_params.num_agents}" + name: "parco" + +# Trainer: this is a customized version of the PyTorch Lightning trainer. +trainer: + max_epochs: 100 + +seed: 1234 + +# Used to save the best model. However, we are not using this in the current setup +callbacks: + model_checkpoint: + monitor: "val/reward/n60_m5" \ No newline at end of file diff --git a/configs/experiment/omdcpdp.yaml b/configs/experiment/omdcpdp.yaml new file mode 100644 index 0000000..2395519 --- /dev/null +++ b/configs/experiment/omdcpdp.yaml @@ -0,0 +1,74 @@ +# @package _global_ + +# Override defaults: take configs from relative path +defaults: + - override /model: parco.yaml + - override /env: omdcpdp.yaml + - override /callbacks: default.yaml + - override /trainer: default.yaml + # - override /logger: null # comment this line to enable logging + - override /logger: wandb.yaml + +env: + generator_params: + num_loc: 100 # max locs + num_agents: 50 # min locs + + +# Model hyperparameters +model: + policy: # note: all other arguments (e.g. embeddings) are automatically taken from the env + # otherwise, you may pass init_embedding / context_embedding (example below) + _target_: "parco.models.policy.PARCOPolicy" + env_name: "${env.name}" + agent_handler: "highprob" + embed_dim: 128 + norm_after: false # true means we use Kool structure, which seems slightly worse + normalization: "rms" + use_final_norm: false + parallel_gated_kwargs: + mlp_activation: "silu" # use MLP as in LLaMa + context_embedding_kwargs: + normalization: "rms" + norm_after: false # true means we use Kool structure, which seems slightly worse + use_final_norm: false + parallel_gated_kwargs: + mlp_activation: "silu" + batch_size: 128 + val_batch_size: ${model.batch_size} + test_batch_size: ${model.batch_size} + train_data_size: 100_000 + val_data_size: 10_000 + test_data_size: 10_000 + optimizer_kwargs: + lr: 1e-4 + weight_decay: 0.0 + lr_scheduler: + "MultiStepLR" + lr_scheduler_kwargs: + milestones: [80, 95] + gamma: 0.1 + num_augment: 8 + train_min_agents: 10 + train_max_agents: ${env.generator_params.num_agents} # max agents is the number of agents + train_min_size: 50 + train_max_size: ${env.generator_params.num_loc} # max size is the number of locations + +# Logging: we use Wandb in this case +logger: + wandb: + project: "parco-${env.name}" + tags: ["parco", "${env.name}", "communication"] + group: "${env.name}_n${env.generator_params.num_loc}_m${env.generator_params.num_agents}" + name: "parco" + +# Trainer: this is a customized version of the PyTorch Lightning trainer. +trainer: + max_epochs: 100 + +seed: 1234 + +# Used to save the best model. However, we are not using this in the current setup +callbacks: + model_checkpoint: + monitor: "val/reward/n100_m35" \ No newline at end of file diff --git a/configs/extras/default.yaml b/configs/extras/default.yaml new file mode 100644 index 0000000..b9c6b62 --- /dev/null +++ b/configs/extras/default.yaml @@ -0,0 +1,8 @@ +# disable python warnings if they annoy you +ignore_warnings: False + +# ask user for tags if none are provided in the config +enforce_tags: True + +# pretty print config tree at the start of the run using Rich library +print_config: True diff --git a/configs/ffsp/config.yaml b/configs/ffsp/config.yaml new file mode 100644 index 0000000..465f051 --- /dev/null +++ b/configs/ffsp/config.yaml @@ -0,0 +1,86 @@ +defaults: + - _self_ + - env: ffsp50 + + +model: + machine_cnt_list: ${env.machine_cnt_list} + pomo_size: ${env.pomo_size} + embedding_dim: 256 + encoder_layer_num: 3 + normalization: "instance" + norm_after: False + qkv_dim: 16 + head_num: 16 + logit_clipping: 10 + ff_hidden_dim: 512 + ms_hidden_dim: 16 + scale_factor: 10 + eval_type: 'softmax' + one_hot_seed_cnt: 4 # must be >= machine_cnt + use_comm_layer: True + use_graph_proj: False + use_ham: True + use_decoder_mha_mask: True + scale_dots: True + use_pos_token: True + + +train: + use_cuda: True + cuda_device_num: 5 + train_episodes: 1000 + train_batch_size: 50 + accumulation_steps: 1 + max_grad_norm: 1 + logging: + model_save_interval: 100 + img_save_interval: 100 + log_image_params_1: + json_foldername: 'log_image_style' + filename: 'style.json' + log_image_params_2: + json_foldername: 'log_image_style' + filename: 'style_loss.json' + + +optimizer: + optimizer: + lr: 1e-4 + weight_decay: 1e-6 + scheduler: + # class: "exponential" + # kwargs: + # gamma: 0.98 + # class: "multistep" + # kwargs: + # milestones: [60, 90, 120, 150] + # gamma: 0.3 + class: "cos" + kwargs: + T_max: ${train.epochs} + eta_min: 0.0000001 + + +test: + saved_problem_folder: "../data" + saved_problem_filename: "unrelated_10000_problems_${env.ma_cnt_str}_job${env.job_cnt}_2_10.pt" + problem_count: 1000 + test_batch_size: 50 + augmentation_enable: False + aug_factor: 128 + + +logger: + log_file: + desc: 'matnet_train' + filename: 'log.txt' + +# hydra: +# run: +# dir: ${ROOTDIR:}/outputs/${instance.num_jobs}-${instance.num_machines}/runs/${model.model_type}/${now:%Y-%m-%d}/${now:%H-%M-%S}-0 +# sweep: +# dir: ${ROOTDIR:}/outputs/${instance.num_jobs}-${instance.num_machines}/runs/${model.model_type}/${now:%Y-%m-%d} +# subdir: ${now:%H-%M-%S}-${hydra:job.num} +# launcher: +# n_jobs: ${num_jobs:${train.first_gpu}} diff --git a/configs/hydra/default.yaml b/configs/hydra/default.yaml new file mode 100644 index 0000000..ad6704d --- /dev/null +++ b/configs/hydra/default.yaml @@ -0,0 +1,22 @@ +# https://hydra.cc/docs/configure_hydra/intro/ + +# enable color logging +defaults: + - override hydra_logging: colorlog + - override job_logging: colorlog + +## NOTE: uncomment below for default logging +# output directory, generated dynamically on each run +# run: +# dir: ${paths.log_dir}/${mode}/runs/${now:%Y-%m-%d}_${now:%H-%M-%S} +# sweep: +# dir: ${paths.log_dir}/${mode}/multiruns/${now:%Y-%m-%d}_${now:%H-%M-%S} +# subdir: ${hydra.job.num} + +# NOTE: comment below and use above if you don't want to use wandb +# modify the log directory to separate between models and envs +run: + dir: ${paths.log_dir}/${mode}/runs/${logger.wandb.group}/${logger.wandb.name}/${now:%Y-%m-%d}_${now:%H-%M-%S} +sweep: + dir: ${paths.log_dir}/${mode}/multiruns/${logger.wandb.group}/${logger.wandb.name}/${now:%Y-%m-%d}_${now:%H-%M-%S} + subdir: ${hydra.job.num} \ No newline at end of file diff --git a/configs/logger/aim.yaml b/configs/logger/aim.yaml new file mode 100644 index 0000000..8f9f6ad --- /dev/null +++ b/configs/logger/aim.yaml @@ -0,0 +1,28 @@ +# https://aimstack.io/ + +# example usage in lightning module: +# https://github.com/aimhubio/aim/blob/main/examples/pytorch_lightning_track.py + +# open the Aim UI with the following command (run in the folder containing the `.aim` folder): +# `aim up` + +aim: + _target_: aim.pytorch_lightning.AimLogger + repo: ${paths.root_dir} # .aim folder will be created here + # repo: "aim://ip_address:port" # can instead provide IP address pointing to Aim remote tracking server which manages the repo, see https://aimstack.readthedocs.io/en/latest/using/remote_tracking.html# + + # aim allows to group runs under experiment name + experiment: null # any string, set to "default" if not specified + + train_metric_prefix: "train/" + val_metric_prefix: "val/" + test_metric_prefix: "test/" + + # sets the tracking interval in seconds for system usage metrics (CPU, GPU, memory, etc.) + system_tracking_interval: 10 # set to null to disable system metrics tracking + + # enable/disable logging of system params such as installed packages, git info, env vars, etc. + log_system_params: true + + # enable/disable tracking console logs (default value is true) + capture_terminal_logs: false # set to false to avoid infinite console log loop issue https://github.com/aimhubio/aim/issues/2550 diff --git a/configs/logger/comet.yaml b/configs/logger/comet.yaml new file mode 100644 index 0000000..e078927 --- /dev/null +++ b/configs/logger/comet.yaml @@ -0,0 +1,12 @@ +# https://www.comet.ml + +comet: + _target_: lightning.pytorch.loggers.comet.CometLogger + api_key: ${oc.env:COMET_API_TOKEN} # api key is loaded from environment variable + save_dir: "${paths.output_dir}" + project_name: "lightning-hydra-template" + rest_api_key: null + # experiment_name: "" + experiment_key: null # set to resume experiment + offline: False + prefix: "" diff --git a/configs/logger/csv.yaml b/configs/logger/csv.yaml new file mode 100644 index 0000000..fa028e9 --- /dev/null +++ b/configs/logger/csv.yaml @@ -0,0 +1,7 @@ +# csv logger built in lightning + +csv: + _target_: lightning.pytorch.loggers.csv_logs.CSVLogger + save_dir: "${paths.output_dir}" + name: "csv/" + prefix: "" diff --git a/configs/logger/many_loggers.yaml b/configs/logger/many_loggers.yaml new file mode 100644 index 0000000..801444d --- /dev/null +++ b/configs/logger/many_loggers.yaml @@ -0,0 +1,9 @@ +# train with many loggers at once + +defaults: + # - comet.yaml + - csv.yaml + # - mlflow.yaml + # - neptune.yaml + - tensorboard.yaml + - wandb.yaml diff --git a/configs/logger/mlflow.yaml b/configs/logger/mlflow.yaml new file mode 100644 index 0000000..f8fb7e6 --- /dev/null +++ b/configs/logger/mlflow.yaml @@ -0,0 +1,12 @@ +# https://mlflow.org + +mlflow: + _target_: lightning.pytorch.loggers.mlflow.MLFlowLogger + # experiment_name: "" + # run_name: "" + tracking_uri: ${paths.log_dir}/mlflow/mlruns # run `mlflow ui` command inside the `logs/mlflow/` dir to open the UI + tags: null + # save_dir: "./mlruns" + prefix: "" + artifact_location: null + # run_id: "" diff --git a/configs/logger/neptune.yaml b/configs/logger/neptune.yaml new file mode 100644 index 0000000..8233c14 --- /dev/null +++ b/configs/logger/neptune.yaml @@ -0,0 +1,9 @@ +# https://neptune.ai + +neptune: + _target_: lightning.pytorch.loggers.neptune.NeptuneLogger + api_key: ${oc.env:NEPTUNE_API_TOKEN} # api key is loaded from environment variable + project: username/lightning-hydra-template + # name: "" + log_model_checkpoints: True + prefix: "" diff --git a/configs/logger/none.yaml b/configs/logger/none.yaml new file mode 100644 index 0000000..1ce6c82 --- /dev/null +++ b/configs/logger/none.yaml @@ -0,0 +1 @@ +logger: null \ No newline at end of file diff --git a/configs/logger/tensorboard.yaml b/configs/logger/tensorboard.yaml new file mode 100644 index 0000000..2bd31f6 --- /dev/null +++ b/configs/logger/tensorboard.yaml @@ -0,0 +1,10 @@ +# https://www.tensorflow.org/tensorboard/ + +tensorboard: + _target_: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + save_dir: "${paths.output_dir}/tensorboard/" + name: null + log_graph: False + default_hp_metric: True + prefix: "" + # version: "" diff --git a/configs/logger/wandb.yaml b/configs/logger/wandb.yaml new file mode 100644 index 0000000..4139fc1 --- /dev/null +++ b/configs/logger/wandb.yaml @@ -0,0 +1,16 @@ +# https://wandb.ai + +wandb: + _target_: lightning.pytorch.loggers.wandb.WandbLogger + # name: "" # name of the run (normally generated by wandb) + save_dir: "${paths.output_dir}" + offline: False + id: null # pass correct id to resume experiment! + anonymous: null # enable anonymous logging + project: "rl4co" + log_model: False # upload lightning ckpts + prefix: "" # a string to put at the beginning of metric keys + # entity: "" # set to name of your wandb team + group: "" + tags: [] + job_type: "" diff --git a/configs/main.yaml b/configs/main.yaml new file mode 100644 index 0000000..f2ff820 --- /dev/null +++ b/configs/main.yaml @@ -0,0 +1,64 @@ +# @package _global_ + +# specify here default configuration +# order of defaults determines the order in which configs override each other +defaults: + - _self_ + - callbacks: default.yaml + - logger: null # set logger here or use command line (e.g. `python train.py logger=tensorboard`) + - trainer: default.yaml + - paths: default.yaml + - extras: default.yaml + - hydra: default.yaml + - model: default.yaml + - env: default.yaml + + # experiment configs allow for version control of specific hyperparameters + # e.g. best hyperparameters for given model and datamodule + - experiment: base.yaml # set baseline experiment + + # config for hyperparameter optimization + - hparams_search: null + + # optional local config for machine/user specific settings + # it's optional since it doesn't need to exist and is excluded from version control + - optional local: default.yaml + + # debugging config (enable through command line, e.g. `python train.py debug=default) + - debug: null + +# task name, determines output directory path +mode: "train" + +# tags to help you identify your experiments +# you can overwrite this in experiment configs +# overwrite from command line with `python train.py tags="[first_tag, second_tag]"` +tags: ["dev"] + +# set False to skip model training +train: True + +# evaluate on test set, using best model weights achieved during training +# lightning chooses best weights based on the metric specified in checkpoint callback +test: True + +# compile model for faster training with pytorch 2.0 +compile: False + +# simply provide checkpoint path to resume training +ckpt_path: null + +# seed for random number generators in pytorch, numpy and python.random +seed: null + +#https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision +matmul_precision: "medium" + +# metrics to be logged + +# NOTE: this should be done on the model side +metrics: + train: ["loss", "reward"] + val: ["reward"] + test: ["reward"] + log_on_step: True diff --git a/configs/model/mapdp.yaml b/configs/model/mapdp.yaml new file mode 100644 index 0000000..2d6d7d5 --- /dev/null +++ b/configs/model/mapdp.yaml @@ -0,0 +1,8 @@ +_target_: mapdp.models.MAPDPRLModule + +# NOTE: this should be done on the model side +metrics: + train: ["loss", "reward",] + val: ["reward",] + test: ["reward",] + log_on_step: True \ No newline at end of file diff --git a/configs/model/parco.yaml b/configs/model/parco.yaml new file mode 100644 index 0000000..0eca706 --- /dev/null +++ b/configs/model/parco.yaml @@ -0,0 +1,8 @@ +_target_: parco.models.rl.PARCORLModule + +# NOTE: this should be done on the model side +metrics: + train: ["loss", "reward", "halting_ratio", "pos_ratio"] + val: ["reward", "halting_ratio", "pos_ratio"] + test: ["reward", "halting_ratio", "pos_ratio"] + log_on_step: True \ No newline at end of file diff --git a/configs/paths/default.yaml b/configs/paths/default.yaml new file mode 100644 index 0000000..ec81db2 --- /dev/null +++ b/configs/paths/default.yaml @@ -0,0 +1,18 @@ +# path to root directory +# this requires PROJECT_ROOT environment variable to exist +# you can replace it with "." if you want the root to be the current working directory +root_dir: ${oc.env:PROJECT_ROOT} + +# path to data directory +data_dir: ${paths.root_dir}/data/ + +# path to logging directory +log_dir: ${paths.root_dir}/logs/ + +# path to output directory, created dynamically by hydra +# path generation pattern is specified in `configs/hydra/default.yaml` +# use it to store all files generated during the run, like ckpts and metrics +output_dir: ${hydra:runtime.output_dir} + +# path to working directory +work_dir: ${hydra:runtime.cwd} diff --git a/configs/trainer/default.yaml b/configs/trainer/default.yaml new file mode 100644 index 0000000..84df21f --- /dev/null +++ b/configs/trainer/default.yaml @@ -0,0 +1,22 @@ +# Customized for RL4CO +_target_: rl4co.utils.trainer.RL4COTrainer + +default_root_dir: ${paths.output_dir} + +gradient_clip_val: 1.0 +accelerator: "gpu" +precision: "16-mixed" + +# Fast distributed training: comment out to use on single GPU +# devices: 1 # change number of devices +strategy: + _target_: lightning.pytorch.strategies.DDPStrategy + find_unused_parameters: True + gradient_as_bucket_view: True + +# perform a validation loop every N training epochs +check_val_every_n_epoch: 1 + +# set True to to ensure deterministic results +# makes training slower but gives more reproducibility than just setting seeds +deterministic: False \ No newline at end of file diff --git a/data/ffsp/unrelated_10000_problems_444_job20_2_10.pt b/data/ffsp/unrelated_10000_problems_444_job20_2_10.pt new file mode 100644 index 0000000..99d5907 Binary files /dev/null and b/data/ffsp/unrelated_10000_problems_444_job20_2_10.pt differ diff --git a/data/omdcpdp/seoul_n1000_m250.npz b/data/omdcpdp/seoul_n1000_m250.npz new file mode 100644 index 0000000..326ee25 Binary files /dev/null and b/data/omdcpdp/seoul_n1000_m250.npz differ diff --git a/data/omdcpdp/seoul_n1000_m500.npz b/data/omdcpdp/seoul_n1000_m500.npz new file mode 100644 index 0000000..5c30510 Binary files /dev/null and b/data/omdcpdp/seoul_n1000_m500.npz differ diff --git a/data/omdcpdp/seoul_n1000_n100.npz b/data/omdcpdp/seoul_n1000_n100.npz new file mode 100644 index 0000000..cc2b01d Binary files /dev/null and b/data/omdcpdp/seoul_n1000_n100.npz differ diff --git a/examples/1.quickstart-hcvrp.ipynb b/examples/1.quickstart-hcvrp.ipynb new file mode 100755 index 0000000..0aea7ab --- /dev/null +++ b/examples/1.quickstart-hcvrp.ipynb @@ -0,0 +1,401 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PARCO for the HCVRP\n", + "\n", + "Learning a Parallel AutoRegressive policy for a Combinatorial Optimization problem: the Heterogeneous Capacitated Vehicle Routing Problem (HCVRP).\n", + "\n", + "\"Open \"Open\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/botu/miniforge3/envs/rl4co/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" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import torch\n", + "from rl4co.utils.trainer import RL4COTrainer\n", + "\n", + "from parco.envs import HCVRPEnv\n", + "from parco.models import PARCORLModule, PARCOPolicy\n", + "\n", + "# Greedy rollouts over trained model\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Environment" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "env = HCVRPEnv(generator_params=dict(num_loc=60, num_agents=5),\n", + " data_dir=\"\",\n", + " val_file=\"../data/hcvrp/n60_m5_seed24610.npz\",\n", + " test_file=\"../data/hcvrp/n60_m5_seed24610.npz\",\n", + " ) \n", + "td_test_data = env.generator(batch_size=[3])\n", + "td_init = env.reset(td_test_data.clone()).to(device)\n", + "td_init_test = td_init.clone()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "Here we declare our policy and our PARCO model (policy + environment + RL algorithm)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/botu/miniforge3/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:199: Attribute 'env' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['env'])`.\n", + "/home/botu/miniforge3/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:199: Attribute 'policy' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['policy'])`.\n" + ] + } + ], + "source": [ + "emb_dim = 128\n", + "\n", + "# Policy is the neural network\n", + "policy = PARCOPolicy(env_name=env.name,\n", + " embed_dim=emb_dim,\n", + " agent_handler=\"highprob\",\n", + " normalization=\"rms\",\n", + " context_embedding_kwargs={\n", + " \"normalization\": \"rms\",\n", + " \"norm_after\": False,\n", + " }, # these kwargs go to the context embed (communication layers)\n", + " norm_after=False, # True means we use Kool structure\n", + " )\n", + "\n", + "# We refer to the model as the policy + the environment + training data (i.e. full RL algorithm)\n", + "model = PARCORLModule( env, \n", + " policy=policy,\n", + " train_data_size=10_000, # Small size for demo\n", + " val_data_size=1000, # Small size for demo\n", + " batch_size=64, # Small size for demo\n", + " num_augment=8, # SymNCO augments to use as baseline\n", + " train_min_agents=5, # Minmum number of agents to train on\n", + " train_max_agents=5, # Maximum number of agents to train on\n", + " train_min_size=60, # Minimum number of locations to train on\n", + " train_max_size=60, # Maximum number of locations to train on \n", + " optimizer_kwargs={'lr': 1e-4, 'weight_decay': 0}, # Here we have a higher learning rate for demo\n", + ") # example, fewer epochs and simpler model for demo" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test untrained model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average tour length: 19.00\n", + "Tour 0 length: 11.80\n", + "Tour 1 length: 26.31\n", + "Tour 2 length: 18.89\n" + ] + }, + { + "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": [ + "policy = model.policy.to(device)\n", + "out = policy(td_init_test.clone(), env, decode_type=\"greedy\", return_actions=True)\n", + "\n", + "# Plotting\n", + "actions = out[\"actions\"]# .reshaape(td_init.shape[0], -1)\n", + "print(\"Average tour length: {:.2f}\".format(-out['reward'].mean().item()))\n", + "for i in range(3):\n", + " print(f\"Tour {i} length: {-out['reward'][i].item():.2f}\")\n", + " env.render(td_init[i], actions[i].cpu(), plot_number=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "In here we call the trainer and then fit the model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using 16bit Automatic Mixed Precision (AMP)\n", + "GPU available: True (cuda), used: True\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/home/botu/miniforge3/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" + ] + } + ], + "source": [ + "trainer = RL4COTrainer(\n", + " max_epochs=5, # few epochs for demo\n", + " accelerator=\"gpu\", # change to cpu if you don't have a GPU (note: this will be slow!)\n", + " devices=1, # change this to your GPU number\n", + " logger=None,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | env | HCVRPEnv | 0 \n", + "1 | policy | PARCOPolicy | 990 K \n", + "2 | baseline | NoBaseline | 0 \n", + "3 | projection_head | MLP | 33.0 K\n", + "------------------------------------------------\n", + "1.0 M Trainable params\n", + "0 Non-trainable params\n", + "1.0 M Total params\n", + "4.094 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sanity Checking DataLoader 0: 0%| | 0/2 [00:00" + ] + }, + "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": [ + "# Use same initial td as before\n", + "model = model.to(device)\n", + "out = model(td_init_test.clone(), phase=\"test\", decode_type=\"greedy\", return_actions=True)\n", + "\n", + "# Plotting\n", + "actions = out[\"actions\"]#.reshape(td_init.shape[0], -1)\n", + "print(\"Average tour length: {:.2f}\".format(-out['reward'].mean().item()))\n", + "for i in range(3):\n", + " print(f\"Tour {i} length: {-out['reward'][i].item():.2f}\")\n", + " env.render(td_init[i], actions[i].cpu(), plot_number=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch200-py39", + "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.9" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/2.quickstart-omdcpdp.ipynb b/examples/2.quickstart-omdcpdp.ipynb new file mode 100755 index 0000000..c4bb365 --- /dev/null +++ b/examples/2.quickstart-omdcpdp.ipynb @@ -0,0 +1,400 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PARCO for the OMDCPDP\n", + "\n", + "Learning a Parallel AutoRegressive policy for a Combinatorial Optimization problem: the Open Multiple Depot Capacitated Vehicle Routing Problem (OMDCPDP).\n", + "\n", + "\"Open \"Open\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/botu/miniforge3/envs/rl4co/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" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import torch\n", + "from rl4co.utils.trainer import RL4COTrainer\n", + "\n", + "from parco.envs import OMDCPDPEnv\n", + "from parco.models import PARCORLModule, PARCOPolicy\n", + "\n", + "# Greedy rollouts over trained model\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Environment" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "env = OMDCPDPEnv(generator_params=dict(num_loc=60, num_agents=5),\n", + " data_dir=\"\",\n", + " val_file=\"../data/omdcpdp/n50_m10_seed3333.npz\",\n", + " test_file=\"../data/omdcpdp/n50_m10_seed3333.npz\",\n", + " ) \n", + "td_test_data = env.generator(batch_size=[3])\n", + "td_init = env.reset(td_test_data.clone()).to(device)\n", + "td_init_test = td_init.clone()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "Here we declare our policy and our PARCO model (policy + environment + RL algorithm)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/botu/miniforge3/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:199: Attribute 'env' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['env'])`.\n", + "/home/botu/miniforge3/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:199: Attribute 'policy' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['policy'])`.\n" + ] + } + ], + "source": [ + "emb_dim = 128\n", + "\n", + "# Policy is the neural network\n", + "policy = PARCOPolicy(env_name=env.name,\n", + " embed_dim=emb_dim,\n", + " agent_handler=\"highprob\",\n", + " normalization=\"rms\",\n", + " context_embedding_kwargs={\n", + " \"normalization\": \"rms\",\n", + " \"norm_after\": False,\n", + " }, # these kwargs go to the context embed (communication layers)\n", + " norm_after=False, # True means we use Kool structure\n", + " )\n", + "\n", + "# We refer to the model as the policy + the environment + training data (i.e. full RL algorithm)\n", + "model = PARCORLModule( env, \n", + " policy=policy,\n", + " train_data_size=10_000, # Small size for demo\n", + " val_data_size=1000, # Small size for demo\n", + " batch_size=64, # Small size for demo\n", + " num_augment=8, # SymNCO augments to use as baseline\n", + " train_min_agents=5, # Minmum number of agents to train on\n", + " train_max_agents=5, # Maximum number of agents to train on\n", + " train_min_size=60, # Minimum number of locations to train on\n", + " train_max_size=60, # Maximum number of locations to train on \n", + " optimizer_kwargs={'lr': 1e-4, 'weight_decay': 0}, # Here we have a higher learning rate for demo\n", + ") # example, fewer epochs and simpler model for demo" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test untrained model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average tour length: 129.44\n", + "Tour 0 length: 108.70\n", + "Tour 1 length: 145.46\n", + "Tour 2 length: 134.15\n" + ] + }, + { + "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": [ + "policy = model.policy.to(device)\n", + "out = policy(td_init_test.clone(), env, decode_type=\"greedy\", return_actions=True)\n", + "\n", + "# Plotting\n", + "actions = out[\"actions\"]# .reshaape(td_init.shape[0], -1)\n", + "print(\"Average tour length: {:.2f}\".format(-out['reward'].mean().item()))\n", + "for i in range(3):\n", + " print(f\"Tour {i} length: {-out['reward'][i].item():.2f}\")\n", + " env.render(td_init[i], actions[i].cpu(), plot_number=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "In here we call the trainer and then fit the model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using 16bit Automatic Mixed Precision (AMP)\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/home/botu/miniforge3/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" + ] + } + ], + "source": [ + "trainer = RL4COTrainer(\n", + " max_epochs=5, # few epochs for demo\n", + " accelerator=\"gpu\", # change to cpu if you don't have a GPU (note: this will be slow!)\n", + " devices=1, # change this to your GPU number\n", + " logger=None,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | env | OMDCPDPEnv | 0 \n", + "1 | policy | PARCOPolicy | 941 K \n", + "2 | baseline | NoBaseline | 0 \n", + "3 | projection_head | MLP | 33.0 K\n", + "------------------------------------------------\n", + "974 K Trainable params\n", + "0 Non-trainable params\n", + "974 K Total params\n", + "3.899 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sanity Checking DataLoader 0: 0%| | 0/2 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWkAAAFfCAYAAACMWD3+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3QV1RaHv7k9vRNCEhJCCb33Gpp0CFIEFCkqqKg8CwoqggKioogoiA0RpPfee+8JPQQCqaT3cuvM+2NIICSBAAmg5lvL9V7uzJw59zLzmz377CJIkiRRRhlllFHGM4niaU+gjDLKKKOMoikT6TLKKKOMZ5gykS6jjDLKeIYpE+kyyiijjGeYMpEuo4wyyniGKRPpMsooo4xnmDKRLqOMMsp4hlE97QkUB1EUiYmJwc7ODkEQnvZ0yiijjDIeG0mSyMjIoEKFCigURdvL/wiRjomJwdvb+2lPo4wyyiijxImMjMTLy6vI7f8IkbazswPkL2Nvb/+UZ1NGGWWU8fikp6fj7e2dp29F8Y8Q6VwXh729fZlIl1FGGf8qHuTCLVs4LKOMMsp4hikT6TLKKKOMZ5gykS6jjDLKeIYpE+kyyiijjGeYMpEuo4wyyniGKRPpMsooo4xnmDKRLuM/w/nz56lWrRrnz59/2lMpo4xi89AifeDAAXr16kWFChUQBIF169Y98Jh9+/bRsGFDtFotVapUYcGCBY8w1TLKeDwmTpxIaGgon3322dOeShmlyL/tYfzQIp2VlUW9evWYM2dOsfa/ceMGPXr0oH379gQFBfG///2PV199le3btz/0ZMso41EJCgpi/fr1AKxbt47g4OCnPKMySot/28NYeJxGtIIgsHbtWgIDA4vc56OPPmLz5s1cuHAh77NBgwaRmprKtm3bCj3GYDBgMBjy/s5Nn0xLSyvLOCzjkegTGMiBKDOG9CRMN07Rs2dP1q5d+7SnVUYJExQURLPGDTBa7vxdr169pzupIkhPT8fBweGBulbqPumjR4/SqVOnfJ916dKFo0ePFnnM9OnTcXBwyPuvrLhSGY/DsVNnuOTUEodOb+DW9S3MZnOZNX0XRdlpj2G/PTW2/PQRqePtmRygRaVSMXny5Kc9pcem1EU6NjYWd3f3fJ+5u7uTnp5OTk5OocdMmDCBtLS0vP8iIyNLe5pl/EuJTdPzyuILmNxrAeCYIAvzv+UGflyCg4Np3rx5gXssMjKS5s2b/6MeZGdOHGGUx0WsVNC3tu2/5mH8TEZ3aLXavGJKZUWVynhULkSn0f37vWRpXQBw1N/i/PLvAP41N/DjIEkSo0aN4sSJEwQEBOQJdWRkJAEBAZw4cYJRo0b9YyzqmBXjcFVmAFBOawT+HQ/jUhfp8uXLExcXl++zuLg47O3tsbKyKu3Tl/EfZduFWAbMO0qyXgRAJxm4vvgzJEnMt9+kSZOexvSeCQRBYNWqVfj5+REWFkZAQABHjhwhICCAsLAw/Pz8WLVq1T+i0capHcvpanMp7+/ytgJa5b/jYVzqIt2iRQt2796d77OdO3fSokWL0j51Gf9BJEni533Xef3v0+SY5NUjAQn9nrlkJt4qsH9YWNiTnuIzhaenJz8tXEmzl8YhNR1Kh0Gv5wn0vn37/hHrQZIoYnfgc1SCyLlsNzKNsuXv7XBH3v7JD+OHriedmZnJtWvX8v6+ceMGQUFBODs7U7FiRSZMmEB0dDQLFy4E4PXXX+enn37iww8/ZOTIkezZs4cVK1awefPmkvsWZZQBGM0iH689z6rTUfk+f76alu++2vWUZvXsEZ+u5/D1RA6FJrH7YhSpBsCzHQDlPOoQt+QjFi1a+I8QaICoHXPwV0VjkpSMXJXMwm4iNd2UVHQQuJYs7/NPfhg/dAjevn37aN++fYHPhw0bxoIFCxg+fDg3b95k3759+Y559913uXTpEl5eXkycOJHhw4cX+5zFDVUpCkmSCn1lK+rzh+H8+fP069eP1atXU6dOnccaq4xHJznLyOt/n+bEjeR8n1e2MbFtQi/UKuVTmtnTJyE1k80nr7L/yi3OxRtJMmnybVci4mBKIiPHiMneE3NGEpr9P7B/67pnXqgN6UmYvq+HrZTBTZ9B+I74Bf7uB9d2QZ850OClpz3FIimurj20JR0QEHDfhYTCsgkDAgI4e/bsw56qRAgODmbUqFGsWrUq3wUXGRlJ//79+fXXXx8rjvLuwPmyuNunw7X4TF756yThSdnYaVXY6lTcStPjZqflr9Gt/3MCnW0wsfNMKLvOR3I2JptovRqJXGNEgwDU8XKgZWVXqtiamPDaIM6GXKJStZp4vfwtUbigbzqCdp26sn/XtmdaqDVHvkMrZZCmdMHzhRnyhw63+wWmRRV94D+If0T7rEfl3tXrXB9b7up1WFgYo0aN4tixY49kUReWxfasBs7/WzkUmsgbi0+ToTfj5WRFl+ou/HE0CoUAPwyqj5erw9OeYqljsYicj0zmREQah64lcSIsEb0515CSrWYnpZHabmra+LvTq5k/Hs72SJJE8+bNuRZySfZB79qGYOtC79kHSS5Xiax6A+k3YADHjx59NhcPYy8gHJ8HgP0L8xCsb1ujuSKd+u8I3f1Xi3Tu6nWuIPcKCGDun38ydMSIElm9/vSrT/Ea6oXqhoqoY1FMnjy5zJp+gvx9LJxJGy5iESUa+zgxukV53lh2AVDydvsqtKzsWuyx/mluqws3brHp1DWOhiUTkgp6Kf+tbK0wU91JoIWfCz0aV6amT/kCYwiCwK+//lrgTfPPkc0Y+MsR8GtMw+faPYmv89BIogVp07soJAvU6I1Q7bk7Gx1uW/5p/w6Rfqy08CfF4/qkIyMj6RYQwHyFkjSLhVejIlF5ez/W6nVQUBCdJnTCY5AHALahtpydfZbjB4+XWdOljEWUmLr5En8evgnA8w08+aRbNbrO2E6CSUMlaxM7Pn44P3RgYCDr168nMDDwmXzQJmboWXngHAevxnMh0Uy6RZ1vu0YQae1fnlZVXGlVxQV/d7tiGx+Frc1svxjL63+fRpLgk+41eK2tX4l9l5IgfN2X+AR9jaiyQvH2qTvWM8DNw7CgOzhXhnfOPL1JPoDi6tp/QqQBjuzbh+q1UdgplSSYzWi+nEbzgQMfeU6BgYEczj5M+RfvWCg6ow7PC56s+2HdI49bxv3J0Jt4Z+lZ9oYkADCuiz9vBlTmxVmbORInYC2Y2TK2Db7lnYs9ZlBQEA0aNMj399N+0KZm5rDnfDhXUiQOhSZy6VZ6vu0CEt5WJhp62tC5jjcdG1RBp1EXMdqj8fvBMKZuvowgwM8vNqRrbY8SHf9RyU6Kgh8bY00ON6u9gu+Qmfl3SAmHH+qCUgufxILimczZKxPpu8n1QT+fkcFIZzn7LF2ScJ8zB99OHR96vNyb2qGZA95veCOmiVjrrNFr9QDUlmoz+/nZuNm7PfTYZRRNZHI2r/51ipC4DHRqBTMH1qd7HQ9+3HCM744kARLf9vChf5viuSvSDGlcTLjI5/M+J1mdTNSVKBJXJ9Kzx5MvvmQ0mdkddI2d5yI5HZVJZI4K8Z40Bm87BdUcJNrX9KB742o429uU6pwkSeKz9RdZdCwcnVrBslEtqO/tWKrnLA7hPwXik7iXZKU7Dh+dQ6nR5d/BYoKp5UAS4YNQsC33dCb6AEotuuOfxt2LhAf8/BiuUKAQRewFgaQxY+D7mfh27/5QY+ammZozzAAY041c//Q6Dd5uQGa1TC4IF+i5uifj6o+jf4P+Jf2V/pOcDk9h1MJTJGUZKWen5fdhjanr5cipq5HMPhIPKOldWV2kQKfqU7mUfIlLSZe4mHiRc3HniDfEyxuryv/j4uVC/Lr4J7IILEkS1+IzWX34IvuvxHItXYGJXPeMvNhnpzDRsbYn7WtWoGVlV9zstKU2n8IQBIFJvWoSlZLN3pAEXv3rJGvfbIW3s/UTncfdxJ/ZTMXEvQCYunxdUKABlGqw84D0aNkv/YyKdHH5V4u0JEn079//ziLhvn1EjxuHQ5CcImotCKS+9z6Z9vbYtm5d7HFzA+MtmXJGm9JWiSHDwLEvj1GpTSXcXnIjW5vN5+c+51TmKT5q8hFOOqeS/4L/EdYHRTNu1TmMZpGaHvb8MbwxHg5WZBtMvLHoFCY0+Fob+W5EVwBS9ClcSrqU77+YrJgix9eYNGhuagjbEIaoF/PqPZS0NX01KoGNJ65yU6/l+I1U4jNyy/HKbgqtYMbfAZpVcqJH48rUreSB4im/qquUCn4c0pAB845y+VY6IxecZNUbLXGwKlnXSnEQzUaELR8gABHOranYtG/ROzt4ySKdGgmejZ7YHEuDf72749446cgDB8gcNRqAaJUST7MFQa2mwszvsO/c+aHGjs2KpfOqzqgUKs68dCZv8SUjJ4OZx2ayJnINoiTirHPmjWpvMKjBoIca/7+OJEl8vyuU2btDAehc051ZL9THRivbFh+vPc/SU5ewso7g5XYqbhlvcin5ErFZsQ8c29piTQ1lDQ78foCbR24iiQVvg8f1TcelZLDpRAgHQuI4H28k2Zw/iUSrUlDf05ZK1ka61velTe1KKJXPpv/0VloOgXMOE5duoFUVFxaMaIr6Cc/15vIJ+F6eix4dljdPYFPOp+idV42EC6vhuWnQ8q0nN8mHoMwnfRf3rl4f79IV+/BwMtq2oYLOiowdO0CppML0L3Ho3bvY4+aYc2i6uCkARwcfxVZjm2/7hcQLTDw8kWupchp9dUV1vu32LT6u97m4ygBAb7LwwcpgNp2T622MbufHK21duZJymYtJF9kTdoZLSZdQqNMfMNIdPGw88Mef3tV706FmB/o93y8vzr0w+vTpU6z2cHfP+Ux4CtuCbrLrfCS3DHcnkciLfR5aE2393endrBoNKzqhU/9zEm0uxqQxYN5Rso0WBjb24ut+dZ9c/HRGLKbv66MWcwiv8z98+n1+//13ToLDs6DZG9DtqycyxYelzCd9F/deSI7DhyF+/gW6o8dw2r0LhbU1aevWEfPReMTsHJwGvVCsca1UVuiUOvQWPamG1AIiXdu1Nst7Lmfy1slsStzEFfEKz298npG+I3mj3RtP/VX2WSU+Q8+IRbu5knwJnVsMNX3T2ZlxgyWrEvLtp1ADCLjqXEjSJyFR0N5wxJHnaz/Pcz7PUdOlZr5r4UH1HB603WS2cPDCDbYHhXM1TeBSggGDObfKnmw1O6uM1CmnoZ1/eXo2rUY5J7sHfv9nlVoVHPhpSANe/esUK05F4eNiw5j2VZ7MyXd8ilrMweBSC+8+nz54/7ysw39+rPR/wpK+F9Fi4UzrNtikpJD9wkAaTppE3NRppCxZAkC5ceNweWVkscbqvKozsVmxLO2xlNqutYvc7/DVw0w8PJEEhSw0lYXKzHhuBlXLV33s7/NPRpIk4rLj8nzHJ2LOERR3EUlZ0EJWCAp87HyJiLYjW++Kq0MWVTyNBMcHIQp3SpA6WBxo6tiUvrX60qpqqxJ7GIqiSHBYDFtOh3HsRgpX08BwTxJJOTstrau44mNloFtDP6p5/bsifCRJYtGxcD5bfxGAHwc3oFe9CiVSB6dIwvbDwt6AAKP2QoUGDzyEkG2w9AXwqAejD5TOvB6TMkv6PiiUStT9+8FvvyNs3oL0ySe4T/wUhY0NSb/9RvyMGYhZWbi+/dYDLzxHrSOxWbGkGlLvu1+raq3YUmkLU7ZOYVPyJq5znYFbBzLMZxhj2499Yq+NpVlsqjjnjs2KlSMski5yKfkSl5Muk6zPXxQJJSAJ+Nj7Ua9cLWq61KSmS03sBDveWPIHBlUIGte9ZAgiZxMAAWxybGho25ChzYfSzK9ZiQlzQoaBI9cTORSayLagG2TkJZHIt44aC1XsRVr6OTOofQOqlLN9NlOoS4C713dGtqrE/MM3eH9lMApDOl+8Peyx6+AUhsWYg37l69gANHm1eAIN/6r6Hf9JkQao8frrXF22HKuMDDJ27MShZw/Kvf8eChsbEmbNInHuXMSsLMqN/+i+N52j1hGQIwoehE6tY1rvafS90ZcJ+ycQq4jlj8g/uLDjApNaTsLbrnQL2ZR2sam7kSSJmKyYfBEWl5Muk2Io+DspBSVOam9uxbtg0XtR06UGvw7shbu9PRGJESw/s5wlJ5YQIUWCo5R30VZzqkZnn85s/G4jWxZtwSPQgxYvPV6d8qT0LLacvMrey7e4nGThVs7dYq9GgYi3lZnG3rZ0quNNx/pV0Kj//bfRvXVwdu/ZS2SKOzsvxTFmaTDRVyMfqw5OUUQs/5BKOTFkCzZYdfiEYo/sePv6zk4CYzZonl7Y4OPyn3R35JIwdy6Js39EV7Mmvqvv1PBIXriIuC+/BMBxQH/KT56MoCx8gWfc/nFsu7mNj5p8xEs1i18W0WQ2MfvgbJZFL0Nv0WOlsuJV/1d5peErKBUlv5iUW0znxIkT+Qq63x1H3rRp00e6ySRJIiozKp8YX0q+RJohrcC+KkFFFacqsnXsXJOqTv4sO2RmxUm5e8/gphV5u7Mba86tYvO1zURJUdx9Z1pyPPG0+DOr7yhqVajFmTNnaNKsOQCi2fTQERl6o4ldZ+UkkjMxWUTl5F/sA6jpYU/rqq7Uc9fSyt8DR9v/ZkehyMhIOndohyI1nG6NKzH0pRcZsN8Vk7MfZMSx+X/tqVW1UomdLz38PFZ/BqDGTETjT6nYc9zDDTDdGwzpMOYkuFUrsXmVFGXRHcXAnJLCtfYdkPR6vP6cj91d3WJSV6/m1sTPQBSx79GDCl9NR1AXjA2ddmway0KWMaruKN5u8PZDzyEyPZJJRydxMvYkABWkCkwPmE5D34aP/sWKOtddguzn58eiRYsYOnRovk4cnp6eGM0WzKKERRQwiSJZ2XrSs7IxGM3kGE1EZ0VzI/MqEdnXicoJI84UTo4ls8D5BJTY44Gd5IWN6Im12ZMKjrXR6ewxWUQiE9I4ECYLuaBKRWV3ATvHc5h0EfkH0ntiSKuLKaM2kskFNRYkQETIy8oTzEbiV03iuQaV7xvfLIoiV2IzOHI9icPXEjkSGo9BzC/KDkoTtVxVtK1WjsBWtSjvWLqZfaXJoxaOMuuzSAs7TVb4GSyxl1ClXKMcyWgyIhEkc95+fdYoCG43G2ycaVrJmUWvNEVbQqVho75ti1dmMLG6Krh/eBLhYV1Yc1tA/CV4aQ1UefjM4tKmzCddDFROTmi7dkW/bh0Xp39F8w13wrEc+/VDYW1N9LgPSd+8GTEnB8/vZ6LQ5s/6ctQ5AhRqNRYHb3tvfn/ud34+8jO/X/2dGEUMI/aNoLdLbyZ2m4hGpXnwIMU91+2iUgEBAaRU6sjIdTGo+n9LVUEWu3ZzghA5d9cRIoImCaUuGqUuGoUuGqUuBkGpLzC2JCoRDR5Y9BUQ9Z5Y9J6IhvKkS/deYsm3/wNBnYza+QJq+/MoreRVeNPtvSzZFTFl1MGcXhvJnD8R6E5m3l3nV2lQlfdn3bpVBbIFL4XHsvnUdY5cT+JKikROvjkJ6AQz1R2hhZ8L3RtXpk6lZ6NGRUnwoHrnkikHIekaxF8hJzKIpCuHscmOxMGShAsSLvcZ+0Kymj0hSfz+jS9Tj2Zz4kYy41efZ+bAeo/t8oja/RtemcFYUKDp++PDCzTI1fDiL/3j/dL/aZEGsB70Ajnr1uFw9Sqxp09TvtGd7CT7bt0QrKyIfmcsmXv2EPn663jPmYPC+o5/62F80kWhEBSMaTWGTn6dGLdjHDeEG6xLXseRRUeY2mYqLaqUXD9Ib29vJv7wJ5MPZZBfakUUmkRUBQTZUGAMSVQhGN1R6CugMFbASV0VR20l1Ao1FpWBDEsqKq2A2gqUCgtqpYBKIaBWCugcDASlHydNdQ6l1V03jwT2Ji9q2reiqq4Rzu5ulHN15lhkFkuOy5b1wBrW9G7ki06tQqtR8cmE8RzcvxdNsyFYVW8DyN2hP5v6NT1Gvsv+kDguJphJzVvsk8Vdq4Tmld1oXcWV5pWcqFnB4ZlNInkc7q53vmf7Zk5vmo8bSVhiL6JODcM2OwoHMQWQI2OsgLtqyaFHS5rGA72dD7hUoULiQdTJVwFYet7EyA3p6M3w8ZjhfLNwIx9uvsnas9H4uFjzv06P7l4wZadhf2gqAJFevfH1b/loA/1LwvD+0+6OXI71CcQhJIS0Zk1p/tdfBbZnHTtO5JtvImVnY9WgAd6/zEN5ex6bwzYz/uB4mpZvyh9d/njsuYiiyJx9c1gQvgCjwohCUtDFsQtTe04tEas6MjKSNhOXoqjoCun7UZiDsfJSoK2gxCAVtJC1Si3+Tv7UcKlBLRc50sLP0Q+1ovhpwTfSbrAzfCc7b+7kSsqVOxskgQqSNx0qtGVgg4FUKpffnxmRlE2P2QfJMJgZ3c6PCd1q5G27u3KdW+8Psa7RFgBD7DW07n4g3BFdAQlPnYmGFazpWNuLzg2rYq0ruTeUZ5XAwEBaGfYyorEtLsrMohfddA7gVgPJrToROVZoPOti59cYm/JVZAs2JwVWjoAwuWbGJ3v0LIv2ZNGiv/O5y96bs5oZ+6IBmDmwHs839CrqjPcl/M9X8QlfSbrggO79YDS2j1hS4eBM2P051BsMfec92hilSJlP+iG4sWUL+vfex6JQUHH7NuwLqTGdExRExKjRiOnpaGvWoOLvv6NyduZI9BFG7xpNNadqrO69uuTmFH+DD7Z/wFVRtlyqOlVlSqsp1HKp9VDjmEUzN9JuyDHI4SdYe2IrivICgsJYYF+tQkt1l+p5IW81XWri5+CHSvFwL1ySJHHyxklWn1/N8ZTjJAlJd21TYMmqjI+qAT8FvkwV98KzL7P0Rnr/sI/rKSYa+TixbFTzvDRkk9nC86/+jwiDFUL5GqRqCxbQsZeyaORlQ0B1D3o29cfF4Z/rV34UgoKCaNywAebP7twvWZKOVHV5zE6Vkdyqo/Wqh0PlpliX84Wi3BOJ1+R446Rr5JgFhqzO4pyxYpELz30nL2De/jDUSoFFrzSjud/9HCaFkHAV6eeWCKKJqNbf4NVp9KP/COdWwppXwbcNDN/06OOUEmUi/RCIosipDh2xi40ls0cPmnz3baH76S9fJuKVV7EkJ6OpXJmK8+cTqkrkhU0vUM6qHLsH7i7xec0/PJ+/ov8i1ZCKUlAypNoQxjQYg422oOiYRTPXU6/LERbJl7mUdImQ5BD0loIWsgIN9crVwlvjzcqfVhJxIoK63nU5fvT4I/kTRVHk2PVjrLmwhuOpx0lVpOZtUwpKbKWaxMZUw5xZk/+1r8/YjlXve54RP25mbzRYKyV2jetIpt7Isr1BHL+ZSmiagLEQvzRA4sZv0Ueco2YlT86dO1foPv8FAgMD2bx5M9njrVArBZr+aeZsjJGePR+iDOv1PbByOOjTwMGbkIaTefnDGfcN4axTpy5vLT3DlvOxOFipWfNmSyq72RZ5inxIEvzVC24ehKpdYMjyoh8exSHiGMzvAk6+MDb40ccpJcpE+iG5+OtvKGbOxKDTUePgAbR2hafvGsLCiBgxEnNcHGpvb3Q/TafbseFoFBpOvXSqVBIZkvXJfHXiK7be2AqAo8WRCY0n4Oflly/sLSQlBIOloA/ZWmVNdefqqLNd2BfiDAZPdr7dn0qu8nd81DhpSZK4nHyZlcEr2XlzJ2nKO4unCkmBn8KPJm7t2Bfiz9VYEY1KwYz+delT3/O+4/6+7RRT98khefZaBdZaDbHp+R80GixUdZBoXsmRUwkQHJ3JuC7+jGlf5R/XCqukudsVlPShHc5WAtV/yiQkSczbft9/Z0mCE7/CtgkgWcC7ObzwN9i6FSsZSm+yMPi3Y5yNSKWiszVr32yJi+2Dy6xmH/8L663vgEoHbx4D58cM50uLgu9ryfUDPo1/5or/l0V3PCTVhw8j+LffsMrI4MrPP1Pvww8L3U/r54fP4r+JGDESU2Qk4mvvUSFQIsbFSI45B2t1yQfN26ntGF5rOGnZaRyJO0KqMpWPzn4EhTRgt1HbUMO5Rj6XhY+9DwpBwbD5JzCnJzCwsVeeQIO8mFjc+GhRFNl3ZR+HEw9zOOEw0ZmyDxKlLMxVlVXp6N2RAQ0HEJ2m4tWFp0jIMOBqq+HXlxvTsGLh/sWE1Ew2n7zKyjPRXEy5czOlG0TSDXo0SgVVnRTUdFHyXN2KBNSrnNce66NV5wiOvhMC+F/v4J5b7xwg0yjhbCVge5cLftKkSUUXjjIbYcsHcOb22kz9F6Hn96CSRbaoa+Tuz3VqJb+93Ji+cw8TkZzNqEWnWfxqs/sWk9KnxiNtmwCAodnbaB9XoAFsy4OgBNEEmXFg/8+M2ikT6dsoNRo0/Z6HBX9hs3sP0gcfFBn2o/Hywufvv4l4ZSTGa9f5/G+YOkhJqiH1sUXaaDESmhLKxaSLeS6L0JRQTKKpyGOq2FZhVMNR1HSpibedNwqh4LzPRqSw/2oCSoXAW+0L1gu5n0BbRAu7Lu1iw+UNnM44TZYyK2+bTqmjjVcbaqlr0bdeX5xt5bZVm87F8P6KkxjMItXL2/H7sMZ4Od35bQxmC2cjUll18DxHb6QQo89NIrkz93IaE70a+9G+RgUa+xavYlxZB/f8haEyDPKLsp22GIWlspJgxVAIPywvvHb+Alq89UguB1dbLX8Ob8Lzc49wOjyFD1YGM3tQAxSKwseKXfo2vlIWqQoXbNu8+9DnKxSlCuw9IS1CtqrLRPrZ50GvajXeeptrq9dgCg8nc98+7Dp0KHIstXs5fBYtIvKVV+HSJSYtsZDS7DgV2t2nEPk9GCwGriZfzRPjS0mXCE0NxSyaC+xrp7HLZx1fjbzKktAlZCmzuJZ5jVXHV/FNz28KFWiAH27XZH6+gScVXR78IDFbzGy/sJ2NIRs5m3WWbEW2vEEJKlFFTW1NhrcaTqsKrfI9mCRJ4qc91/hup7zg2aF6OWYPboCVSsG+4OvsCA4nwmjNqfAU9Kb8FePu5q8hNWhXt/jNTwVEdLFnuLJ+Drte9+avI7EsvST9Jzu45/PF/9YRok+xd+sGqH6fDkRxl2DpIEgNB6099PsD7u7A/QhUKWfHvKGNePmPE2w6dwsfF2vGdaleYL+Ec7uoGLcdgJwOU3HUleAir4PXbZGOAO8mJTfuE+Q/I9LFrVvhNOgFkn77naT5f+YT6cIEXuXkhPeCP9k1MACfmzlIYz8na54HNs2bFzi/3qwnJCVETpm+LcjXU69jlgoKsoPWgZrOdwS5hksNvGy98p2/q29XXmzwIuM3j+eY/hgnDCd4YesLTGoxiTZebfKNFxSZyr6Q21Z0h6JLS5osJs7Gn2VH+A52he8iSX87KkNxW5g1NelaqSuBDQKxsyros9ebLIxffY51QXIXlICqzlS21vPirM2EpII+L4kkBwBXWw2NvGypYiei0lrxwyG5dvTkjh4PFGjRbCLp8gGyLmyj/7WTfKwNwSEkGxzl7daN1Sw6l/2ftabz0NwWPGNW0fuEbIXVr4IxE5wqweBlUK6gmD4KLSu78lW/unywMpg5e6/j42zDwCZ37j9JtCBtfBcFEpEOTfFuPaREzpvHv6DQ0n9CpO8tDlNY+FBucRinl14icf6f5Jw6RcTu3VTs2PGBAl/1f5Xp9ddF6t40EDlqNG7fz2CfdQaf/PgJHQd35JZ0i7DUMCySpcDcnLRO+cS4pktNKthUKJZ/2MXWhd9e+I2NQRv58eqP3Mq+xZu736SXXy/eqfMO5R3lTuY/7JKt2r4NPPFxyW+l6E16NgdvZvO1zZzPOY9ecWeBzlphjb/Sn66VuxJYPxBrbdEWeGKmgQHzjnIj8Y4Y7AtNZh+Qe5mpsFDZTqRTbS96NauGv7sdgiAQlZJN9x8OAtDNT8vwzgVT4iWLGSHuAtw8BDcPYbq2DzcxBzfAF/LV94jXqxizVX4QlFYrrH8M2tsPU2NGwW2SBId/gF2TAUkOVRu4EKyL32m9OPRv5EVEUhaz91zj47XnqeBoReuqrgBErJuKjykCAxqcBs194FgPvSicW2jpHyzS/5nojuLUrcgV4GODh+Bw9ixpdWrTbMWK+xYmuhl9k1rf1UKlE/nfOpEmoRJmBfzYW8HRGvldD8465zsui9uWcnmb8iUSEZJjzuGnsz+x6NIiJCR0oo63qr1F/Yp96DPnMEqFwO732uHraoPeqGd90Hq2XN/CBf0FjHfFTNsqbXnO7zk6+3SmWflmqJVFJ62kZuaw5eRVFp+M5mJywctIQMLbykRDT5u8inFW2vzjGc0iA385SlBkKvW8HVk5ugUalUK2lC/tJ+viNlRRx3HNCkFH/sgVAxoSbaqRYRSpbroEQHCshR5LsonOyD+fx22F9Y9lzSg4txw6T4FW79z53KSHjWPh3DL578avQLev5SaupYAkSfxveRDrg2Kw06pY/WZLPBUpKOY0wQo9N6u/ju+grx84TmBgIOvXrycwMLB4D95T82HTu1CtGwxZVgLfpOQoC8ErhMjISAK6BpDln4UmRUPkgUj8fPMLNEDUoUNkvPoaoiDgvno1OXa2eQJfuVllhn46lGV7l2F2MaOtoM0TWaVFYswmkdaXJCyCxKzaRjaas5j+7nS6N+qOu7V7qdcaDooL4p0t75CikNPUrXJqkxAZSJ+6fgS2zGL1+dUcjjuMSXFnIVIn6qhrVZceVXvQvW53dOpCOjADBpOZ3Wevset8JKejMonMUeUVOMpFo1QwtHlFKtua6dq4Ks529/d/j/ltF5uvG3DUKVjZQ4k6dDvq6OO4ZF0tIMoWtQ1K39bg2xqjZzNUXg1QnPkLccuHKBDZnehC399ukFEwT+ehW2H9a9j0Hpz6A9qNh/Zy9AQZcbBsCESfkqMfun0NTV8r9akYzBZe+v04J2+m4OloxSavhThdW0uiygPn8edQPCCjNigoiPFDAqigzeavYBNnzhbjwRu6Exb3B/c68MahEvw2j09ZCF4heHt7M+rbUfwd/zcATi840aF8B4x2+e9qr9atOV7JF/sbN7n+wyya/fIL+/bto32f9uhG6ViVtApVXRWqe34+i1Kg6syfOPbieJonZfDueS3heomN329k5NridXp5XOq712frkK1M3DyRnRk7ybG6gG21C+zWw+49t3dSgJVoRX3r+vTy70XX2l1RqwpaUJIkERqfyeFriRwMTeDgldi7ihsVvKF2vtuWqu7Faw8lmo2sWr6QCjdP87v6Mu1Uoag356+kp0dLkk01TJ5NsanVFZdaAXD7RtaIIuycCEd/QgEsNbfnrbNqMow3Cj3fg1ph/WvR3k4kMd7+bWOCZIFOjwadIwz8C/wCCj20pBtEaFVKfh3amOd/PoJL0mmc9LIlrOs394ECbcpOJ3nJaLYNlAArzsZRPDfWv6B+x39KpCMjI/n13V9xe8mNLO8sRCuRXWm72LV+F3Vd69KnSh+6VeqGncYOp+HDsUyajNXhI2TFJ+Dt7c3vs3/n3cPvYi4vL/YJksALni/gXcGbGadm0NW3K46pzow8cpJljZtQNyODyS7OPLd58xNbvErLTmP1mdXEZMcUur29Z3t6evSkvX/7QoU5JDKeTSdDOXI9iatpAhnmuy1lJVrBTBV7uJymIjc2Y2BjL6YG1kGjKjpZQDQbSbywl+xLuZZyKAMxQO4UzCBqbLmlroTJs1meKHsWMkdMOfJr/OUNAGwv/xoTbgYw+Qt/3u64shi/0n+I3L6bhgy4uBbWvgHmHHCtJi8QulQu9LDSahDhZKNh/tD6mH+WO3gftOtOK//29z0m8cI+WPMqHazl1nMWCcKSTQQVZ1E4V6T1qfJvoC2eEfEs8Z9xd9zrk37zmzdZELUgLxogF61SSyefTvTx641q4IfYJiWRPaA/5UaNIiAggBs3b1CrXy10nXXoNfmz4Jp5NCNxbiKbN2/GVatlU+UqWBsM7La3Y7enZ6ktXmWZslhybAk7bu4g1ByKRXFngVI02aFQ31k0slHZ8FHTjwisEoggCMQmp7PpxFUOhMRxIcFIsjm/RaNVKWhayZmWlV1p6GlNVQ8nxi4P5mBoIoIA47tWZ1Rbv4KWlcUMscFkX95JytmNuGZdRUv+N5Z0yZogqSotOvdDXbkdlK8DD2p4kJUISwdD1AlQaqDPXCZc82fpiUje71yNtzv+t3tGFuDoXNg+If9nVTpB//lyYaVCKM0GEQARyz+i4uV5pEi2tDd8x4A2dfmkR80C+4lmExHLx+Ed+hfKPJMATkRbaPZ7FiqVqnhp7l/5yCL95jEoV+P++z5BytwddyFJEv379y+wSNj7Zm96TeuFqrkKQSVfbAaLgc1hm9kctpmerax5eQOwZTPPLVuWd/wv//uF4a8Ox6G9A+ZGZsxK2bI+fus4V49fxWw2E2s284NBzwQE2mdksuHMmRK1ppOzkjkce5id4Ts5HH0Yo3hbABVga7ElK74qmfqW9K7ejFmDGnD8+nG+PP0lYTlhfHbkM34+tQpl0gCuRKnu6kSiQUDCQ2uiQQUrOtTyolvjankV4yKSshn463GuxWdipVYya1B9utSSI0hEs5HE87vJvrQd5/TL2KdcBGMG1kCuV1qPjkRbf/YZ/VmaUY/rkhcrRzdDXdz6zYnXZP9iyg1ZYAYtAd/WcO2/W6PjgdwbN9/iLTlJ5T4PQ0EQWLVqVZ4gBwQEFFhoX7Vq1SMJdEZ0CO6X5wNwxvc1UkPs+O3gDSq62DC0+Z1iW2kRF8hZPAxfwzUATmaUIy42lp5VFey7Kd9vZrO5eCGWDt6ySKdFPVMiXVz+EyItCAK//vprgde3qr5V2fnZTvqN7od9P3viVHH5jtvmn0UvG3DKyqFFExFLrapsnrWZqr5V2b19NwEBASSsTsB/vD96J9mqrjqtKubTZqJXRbMoJISuTZvRIC2NyS6uTP3sM1auX19gfsUlNjWWFWdWsDdqL2FiWL4O2eW15amjqUPfWn354rM/uVWpH0giYwIqs/vsNXYEZ5IR+TJG7XHUbju5ZTyHZH0FlVM3bDMaULecjnb+5enZtBrlnAq+Ep64kczoRadIyTZR3l7Hby/VxT3pFDcXb0cdfQLX7FDK3WMpo3MAn1ZEa/zQVOuAS4227Nt/gU93yq6YTwPci19gP+KYnGyRkwKOFeHFVeDmf3vjv7Px62OTFgXbPrrzd5850KB4Ld5yG0R06tiZAL8XGTFgDGExBSOhHpbU5W/ijZE4jS8dhk3k/b1hfLfzKpPWX8DLyYr21dzg3ApsN76LgzkLI2oWJ9Vh5E/7uPa27LrZezN/KOt909xBDsOLO/+P9Uv/J0QaoF69eoW+nnl7e3N883FESWTmrpksjV6aF/lgpbHnbFsdHbbeon+0hpMjlLx85GW6xHQhsEoge/fuZcCAAUxrOY13L8uprIJSQN1UTZVGVVCdUvHB0ktsqOiHU3Y23VNSH3reMSkxLD+9nL0xe7kp3kQSbnunBPDUedLLvxedfTpT1VGuKhcUFMRFfNAAgiTSc9ZeDHn/zDrIaoeVsTaa8ivJUd9EV3497u6neK/919TzKdwaWXU6iolrzuAv3mCscxiDy0UgzD+E5h5RzrWULd4t8Wk7BNxrgUJJbjmlW2k5TN8bDQgEVIBXuzYu3o9wYQ2sfR0sBqjQUK6OZluwPOkz77d7kkSelBcI76aYAp2Lp6cn/xvwFWKSPX7la/PZ4iEsWrTokQU65sBCvNNPISKg7P0DgkLJWx2qEJ6czarTUXy8+ADbqqzDIWwjSiDNrhpS31/5PnAY3vYClZ0VmEWJQxH5E8AeuCic65dOLRPpZ577FYdRCkrGPTeOgYkDGb99PBfMF8gQM1hTxUw7jYpKcWbax7uy1z2J1aGrWR26mkoOlRj1+yiq+lSFy/JY0xpNY9bJWSQoEzA3M+PTuBbn4xvRfMFumsXHk3HiBHZNm953nok5ieyJ2MP6y+s5n3o+nzA7i860cG5Bvzr9aOJXMM3146kz0FSRb05JocIAqLFQxV6kma8j3Rr60aSaFxIvMmPHDJbfWk60Ipphe4fR160vH3f5GLVKjcWoJ+H8Lk7s34JrygVOqkKwFfSQDdyUz5WDjiTb6pi9mmFbuxvO1VvjVdhCH2C2iLy95CxZZoHKTmrmjAp4wL8WdyVbTJL/9u8B/X67k0VXRuEEL4MN78gPtVxcis40LYoVP+9CTLJHQmLbxfkYzXqGDh36SJa0WZ+J9b7JAESU74Zv7QBAvve+7FsH64i9vJH+Aw5hyUiCEiFgPA6t3wOlSk5zD1oK615H5d2EDMNDlgT+h2cd/qdEujj4uPqw9MWlrDi5glnnZxFvm8HO2ha6noFBh2wY+usM1l1bx87wndxIu8GsM7OYfXZ23vH1K9ZnZ82d/Lz/ZxbdWESmMpOZHvt5t44VLc7nEDdxIjZr1+ZrwQVykf/lZ5cTlBXE5czLiNJtV4YAbqIbLVxa0K9uv/s2qA0KCmLbxnW4969LOXd3iL1C8uUjrPp9Fo0bFTxufNfx9Inpw7id4wgXwlmVuIpTf25kfJpAk8wblMdEb8jtOoWodURRSY5T1ns0QetVHy9l8S6h73Ze5VR4CnZaFfNfbYXNgzqjWMywdZycjADQ7HXo8uWDFxb/y4gW2P0FHJ4l/129J7QYA392u39aeCGc3n+FxHMKBAGupO5n2g8TGDr0Up6P+mGFOmrZOHzFJDIFWzyG/Jj3uVmfScyCUXyRsRkECBPL86PjOKY2H47N3dfWTTkjlUpteGjKRPrfycAmA+lauys/nvyRrc1W8NwZI05Xw9ixZTmTX57OhKYT2BG+g7WhawlKCMo7rsfaHrxU4yUC6wXycvOX+WrnV2xN2sovnYxUvQmu4RGcGv8eTWfP4+qtq6wIWsGhuENEE53PtVrbpTadfTvTwqUFNTyKt9gxefJklKKR2CXjib39mUqlYtrUKQVWwC1GPYnndlIt8wobBBVrEtP5zsmWmxoDb7tKjFZZ8XyKljNidVSeDajfthfO1VvniWTh6S6Fs2RvMD/vk2+Qr/rVLZCaXgBDJqwaAaE7AAG6TofmbxS5eynnB/0zMGTA6tfgqlxznDYfQPtP5EVWkH/TYpISl8X+RdfRqqy4nnyGcTNewcfHJ6+JcVhYGP379y92dIch9gpeN5cDkNx0HBXt5ZTwxAv7ENaOwtcirwWFOHdkROpwYuKVpC89y68vN0aZWzUvV6R9Wxf7e+ThUFH+33+oT/o/E4L3OFxNucrZ4YOpG5LNnroCa7p5MKnlJNr6y331bqTdoPe63gWOq+Fcg8AqgdR1qMvMAzMxXjrOJytkC3nSi0ouV8x/gXtIHrQu15qRbUbiZfdw/eHuLvReGGdPHcdDiiX78k60MSdwzbmOhvzlT2N0jkxwdOaM1e04cGMFPm0yiYH1H7ERKBAanUCvn46gl1R0rKjmjzcfUFkt/RYsGQix5+Ti7/1+hxq97nvIx2vPs+R4BO92qsbYTv/BELzkG3JYYsJl+TfrMwfq9Je3ZcTBd9UAASalPPCJlpGaxYbvz5Mal018ZjgjpnTAt9KdqIuHjpOWJDki59oukhzr4vzOfiRJJHzZh3iHLkCFhSzBhtS2U/FsP5IzESkM/vUYBrPI8Ja+TO5dC1LC4Ye6oFDBR+F3EnSKS/otmFldzq78NF4uYfoMUBaCV4JUc6qG6vWpGN59jzYXJZa2i2PM0TG0PdeWad2nUcmhEk3KN+Fk7El6+fVCb9GzN3Ivl5Mvc/nE5TsDVVawu55Ex2CJNzdb+OAVJQaNQD/XfrzU+CWquD+83zCXuwu9A6gV0LiCkt51nehRywH/Dd3QCPkXXLKxwlShKQ71eoBva87FO3FiRTAmqzNYe2xA0sQwNeh1jt/ozJTuU+5bYKkwjCYzr/x+CL2kwV1jZPaITvc/IO4SLB4A6VFg7SovEHoVc3Hxv8rNQ7B8KOQky0XuBy8Bzzsd7+8ImgSm7Pv6881mC0u+3o85RYe1o4YPvxqMjWP+d6aHaRABwOWNcG0XKDW4vPQnpEeTumAQlVIvABBlWw+nYX/j6SZbuw0rOvH9C/V5c/EZFhy5iY+LNSOsj8hjVWj48AINYOsud2cRTZAZe8f98Q/h2eon84wiSRJ+3bqRXqECagsMPukIAhzIPkDX5V1ZfGwxjlpHAGq71mZmwExmNZ+FvbLg03FhRwWJ9uCeCi/tla3qHXE72H91P6IoFti/uETeDKNvIw9+fakaB0e5kDrejiOv2DC+iZE61gloBDPZWBNp15CbNceQ9MJmrD6LxmHUBqSmo/j5so7XF58lxyTSwr0TG/qup6lDUyRBYkf6Drou6cqui7seak7vzd9NRI4GNRbmvdwEG6v7tFAK2yf3o0uPApeq8OquMoF+EKcXwMI+skBXaACj9uYXaAC1NXl+tAe4PFb8sBdzig5JsNBsYIUCAp1LcQXamJmMZfM4+Y9WYyHmLPzcCqfUCxjREF7vAzzf24fNbYHOpXsdD8Z3k0ulfrHpEjFBO+QNj+KPBrltlsPtGKN/oF+6zJJ+AHenx9q9OARmfEvrs5monx/F73GLyNJk8VXIV3n7f3XiK3459gvJiuRCx8vRCvzeRcf4lXq6nJE4W1XNGb8MZoXNYvn15XzQ+AOeq/3gYusWYw6JQdvJvrIT7a2THAuMRo0ZyF0gEsDaBcm3NRFCRWxqd8XFvwXe9yy8GUwWPll3gVWn5Yt3WAsfJvasiUqp4I/AP/jz0J/MDZ1LiiKFd0++S9tLbZneczr2Vvd3Oy3ff45NN0yAwLut3WlQ5T7WS9AS2PA2iGao2BIGLX6ocpn/OZe0xQw7PoHj8+S/a/eTXRxqq4L7CoKcGm7MuF2/w73QIXesOEFKqGyz1XzOiZoNi99woSiil4ylUlYsJqUNGVcO4Rw/Q97g1QRV4Dx8XIt+cxzd1o/wpCyWnoiQ/dECcinVR8XBG1JuymF4FQvWe3+WKbOk78O9dait27cn294ejcFA/NfLCX43GPvE/GIlIZGsSEaQBPwEP0Z6jqTytspcefUKV8dcxTrHmjNVzByoKd9Q72xW0lPTEaWo5JZwi/dPv8+QpUOIzMi/yCGZ9BB+FPbPQFzQC/FLL9y3DKNS2N9UyAlBjZksrIm0b0x0vXflFNhx1xEGLiS12gB6DH+fqOj89TzOX71B7bd/YdXpKBQCfN67Fp/3qY1KeeeyGNF6BBsCN1BPXS/v7aHb0m5sDNpY5O92PSaRydtuAAKty0u82bNZUT8w7J0O696QBbp2Pxi69pHrGUv/hUjpnBTZx5sr0B0+lbuoFCbQudxbZOkezh0L5eqedABcakCHvo//BpN0+RAVYzYBoLZk4Rx/FElQQsDHMGIbivsINMjW+hd9avN8JTMVhCRMqIixr/voE/oHF1oqE+n7kJse6+fnR1hYGB07dya5VSsAWutTqDmtOumu6YUeO7X+VNa/vJ72ru1Zv2w9ZrMZY5aR6F+jUUgKfu9qJMVWg3VmJn22p7GmxxoaaRqBBOeN5+mzrg+fbxzN+b9e49ZXTbB86QV/doW9U1HcPJBPlG/WepvkwVux/iwa7/d249l3spz+KggFHjSRkfJFeuhcKL1m78fk6INg1jN/WBOGtfQt9Lt4OHnw95C/+aTGJ9hYbEhXpvNx8MdMPTaVLFP+0C6zReT9VRfIkVSUUxv5ZXTnwn9cs1EW5/2330JavwfP/w5FlEn9L3P+/HmqVatGyJHN8HsnCNsLahu5g3fbcQ8Ob8n1Qxfi7rgVkciBRWEIKNC4Ghj4VsBjz1cSRcS1b+Srt5GicCGh92II+KjYC3dqpYJp9eWSu2fFyoxcfJEMfdG9Pu+Lwz+3+H+ZSD+A3PRYPz8/MmplMMlvH5k6cM8SaRBnRqPQ0MG7A7Xtauc77pOgT3hr1Vt8NPGjfJ9Hn41GdVSFXivwY0/5InY4dgzb05f5pkog35pr09CgwCSaWJV8hDcsh9mtuYUkmZBs3KBWX+jxHdkj9+eJsu+AqTj7tyy0ce69D5qAgAB+Wb+flxYEga0bZCby19C6BFQvmMF3L4OaDmJT/00008mW8fKQ5fRd35dDUXfq9M7eHUpQTBbWGiW/DGtauB86JxUW94PgpfKKe89Z0GmS7DssowATJ07E1xKG55aXIemaLDivbH9g1EseuZXw7omVNhstrPvhFIJFDToDQz4KQKF8/H+DqD9H4GaMyPs73K0DNu+dplyDbg89llWUvGh4XlWHK7EZjFlyFpPlEdZu/sGWdJlPuhh4e3uzaNEiXvjrBTLsTeyqryTwmIVRweWpPXk9NmobmgxsAj1BypSobludECGE/Vn70fXW4S/6E7IlJG+8s7+fpYV/My5UyuRAfSVtgyykffIufl3j6aKReA44bKVjhrMzYRoVX7s48YujFyOrjWZYy2EoFAoeJs4i90ETEBBAjMWO6UfSQSOP0Ki6LzvCclhzcgfONlrc7HWUc7DB3dGGCs52eLg45Oum4mrvyu8v/M6xW8eYfGQy0ZnRvLH7DRpqGtK/xgR+3HsdgOnP16FBFc+Ck0mNgMUD5XAxjS0MWABVi7C2i0muIfnsB5M+HJIocubgdmqk7mHqi9YoFWaynOtgM3Kt/IAtLoW00JIkiT2LriBmaUBloffbDbCxu4/LpDiIIlF/v4l35Lq8j6LbzcSn/SuPNp4kydErQPuu/fh2o4IDVxOYtOEi0wJrP1yBp39wQssjifScOXOYMWMGsbGx1KtXjx9//JGm90l1njVrFj///DMRERG4urrSv39/pk+fjk73z3i1jYyMZOjQoSRJSegv6PnpfBY9K/jgcD2GpH1HsH3uOb6a/BXvnnoXk97E2ZlnGf31aFamrESv0aMeqOb5AX2Y4NUFl6hgdLEnIesagxzd+K2jgkZhIjbpSmLPuyF28MHi3ZKadbuzwrc+P+2fw7KoZaQqs5h5fSbLry3nw6Yf0qFm0Z3MCyP3QdNlzNR8ldFOR2VyOir3NdgEZAKJ+Y7VKcHd0Ronaw2OViqyU+JxtFJR2/odrBWbCBUPcsZ4hlOnRqKw6cuAGl3oU78QgY45C0tegMw4sPOAISvA4zH8jP8GzEbMyTeIv3IcY9xVSL6BKiMKK30sduYkGmGiUYAsRguCzWwWXFj5zkMINBTq7jizPZzQk3EoFAK93m6EV+XH7GuYFgVrX8crN+kEyHjtBJ6e/vc56AEkh0FGDCg1+DVozw82aYz++zRLjkfg62LNqLaF18IulH+wu+OhRXr58uW89957zJs3j2bNmjFr1iy6dOlCSEgI5coVfGVesmQJ48ePZ/78+bRs2ZKrV68yfPhwBEFg5syZJfIlSoPc7hP31qFe+M1CXn75ZYIc7Gmclk7U3LlU7NwZ/4r+cArU9mrctNXIXO1GlUgRx95qjpQzclW4zluRP/FOciov6DNRAp8kZPF+eXu+7q3m88UW0kNVqIeOokr/gXnzeL/z+4zIHMG0ndPYnbqbaEU0Y0+Opc7ZOnzW/jOqVyheV+fcB01mWBja9EiwcsTOrQJvvz+eHFHJpbAI0vUW0g0imWbINivQS0okBPQWCE/KJjwp+/ZoCsjzN/ZAaVULnccqFNpErL0Xsi46mB3TnsdF54wpKwV7jYK2ymDezv4JrWQg0aoSR2rPwC3NCV/rHJysNejU/95075zkGDIizqO/dRlL4nUUqeE4Sqk4WJIhPRqVJFKhiGMlIMGoY+ruVH48YQQ2PHzJ23vcHYe2BhO8Xu4E32ZQNbz8H0+gs479hc3eiWBIy/vsVpff8HgcgYY7WYZeTUBtxXO1rPi0R02mbLrEl1uu4O1kTbc6xayimGtJG9Jld5uV4+PN7Qny0CI9c+ZMXnvtNUaMGAHAvHnz2Lx5M/Pnz2f8+PEF9j9y5AitWrViyBC56I+vry+DBw/m+PHjjzn10iM37G7lypUMGDAgT6CXLFnCO++8w9y5c5k7fjyNAceQq/Rr04Ypv/8AgKAReLnty5hwwd1hBkPTR3HLnMoXLs6c02mZ7urMqnKVGV/nHTrXfZ4hJ79mCUvY1VRH5+N6Mr76mqyAAGzueuA52zrzXd/vuBZ3jS92f8FZ41nOm88zZNcQXqr1Eq/VeQ07TdEdJwo24f1Frg287xBzIk7JdRh6F7RoLRaR+LRMUrJNZJsFkrOM3ErJ4OK1cFKyTKTmmEk3WAjJ8CXrxlg0rrvQuBxA7RCMweYaN2L7YM6uw0uGXbyrWoBSkDhgqcOYlLFk7DUCd+pAW6uVqEQ9NioJW7WAg06Bg06Fs40GF1stFd2dqVrRAydrDU7Wahyt1ChLwH9aEohmIxlRVyDlhiy8KTcRk8NIunYaO1MSVui5ryNBbU0yDmRry2G28wYnXzTl/fnmtxXMX7OLjOw7i9OP1P0815I2ZhJ6PoKgDfEIKPFt6EDttoW88RSTnJRbJCwYRsW0/PeypfYAPFoMLOKoh+BGbir4ndC7ka18CU/KYuHRcP63PIjyDjoaVHR68Fgaa7B2gewk2Zr+B4n0Q6WFG41GrK2tWbVqFYGBgXmfDxs2jNTUVNYXUit5yZIlvPnmm+zYsYOmTZsSFhZGjx49GDp0KB9//HGh5zEYDBgMdyp4paen4+3t/UTSwu/tSjF37lw+++wzZs+ezZAhQ/K6Uixb9CfRrwzHJSEDRRWJSo3iaVapAmZB4O+rLhxK+ixvzFZNduHZpjc7Tdf5MfgnMk2ZKAQFbazb8FmXz3h97+uEx19l5h8C5VLMpDVqSPPFi4uc48GQg3x/9ntCDaEAOGmdeLHSiwxrOKxAE9nS7rKx+tAF3t90ExB4t4Uz/pWymHZqKqlK2VJrZHZkRswF3Cwi+zUB/KB4mRSjkkyThEmhJdMEZvHhnckCElrBgrVSzNdNpkclJV5uTlSv5Jkn6GrRQAUXBxxsdI/eCFifjpRyg6jzh7EkhEJqOJrMaKwN8diJqfkiGQojU7AlU1MOo7UHFoeK6MpXx6NmC3CuBDZuBSI0HpTm/1Ddz7d/Akd/IqP+WP7a3RLBpEFpr2fk1M5oNI/WHfzWkRXY7nwfOykdEQGLxgG1MRW0DvDWSbArPB672EgSfOcvu8aGb85Xs8NsERm16DR7rsTjaqth7Zut8HYuxirNL23hVjAMXg7+XR9vfiVAqXQLj4mJwdPTkyNHjtCiRYu8zz/88EP2799fpHU8e/ZsPvjgAyRJwmw28/rrr/Pzzz8XeZ7Jkyfz+eefF/j8SdXuKODiWLiQ10YMpbwpgsD6rozsWA1d4gX0sSoi97kgqESq9o6jY2VPklQKArZnkHarGc38R+eN2e0DP/yq+BKfHc/XJ75mR7icRWVjseF5v+dZFrGMSpFGpiyyIACKTz/B/6Wi6/9KksSBqAN8d/o7bqTJRXQcLY6MrjGaIc2GoLgrUqK0+tXdjE2m+w8HyZZUNC8nsuw9OdpAb9QzadPHbE/fiUUAO4vIh+6t6d11LgplfreGJElkGMzEp2ZzLSqW+NQs4tNySMrUk5xtJDVbttZFtTUG1CRnGUnXmwubzgNRImKlsOSz1iu42OPv44mTtRJHwy0Ut4JxMkTjoI/GJicGB0syjmKybIHdBzNKstSuOPjWA6dK4ORLvNkGpVsV7CvWRm1deKuqoggMDCzU6Mnlobqf752OZd8MlqXPJDWnIpLawJDPWuLs9nBzAjDrs4haOBqfmI0IQKrChew2H+Ny4BO0kh6p2wyEZqMeetwCJIbCT41BqYXxEQVCM7MMZgbMO8qlW+lUKWfL6jda4mD1gAfOshfhyibo/u0T6Y7+IJ4Zkd63bx+DBg1i6tSpNGvWjGvXrjF27Fhee+01Jk6cWOh5nqYlnUuuUFcUw5k7wIsqulTUivw/VTp2RG1zREi1cMDNlm+7pKLz1qHYryBzfyaT35hD+rU7Vt7o2e1QaWSRWnp8KbMvziZTmT92dehukV4nRPRWVlTdugXb8uXvO0+zaOa3Y78xP2Q+eoXcHcYbbz5q9hHtqrfL26+kOz+bzBa6TN9IWJYaV7WRPeO7YW9z+0bKSoJlgwmJPcNEN1cu344O8RP8+KbzN/h7PJ6v0mAycyspnVvJ6dxKzuTznZGkGWRLNsATJLUNFpUVyVlGEjP0JGbqEVGgw4C3kICPEEdFIZ6Kef8bj7eQgFa4fwxummBPvMKNJIUbmVYVSFO4gLMvthX88ahUA09XJ5zsrPI9IB+VunXrcv78+SK316lTR66zXBwOz2b/6kguZHdDEix0GeNP1doVH3zcPSRdOgBrXsPFLNdYDHdtj8fw+cT+MYSKKUdJUHviOv4cQkkUMDr5B2x+T3Z1DN9U6C6xaXoC5xwmNl1Py8ouLBjR9L7NkNk6Ho7/LKeod/7i8ef4mJSKSD+Ku6NNmzY0b96cGTNm5H32999/M2rUKDIzM4t1QT+tKnhHjhwh+vtODKgli4xR44TGvzP4tibTrQE2XrW58NMcVHPnkmNlxdDaWSg6aUCCQG0gUwZP4a+pu8iMuvMd35hzJxY1LTuNT7d8yv7M/XmF/dUmiW/nS3gki6TVr0/zZUuLNdfEjESm7ZzGnvQ9eW216qnr8Vn7z6jmUa0kfxYAZu0MYdbua6iwsGR4fZpWv33TJ12XM+KSw0DngHngQuZnXGXO2TmIgohKVDHEcwjvdXoPZQnVhp647gKLjoXzTocqvNfCEVJuEnXhIKb4ayjTItBkxWBjSsBOun/tCrOkIAZXwsVyhEvuhEvuREjliJDciZTcyCxG4KPitrXuZK2horszzjayyyUj8RbONlpc7XSUc7CmvJMtHs52VLgnxLE02D9rHheuVANE6vV2pXX3+g83gCjCsbmIOyehkOQkqpS2U/Dq8CqxR1dSfvur8gJnn2WPFAtdKCtHwMU1coZiwEdF7nYpJp0B846QZbQwoJEX3/SvW7TRceQnOZ2+dj+5EW8RnD9/nn79+rF69Wrq1KnzuN+kSEpFpAGaNWtG06ZN+fFHuXC3KIpUrFiRt956q9CFw0aNGtGpUye+/vrrvM+WLl3KK6+8QkZGBkrlg2/UpyHSuZa0Jv0mB0fa4moFwYkqXN49iFflO52NzTl6LrRujTYri0/j44gZ409mlUyQYLjbcN7v8T5/TNiDXk6cwsZBw7DprRAUdy6kQ1cPMfnwZOIUcl3dqtESUxZZUEig+WwilYfc0wbpPoTcCmHK3ikEm4IBUEpKhtYcyusNXsdGXTIdTY5eT+LF348hSjC1VzVeanW7PGjE8dt9CJPlGr4vroRycvTJmZtnGL9vPLeEW4Bs7X/d4WvqeD/cTWDWZ5EReZHs6EuY4kMh5QYJ8THYmRKprEpALerve7weLZlqN1yqNkZw8gXnSqTggMK1Mnae1VGo5Dcfk9lCbHI6t5IziE3JJD4tG6NCg6iyIjnLRHxaFiE3o8kwSmSZBXJEBWYe7aGjU0qUc7DJE/Ss5DgcrVQ4WWtwtdPhZm9FOQdrPJxt8XR1xNXeBoWieG8/USHJbJh1BklSUM9tF62nfPlQc5NSIxHWvwk3DgAQ79QQm0HzsXGvhMWYQ9rXdXC2JBDu1hGfMWse+rsXflIJvq0GWfEwYiv43L9U7t4r8bzy10lECcZ18WdM+yJSzi+thxUvg3czeGVHkePlupoCAwMfboH2ISk1kV6+fDnDhg3jl19+oWnTpsyaNYsVK1Zw5coV3N3defnll/H09GT69OmA7F+eOXMmv/76a56744033qBRo0YsX768RL9MSXGvT3r13C+ouHcMzjqJM/Eqyr1/GK/K1fP2/alDB4YrVdyQROx+/41PD0wk2Uuu3/Gqx6u83fltfv3ffsxG2cL1qOxA3w8a5nvim8wmvtv1HYvj5AXDIXstBB6TUDg7U3nzJlROxVjBvot9l/fx9fGviRLkuFBnnTNj6o+hb5W+qJWPbrlFJabx/C8nic8w0L+RF98OkH3Z0oW1CGtH3+5D2EBenLln8chkNvH1zq9ZFbsKi8KCUlTS370/Hz33EerbbbckUSQnJYbMyAtYEq7hodXLhetTwsmKuoC1OeX+BZUEBdh7kSI4kK50QXSsiNK1ClYVamBbsQ5WTsUM2XoE0rP0xCSlEZuSSZZZwKTQkpxlJD4ti/OhN4sMcXxYlAoBJ2sNztZqjJkp2GsE7HVKnKzVuNhqcbGVrfVyWluurYjCmG2mqu4AnWoeQDFqT7HPE7l1FuVOfoVWzJGr6XX5EhoNz1vkvPH3WCpdW0AW1ijGnim53zb+CsxtBiorGB8OqvtUT7zNoqM3mbj+IgA/DKpfeJx+9Gn4rQPYVYD3LxfcTsEF24daoH1ISk2kAX766ae8ZJb69esze/ZsmjWTU4UDAgLw9fVlwYIFgNx2fdq0aSxatIjo6Gjc3Nzo1asX06ZNw9HRsUS/TElQVDREbNBOdMsH4KiVCEq2ot6MUNDY0rx5c66cOsXeKlWxEgS8//idRC9Phi0ZRnKFZBDhhw4/0K5CAPPe3pd3Ht/6znQfXa/Aq1lcVhydVnVCbZb46k8L3omQ0rw2LResfOjvIooiu8N3MztoNjfTbwLgJDrxRs03eKHJCw/tOz1z9iyjFp8jUeVKZVdrNr7TBmu1ktStU3A88Z28U7Vu0P+P+9YtvhgRzPjdH3BTIfs2/S1WvJeupWpmInbmJHQYijwWwIiadJULel15THZeHM2uwPYEJ9o2bcwrPQNA9YDWXM8IhYU4xqdlc+5qWL4Qx1xrPduiwFRMa10twYsZWtxEBRnKLD5wHclNXBnKl4WGOHqXc6JqxQo422iwNadgWP4qPmnHAMh0rI7t0CXgcid5JC3iAlbzA9BgIqLRx3j3/LDk1jxO/AZbPoBK7WDYhmIfNnXTJX4/dAONUsHi15rRxPee+O/MeMQZ/uhFe/Sjg9HnSORkmMjJNKHPNJKTaWL75l2kJWWSpc9g+eFZPNe1U6lZ06Uq0k+aJ21JFxUNEXtmKzarh2CnFuUFjSErCL4cyqhRo1gU0B7L+vXk+PvTcP06wm6G0f+P/piqmFApVPzQ/geaODZn/gd36lzU6VCBtgMLJqPojXqaLG1C5RiJqQstKCVY1teLYe/+gl+5hy8haRJNrAhZwQ8nfiCHHAAqUpEJLSbQulrx2hFJkkS7N74kwrE+Siz80N2Tnq3qkbFqDHaXlwGw4qYjA/64jqBUoU9LICPiHPpbV7AkhCLkhqwZE7AX05AkC6vtbPjO2YkshQKNKPFGahrD09JRAZmCHZkaN9yqNUHpWgWcfMlUuyI4+2HtVjFfnZLP1l9g4dHbPunnHjOB4hlHbzKTmm3Os9AvXo8gKUNPUqaBlGwTaXoz6XqRJolW+Jg0ZAkSJ+1DWGk1gWjJhVaGH+87fgvFRb5Vz8NTSMIsKfhd7MVyZS+stRocdEqcrFV4ujjQ/+YkqmUeJ0JdmbNNZzH984ksX7wQH5/H6OKSy4qXZddEh0/lAlJFIEkSJoMFfaaJnAwTWRlGftlxletRGTiplPTyd0dlluTtmSZyMo0YsowUt2TRsuMzOBS0rdSs6TKRfkyKjIaIPImwqK9cB8EvAAYvQ1LpSLp8mfh+/REkCfv58/Fs2QKTxcTHhz5m281tqAQVH9f4mBaubVn/9cW88Zr39aNRF98C58ltyfXCfgv9jkikW8FHr+joVnUQ73d6H9UjrKAnpCcwZccU9mfulxcXJWigbcCkDpOo7H7/FNsNRy8xdn0YEgLW59egvLaXvWMq4Zp8CoBbWQocaj+HtSEeQ9xVtJYH9NRTasHJl6sqe77UZHH6dpSLh8WJic0m0aZWx2J/r0nrL/DX0XDe7lCF9//lIl0clv2wh6TLICHSbqQvlTyN2P7WApPajqXNNpCQnkNixt0hjiKCQsFg/VJelLagECRuiO68axpDkFTQv9tBcYb5mm8xSUp6GL/kqiQbMneHOForRbKS48hIvIXClMOE997C2UaLMSMZd8fcRVN7NOo717HFIqLPMKL/qTM5WSI57b5Gr/NFnyWLcK61K1u+8n8W86M1ytDqwMrBGp2NGis7NTpbNVu2byT44hl6NnsZFTqWn/iGo+d307Nnz1KxpstEujSJOAaLngdTFlTpBC8sBrWOY/3643DxImmNGtF88d+AbMWO2TqGo4lHUUpKJtWZRHWhPnt+vZE3XPuh1anZqmBi8NrQtXxxYCLTF1jwSYBj/gIz+yoojwdftP6CFlVaFDimOFyKvsSUfVO4YJZbGClFJV1du/JZ18+wVheMYIiMT6HrrP1kiWoaOBoJ/u0Dvml0i/417+/bzhJsyFK7orf2QLSviMLFD015f1yrNkbl6JVX9U6SJDaGbWTKoSno0SNIAl0cuzCl+xR0mgfXdykT6TvsWXuKy9vlDMVqHWzpPLAppMfAzBpyj8CJiQVLm8ZdJO3PF3DQyxXibrgEYO4+k0SDktiUTOLSsklMzyE5y0hmVgbTUj/CTYxnlfZ5vpVeJCE9B8u91qkEWgmsJAErCawlAStRwEoSsM79XBSwkbj9twKN9GiJRkq1AitbWWit7DQIWgU7ryUSbzLh7mpN9oUN7Duwg2YtG/Nr10x0kTtQPP8z1BuUN8bdvuhZr29CJVnxx/5POXvlaN72kramy0S6tLl5WA41M2VD1S7wwt+E791P9tvvICoUeG7aiKOf7JrQG/UMWTaEUCkUpahkSoMpuCb4cmZ1Qt5wXV6rTZVG+WufSJLE2zveJiJoH9P+sqASYXZvNYdqSQgIDK89nNfrvl6osBaHXRd3MePkDGIEuRmAq5Urb9V/i8AqgXnhcRaLSNfpGwjNVOOsMrL7oy5cPh/Exa86MryBjhTRhhxdecrXaIa2fHVw8kVvXQGFcyU0dg9XEyI8MZz3t75PiChXDHQWnZncfDLta7S/73FlIi1z8VQYe/+4jiApcaomMuS92z0l9Wnw1e0QyU/i7iSGiKIcN7zrc7AYyBZsSG79OV4di070SFg+FtdLC8i2qUp427+IjzeQEpdBwq0M4mPSUZi1KCUNViorlMLDx4tLSFgJ6UgKI9dwJkcBOYJEtiCRI0joFSIWhQW1lRJXd0dsHbQ42WtJT7iFs40mL8QxW1TyxfabmEWJzIt7Sdokr5kk/TEI54gtBVwpdycPzR69HQUqZm15m2uRl4CHTB4qJmUi/SQI2y93tjbroXpPGLCA4891wz46moznnqPp7B/yds02ZDN4+WDCpDBUoorpjabDRUeu78/O26fHmLr41nHNd4q4tDj6rO5D9yPpDDgkYdBqmP2GHyetrgHgaevJhCYTaFexHY+CKIosOraI5beWE5kpW1I+1j4M8x3GgCYD+GjBbpZf0aNEZNHQOnjbK/MiX3K5e4H1cRFFkT8P/8m8a/Pk5BwJ2tu1Z1r3adhZFV6fJFek32pfhQ+6/DdFOiEmmeVfnkAwa1A563nliy6oVErZbSeJ8MXtB+a4MLBxIT3qCsL6N7FLOC1/XrULYq/ZKOzLI4oiSbGp3IpMIjEmjdSELKxVjuQkpJITeZMMixtmqXgVLFVaJVa26juWrq0Gna0ajbUSo2AhSzSRbjaSYjJg0qjpEjGFKkl72Oj6KrNT25RIiCNA0o6f0Z/fzsJXajG4/A05SqXXnfszN3lIISiYPWonAF+sHEp8smzAPFTyUDEpE+knxbXdsHSwHHpWsw+XswLg6xkYNRr8D+xHd1cES5Yhi0HLBnGTm6hEFTOaziBpt4LES3eGC3y3AZ7++cPtNgdv5pNTH/HlQguV4iDN35+c2e8w/eRX3MqS445rKWsx/bnpVCpX6ZG+hsliYlnIMuYFzyPdKL8ul7f4ERbRG4u+PG82dmBwM597CjUtkgs13f67pIQaICYlhg+2fMB5s5x1565x55sO39DQvWGBfSdvuMiCIzf/syJtNlr47eMdiJla0BoYOrkN9k62+RfA/2oC5hwYG8yFHYsof/5vTKIjaXiS6fcit8wVibmZgClbAJMaQXqwFSwpTSh0FrS2CpRWIkdPH+DqjYtcu3mFTH0a5Tyc2bVnZ/GvCVGEGX5yi7BXdoF3k3yb07P0t7NMM8g0SZiVuVmlOQSHhN03xDHtyHJSDy5ieH01f/axgsodYWjBuO6MtCwWfiRnTr/yfWt0VqUXKVQm0k+Sqztg+YtgMSLWfJ6z313COi2dnJdepOGnn+bbNT0nnUErBhFJJGpRzY9tfyRznwPXTsbn7dP/o8a4V8r/PcetHcfl0K1MXyC7PSzvvI3fa8P57uh3rAhbAQKoRTWDPOWFxUfN5kvISGDytskczDqEJIhIkoCDvhF/BX7Ci31eLLVCTUXx99G/mXN1DplkIiAwuPpgxjYcm8/F818WaUmS2PPXZa4ciwWlhR7v1KJilfJkphgY8dIoFGYt3u5+dHU3kG12IsXigd7iiMj91xMkJFCZUFqJaGwVlFPH4pe6CRtlIjz/DeVr188TsIJVFh/x4R17Hua1lluDjQ+Hx4jnB+gTGMjeQ8eQlBoy4+W3xM5VNOx4UQeu/vDWiQLH3IpIZM2X55AQeXNuhxJJ8S+KMpF+0oRsheUvgWgmMqEhmbtjEcqXx3/3LoR7sirTstN4YcULRAvR2Gvs+a3T74QszCEmNDVvn0ETm+LiaZv3t9FspOffPWlxJJpBB0QEezsqb9yE2r0cB0MOMvnIZOIVstCXl8o/1sKixSLSb94qrojrUNvLlqxKVNFS05Izv5xhxeIVJVqo6UGkG9P59uS3rL0mr7A74MD7td8nsGEggiAUEOlHrUfyT8FoMHErIpH4qGTO70ggJ+VOhIPOToEhS0J6YGVBEZUVuHs7Y+esQ2uvJNOQgquHPe7ezrh7uaC5na5uSE/E9H09bKVMbvoOwXf4neJoJVpl8djPsG28vBj/0upH/XmAoqsIVnFWEPq2LRalFcpPbxVYRA27HM3WH0KQFGbemvvcY83hQZSJ9NPg0gZYORzRJHJtS0Us2SY8f/gB+y4F/7FTs1N5a99bBCcE46h15Jd2v3Hk+1sY0uV/DkEhMGRSMxzd71iMF6MuMmzbi0z+20DlWLANCMDr57kIgoDJbGLGzhmsjF2JWWFGkATa27VnSvcp2Fs93G82/q/dLLusR62A8d0tLLv2I7GCnHjirHbmf03+R+/KvfNZ609CGI9EH2HCvgkkm5MBcLvlxqy+s1gTomTBkZuMaV+ZQTVtSvWB8STQZxtui3AKSbEZaLBGNKjITNaTEp9JToYZ4QGZigqlgI2jhkxjCrHJkTSzOkcVm2gsQjbzrsC73/9OpUq+xZrPzXmD8Y3dQqrCBdsPz6HS2ebbXmJVFpcOgZDN0OlzaP2/Ys2tKIqqIqhVgv7T2/fDhzcKdKaPDUtj9TensXfRMXTa/dPRH5cykX5aXFgDq18hPtiGpEt2WNWrh+/yZYXummHMYPTO0ZxPPI+NYMM0/6+5/JcRQZTFT2erZuDHTbBzvrNI8/O+n9l4ag5f/WlBbQGHiZ9S4cUX87Zfi7vGhB0TuCJeAaCCTQUmtphIa8/iJa1sOXGFMWuuISEwupE9Ewa0QRRF/jj0BwvDF5IqpgLg7+TPGzXfoGOV4sczlwTJmcmM3zyeo3o5NEpr0lJJGsrJ61UY2qgcS8YPKjXXS0mRlZFDRrIefbqFzGQ9cVEp3LgahTFTQtQr5cawD0n5egocy9ngVckdLz93rO01efVhjhw5wjv92/Ccvw3zThrYtGMvLVsWT4ASL+zFeVVfFEjEdJxDhTaFl8997CqLogjfVAJ9Kry6B7waFWt+RXG/KoK33relvK0CRh8Aj/wPj4hLSWycHYyLly2DPi26JWBJUCbST5NzKzEveZ1rG9yQRAHrWd/j07XwIuNphjQGrR5ElCkKK4sVn/t+RdiKO9vtXXU8P64RNg536hdMODgB1d8bGLJfxKhRU3HNGpyq5E86+Pvo3/wR/geJBrlfYVffrrxd+20quhRdojImMY3nZu4lU1TTwNnC6g965vPJGS1Gllxewq/nfiXDJDc1rSxU5uNWH9O0cule0Pfy976/+fHqj2Rr5egYU1oDzIftuL5ibokvYj4shhwzSbfSCbsSQXJcJhlJOWSnmTFl3RZh8cEiLAkWBI0ZtY2Eq4cDvv5e2LtYYeOkIceQyZafzyMYtSjs9LwytXOea+Je7nY75FLs30cUEf/ojCL6FFEOTfB6d9dD/Q4Pxa1guSi/xg4+ugklUe60KH5tDzFnYNASqN4j36Zrp+PZ/tsFPKo48PwHj/egeBBlIv20CVpCzMcTSAuzhkp21NhyvGASwW1updxi8LrBJCmSsBatmeA8leitd1wJLp42BL7XEJ2NfCNmGjN5YV1/Xv85nCq3IK1yZZpu3FBgkSPblM1PQT+x+PJiRElELaoZ7Dm40DKhoijS/asNXElX46Q0suuj53CxL7z+Roo+hen7prMtdptcYlWCprqmTOo0iYquD1+n+FG5cu0KoxeNJrlSCggSglGHfl0au+ftLjWBFkWR9ORMYiISSYxOIzkuk8xkPdlpZtSSFRa9AkP2g5sSKNQSTu522LvosHHSkJKZgJO7DW6ejpT3dsHRxa7QRSuzyczvE3dgSdUhqYwM+rQ5ruUdCz3HYy/onVkIG94GjS3SmBMIDo/eauuB5JYRrfqcXD2xNMlNO+/6NTR/Pd+mvWvOcmlHCnaeAi9PvH98/uNSJtLPAMlLpxD3+RJAwvPDDtiPmFOkUEclRzFk/RBSFCnYWGz4n+ozko7ccXOU87Gjz7sN0OhkCyM4Ppjxi17iq/lmNBYwjRpF3ffeLXTsi4kXGbt5LHHIpVA9JA++aPMFzSs3z9vnk4V7WHwpByUifw6pRdu6D64REhQexNQDU/OST1Siim4u3ZjQeUKRMc0lzZEjRxi9ZCmWupdQauWF084+nfm42ce4Wrk+4OiCiKJIcnw6sRGJJMSkgVGN0qIlPVlPanwWqfFZCNKDI2d0NioMUiZqGwFrBxV2LlY4u9vi5umER0UX7J1sHzhGYfw9Yydp15VIgoVOo6pSvYFvofs97oKeKS0W1bzmCDkp8Nw0aPnWI8232CwZBFe3Qucp0Oqd0j3X7XZitHgLukzLt2n9HweJOmlC527klc9Lt8VWmUg/I5zv0gpVeDJOVbMo/79XocPEIoU6IjGCFze+SKoiFVuLLaMzPybr0h1rtkJVR3q9XS+vu8vHGz6GresZulfEqFbhtWoVLv6Fh6CZzCa+2fkNq2JX5S0sdrDrwBfdv+B0aBIjl1xEQuC1BnZ88kLbh/qOm4M3M/PMzLzoEhvRho9afUSfqn1QPELWWXHJFRybhr1JrxKAvd1qRI8zCAoBa4U1w72HM7rt6HwWqWgRSU/JRp9uIT0ph+TYTELOX0efYcGcLSAZVcUS4dwYYY2tgLWDGnsXKzx8XPCt5oWdsy7vYVqSbFt6LC/5qVZ3RwJ6F4wZv5vHWdAL/7EPPkn7MLv4o3rz8GOHw90X0QJfV5K7jY/aJ5e6LU1yo0hqBsLAv/JtWjlnL/HnJWwrmhj2cZdSnUaZSD8jXFu7FtOEjxGUIlV6x6F67iNoP6HI/W/E32DopqGkKdOwt9jznuEbYoPvlO70qe1Ct9froFQpMJlN9FnYi9F/h1MtBtIq+dJ08+b7xnaGxoYyYeeEPOvX1mKHKXkQiYmVqe9sYc09fujiYhEt/HbwNxZcX0CWMguAGs41GNdkHE3KN3nA0Q9PPotwwBji/LrhbErkyqo3qf96I2xsnbAzOOOVU4maYj3IVmPOEcCoRnhAFbS8GGGdiL2rFZWrV8TORYediw6LQk95bxesbIqXcVdSxFxLYe13Z0AScKstMPCt4r2KP8qCXtypjbhvkhcI47r/hXvTwEeed7GIOQu/BshNbD+6ASXUsadILm+S8xo8G8Nru/NtWvzdLlJDFThVFRnyfqdSnUaZSD8jiKLI6XYB2CYk4FYnHddamQ8swXgt7hrDtgwjXZFOJdtKjIiZSMzFjLztlRuW47lXaqJQKrh66yrvLX6BaQv0aMxgeGUk9ccVPXYui44s4qcrc8i+LagafUNWDZhOJeeChZ4ehkx9JosvL2bB5QVkmuTKdtUU1fikzSc09L2/5VccjEYTsRGJfPzBJIxZ4F3ej/IVapGYpcNRFLAxiygVD7JiJeycrfKENyUzHjtnLc4e9rh7OVPe2wWt7tmpSZ2RrGfl9JPkZJhw8VMz8P1WeS3YShrRbCT5q7q4mm8R7twGn3cK7y9YohyeDTsnyrXIhxQeCVWixATBr+3A1h0+uJpv019fbiczQk25OgoGjAko1WmUifQzxPk5c1D9+BMWKyU1e0bKhsIDYkGjM6IZuX0kMVkxVLWpxvOX3yMt+o5FXb1FeToMrYGgEPjz0J+ELP2WYbtFLFo11TZvReP14EWeySv3sjRyOWrnIwiChJ3ajhFVRjCy8cjH7j+YrE9mbtBcVoSsQEJCkASaWzXns86f4eXsVeRxhhyjHCMcnYIhQ0SNNRnJetITc7gVnghm9QNjhC2iGYXWgkVnIFJ7nUTdLTJ0yVipVYxuOZIW9RujUpdi9EAJos82sn5mEIlRmbh42dJvXCPU2tKzNG8u+wjfK/PIQYf01kmsn8RC8OIBELpD7vzSYkzpny8rSU4/B/g0Pl/nl98nbcUQp8W7qYbeI4sXtvqolIn0M4RZr+d8q9bosrJwe7EFrpbb2VQPuCgjMyIZsW0EcdlxVDB60/PcWyhMd16z67b3ovXAqgiCwCtLRtBj/jFqRIG6SUMq/7UoX2H8e9l5+iqjV4YgouC19gqCjX9yOVluKeQheTClzRSaVW722N/99I3TTDs4jVApFACdyZoe1oEMrvkyxjSJC2dCyE41YcgUix0jLCGCxoTKWkJnp0Rtr+bvG0bSFRLrP2yLk4sVytuWpslsYvqO6ayJX4NFsKCSVHzQ9AMG1xhcqv7ykkAUReZP3o4hXovOVs2ACY2xd7EqtfNl3gpF/UtLtBgJr/sePs9PKrVz5WExw9e+cn32QuKWSwVJgmkeci2Td86C851F8l8mbMGcoqNKgA1dBj3+9X8/ykT6GSPht99I/G4m2qpVqPRuc4QD38gbus2AZqOKPC48LZyBaweSLWTjk1WVLhdGo7grzrZRNx+a96lMWnYar/zSnU//SEZrBrdPPsZ16NBCx4xLyaDzt7tJt6ip62hm3Ye9EBH5Yf8P/H3z77yFxY72Hfmi2xcPFalh1JsJD40hPjqF5NgM0pP05KSZyMjQI5qU6MwPjmrIjRHW2SupUsMnzy1hErJx83DAxd0x3+u+JEn4T9yG0Sxy8MP2eDsXLN0aHB7M+L3j83o+NizXkM9bfo6vg2+xv9uTJncRS0Kk3YhK1Gl2/8YMj0vk953xTjtBvLoibhOCEErbNwwQdRp+7wA6RzkDsBRrZeTjpyaQeBVe3gB+dypIzvtwK5Z0LbW7O9LuAQuzj0txde2f8c73L8B50CCS5/2CIfQaWapx2LY2w6GZsHWcHLjfeGShx/k4+PBzwM+M3juacJtQ9vv/TcCVl/MiEE5vDUejU9Gwiw9TXv6dBTcGMnyHmZivv0Jq0AC32rXzjSeKIiPn7SHdosZBaeKP1zuhUChQoOD99u/T61YvJuyawFXxKrsydnF86XHerfMuA5oMkGOEU7KIjUgiITqF5PhMMpL0iAYlWsGWjGQ9hqx7Y4QVgBYNd14pjUo96dokMrXJYG2mmkslqnr54lbBEY+KLji6Fh4jXBSCIFDOTktUSg7xGfpCRbqeTz02vbyJFSEr+P7M95yJP0O/9f3o6dyTT7p+guYZ64t4YONZ4s/L9lOVdralLtCmkJ14p51AREDo9f2TEWiAm3IXcnxaPTmBBnDwkkU6LSrfx452LiSlZ+Jb+cnF+z+IMpF+Qijt7HDs35/kv/7i+vezqLdmNYgmOPIjbHpX7prR8OVCj23o25A5becw5sAYQhyDsKpsR7Nr/fJ8s0fXXpf9lC5mNiaZaVIRakWIXPnfW7hs343irgJPXyw7wMU0FQpEZvavjZvjHctWFEVcFOX4osY37Ak+yJnY82hNdpwIjeH64uXYGJxQSPdeMvLYGdxplyWoRCS1EY2NgJWDCjsXnRwjXMGJ8j4uKKwkZuyZwYHUHWSbs9kGtFS15E23N3F+hB6OAA4aiAKuRSXQyKfwZgNKhZLBNQbT1rstkw5N4njccdYkreHwosNMazutRNw7JUFI0E3ObUlEQImDn4Wug5s/+KDHwWxAvWM8AJk1BuFWt3SjGvJx83bPz0ptntw5QRZpKCDSRr1sZGitSzHk8CEpE+kniLZ/P8SFC9FcvkzUocN4dZ4i++SO/wwb3gGFGuoPLvTYppWbMluazVsH3yLI7SBWRjvqRdyJ4zyw7CoXUndwecUVFk1qxuRbabhGxXF66hSaTJoMyH7oVUGZeIgKenvZknk6loXbwshJNxeIEVZQkcYUbk1IShMKrRwjbOWgxtHNmloNqmHnLLslihMjPKXHFMbmjGVu0FxWh67mSMIRju49SiubVnzW6TM8nDwe7sfVZwAqQiJiodX9y5V62nry63O/8uPeH/kr4i/iFHGMOjiKbhe6Mbn7ZHTqJxtedzdJcans/P0KgqRB6aBn0LulW4kNkKMrkq6BTTns+3xd+ufLxWKCcLkGC75PWqRvX9tpEfk+zhXp0ohzf1SenZn8B3CsWpUrtWvjcP48UXPn4tWmNXSdLlvUJ3+H9W/KFnXdAYUe36JKC2ZZZvG/I//jqOcWbE1OVL51p2ZGDfuOtKl9kfQ9Fja0rUHTUAeyzio58+46jBYtolHDG9x2BVyRiMKIfAnIl0FuzISkNKK0kqhcoyJ2zjpiTRFsTl1HiHiBTE0K/i7VeK/2e49dr8PVypXPWnxGX5++fLrrU8II41D2IXqu60nvcr0Z12kc1tritQZzsVZBGsSn64u1v0KhYGzHsfSK78UH2z4glFA2p27m2N/H+LzF57Sr/midbh4Hs8nCim+PIJh1SBoDg8a1LvUolLSbwdju/0Z+H+ryJegcSvV8+YgJkvuEWjlDuZpP7rxQqCUtiiKGbBMgIAkPTu1/UpSJ9BOmwptvkPXGm9gFBZESGopT1ary4qHFBGf+grWjZB91rb6FHt/Gvw0zLDP48OSH7PRZgrPCHadoH0B+nX+h5e3UcAuE5XoOcmTPsAIQkbB11OLgaoVRygKNGQc3K1zK21POywkPb1e0BbpRVKaX2IalV5by49kfuZh6kVcPvkqn4E583u3zx04Br1OhDutfXs+a02uYfW42SYokViWuYvvi7YysOpKRrUY+0EftaqsBjCRmGR/q3H7l/Fj10ip+O/gbv4X9RpIiibePvc2QpCG82/xdtErtgwcpASRJ4uDyUMQMHZLCQrfRtXF0Ld1FckkUyVz5Jg6ikQTbGrjV6V+q5ytArj/a9wn7o6FQkTbkGOF2M1yN1bMjjc92DNK/kIrt25Pu7Y1Ckgj94XaPNYUCes6C+i+BJMKqV+DyxiLH6FCzA390/wNrtRWrvGaT5ngr33aTkEW65RZJtpfwithMjSuLiE4/xB8OBlp+1IARX7Xm+Q8aMWhcWwaN7UC3IS1o2qEWvtUqFCLQMiqFiqE1h7K8y3KqKqoiCRI7M3bSZWkXVp96vALtuTzf6Hl2Dt3Jq16vYmWxIkOZwQ9hPzBw3UCC4oPue6y7gxyalpJjeejzKhQKRrcbzdrea6mlrIUkSCy+tpgBGwc88Lwlxfl90Vw6FAMCdB9dj8q1Sr+CX/Se3/DMuoAFBares4osV1Bq3Dgo/++TdnUAON7+fdOi5JA8IDM9B5AzTm1sSy/U8WEpE+mngMPLcmicbv8BcpLlAvYoFNB7NtQdBJIFVo6Qu70UQT23evzc6Wc0GjVrqswmXSuXJM0hlcl/D2Pin8M4c3MXRysfwCP2GAODl+F6cSWq9MjHmnsl10qsfmk1H1T9AGuLNRnKDCZfnMyQxUOITHq8sQHUKjVjO45l56CddHPohho1IRkhDN06lPf3vc+NlBuFHlfBSa5xkmp49IhSbxdvlr20jJltZ+Kic+FG2g1e3voyb616i/Sc9Ece90Gc3n+FQyvlzLeWfavgV6/cA454fIyZKdgflosLRXoH4lStlBcn78VshEi5l+BTEWm7CoAgN5HOku+drNsijWAptYzOR+HZmcl/iGpDhpDl6IjaZOLyTz/d2aBQQuBcqN1P9lOveBlCdxY5TkP3hrzh/gZmpYGNNeegV2VihSMfDpqNUqFi+44DbHYeQbCvAq1FYkzsUUa/9hqPGxovCALDWg5jy8AttLJqBRKcN58ncEMgC88uRJTEBw/yABysHfgm8Bu29t/K81WfR0BgR/gOAtcHMmblGOLS4vLt733bNZBhfvxLunOlzqwPXE/vyr2RkNiftZ9uS7ux4eyGxx77XsJDb3F0eQSSCBXrOVC/85OpgR2z7H/YS2mkC454Dp71RM6ZfwJnwJQN1i5QrsaTP79KA3bl5f+fJhsXWRm31zOUj3/9liRlIv0UUCiVqPrKPmftjp1IZvPdG6Hvr1CzD1iMsOxFuL6nyLHW/7SerMVZZGlS2VTjZ8wKIw7KCnww+DtqDJ1ChsGHuU06kq2FapnwY2DnEutW4mLrwryB8/ih6Q+4iW4YFUZmnJvBiG0juJ56vUTO4W7jzuctP2dlr5XUsqmFKIgcyD5A9zXdmbp1KnqjfGN5u8kLXjmiEpP54V0e9+KgdWBa62l8WuNTbCw2pCvT+eTcJ7y67FWSMpMee3yQO1Nv+ikIQVQh2OjpPLzOE+kkkxxyBO8o+YGT3vpT1NZPcLEwl5u5ro7WT97Nkss9fumcTPlaEpTPVn5fmUg/JWq9NQalkxOKxEQydt5jLStV0O8P8O8BFgMsHQw3DhQ6TlhYGNd2X0O/TE+yTQzbq81HRKSCVQ1qqORuLTevuzG/nuxr1i5eQ/ixQyX6XTrU7MC2odsYW3csViorzsSfof/G/oxbN46MnIwHD1AM/J39WdpvKRNrTsRJdMKoMLI8fjkd/+7IgsML8HSxRwAkBJIfcvHwfrzQ9AU2D9xMU60cyXLccJweK3qw4uSKBxx5f8xmC0u/3g8GLZLSSL/3muV13y5VJAnTundQIhJlWw+vjq+V/jkL42n6o3NxyPVLy5Z0TpZcG0dQlYl0GYDaxganIUMASJr/Z0EXhFINA/6Eql1kv9mSF+Dm4QLjnDt3DkmSCNkewkc1PiLaMYQDfssBaGlQU9egRFGxIVu8JnCmkgq1BS5/NJZbiSXrY9WoNLza4FXW91lPgFcAZtHMtrRtdF3alTWn15TIOQRBYGCTgewauovhFYajE3WkK9P57tp3BC7rjZOzvICakFlyIg3yG8Mfg/5gat2p2FnsyFJmMeXSFMZsHEOaIe2Rxlz54z5MyTokQaT9iKq4e7qU6JyL5NwK3HNCMQtq7AfMeTLnvBez4en6o3O5x5I25MhvtKVZOvtRKBPpp4jTkMEIGg368+eJ3L694A4qLQxcCJU7yv67xQMg4niR4w1pNoT3q71PSLnjnPaUx+uUraLCtYtIOQI/1B9ElhZ84rL54a036TH7IDO2X+HkzWTMlpLxw3nYejC7w2zer/I+1qI16cp0Jl2YxIuLXyyRhUWQHwjvd36f7QO208W+C0pRSTTRmNx/QFdhKVcSw0vkPPfSp0Eftg7aShvrNiDBgeQDBK4PZE9E0e6owti16gTJIfIrfo1ODtRqXLop33nkpMotqgBVhwnY+9R5Mue9l+jTsuFhUw7c7p94VKrcY0m7u8oJVN6+RVdpfBqUifRTROXiQkaTxgDE/Dyv8J3UOhi0GPwC5MD/v/tB1Kkix2zv3R67/Xac9NxCiNsJlIKCAY61ERdPInHXHla1rQrAkHOnyQ49zZy91xkw7ygNp+xkzJIzrDwVSXxG8RJCikIQBIa3Gs6WAXcWFs+ZzxG4IZDvd32PRXx8nzGAs60z3/b9llXdV9HDpwdIAmqHYKYGDeOd1e+QkJ5QIue5GwdrB+YOmMufz/2Jr70viTmJjN07lmErhxGVHPXA42NvpBGyW3YBuVSX6Niv5BsiFIVh20TISgDXatDi7Sd23gLceAb80XAnDC9VFuncbEPdM5QSDmUi/dTxfvNNAOxDQog7e7bwndRWMGip/GpozIBFz8vdLO5BkiT69+/PkQVHMKw3cNBvBVEOIWhUOt4N/BZuRbH3VCzBlTWoRfgw+E9613TG0VpNut7M5nO3GLfqHE2n7abnjwf5dnsIpx7Dyr57YdFVdMWoMDI/ej79VvQrsYVFgCruVfgq4CsqpY7BnFUZC2b2Zu6l2+puTN82Hb3p8R46hdG4QmNW9V7FK7VfQYGCM9lnCFwfyK8HfkUUC/+9slINbJ13HiQBB28lA98u3Uand5MQvBNN8EIAxG4z5OiGp8Xdi4ZPk3vcHcbbMfbPUko4lJUqfSY41rs3DldDSWvRnOZ//ln0joZMWNwfIo7KpR2HbQSPuvl2ubuv3VnjWT7fN4XeF9/BNdsToyKT5kPKIwkJqMd8gK0ejrf1Y+i8TQRFprI/JJ59VxM4F5Xfz+pgpaZNVVcC/MvRrpobbnYPn4VnNBuZvn066xLWYRbMqBQqRtYeyai6o0osq+/NedvYctNMLY/zpNtvIVWRKs9fdGC0/2hebP7iI7UGexD7r+xn0tFJJCnkqI9qimrM6DIDv7uKRZkMZtbNPEt8eAbOFWzo92GjJyYGotlE4tcNKGeKJMKxORX/V4hr7Ulh0sNXFeUF8bdOgWvVpzeXnBS5ljXAJ7GsnHuK+MsmKjWzpfuIxyt5UByKq2tllvQzgNurrwJge+Ik6VHRRe+otZXb3Xs1AX0qLOwDcRfz7VKvXj2OHTuGt7c3vSv3ZkSVYWyt/guZmhQ0oi1n1yXSsGFnzveSK741OhTG4a0LaeTjxHvP+bPhrdac/KQT3w2oR696FXCwUpOWY2LTuVt8sDKYJtN20evHQ3y3I4TT4clYxOI94zUqDZN6TGJD3w2082qHWTTz67lf6bq0K2tPr32k3+1e5KxDAUVOTXYP3c3Q8kPRiTrSFGl8E/oNPRb2YP+V/SVyrrtpV70d217cRg/HHigkBVfFqwzYPIDZe2YjiiKiKLLoq13Eh2egtVHR/Y26T9Rai1w/lXKmSPRocX7hKS0W5hJ1UhZo2/LgUuXpzkXnCJrbVSDToshIlVvJGcwl/+b1OJRZ0s8Aoihyqn177OLiyezdiybffHP/A/RpsDBQTgiwdoXhm6Fc9SJ3n7FjBpuu7aTPxbFoLVZoyxl4+ZOObOzfipqhmUSWU9Jy6yFsbRwLHGu2iARHpbIvJIF9IQmcjy5oZbet5kZANTfa+bvhavtgq1iSJHZF7GLK4SmkmFIAqKeux1ddv7pva60H8evWk3y5Px4vnZFDk+U49KTMJKbumMqe9D2IguyG6OnXk7ENx1Lepvwjn6sojl47yqcHP83rnF5NU42+Ka+Sdk6LhETbl32o2/LJiVNWfDjKuU3RoedmjTfxfWH6Ezt3oeydDvu/gtr9of8fT3cuAHOaQ8JlGLqWX+cbMCVpqdTGiu4vtij1U5dZ0v8gFAoF1oMGAaDesRNjVtb9D9A5wNA1cquh7ET4qxckhha5+7jnxtGlUgDb/f/AIpgxxGtZ+eMBWv6wkAwrAe94C1smv1LosSqlgkY+zrz/nD8b327NiU868u2AevSs64G9TkVajomNwTG8vzKYxlN30funQ8zcEcLp8JQirWxBEOjs05k1PdfQUtcSJAg2BdNnfR9m7Z5VpE/3QVRwlq2iDNOdxSgXWxe+f/57VnRZQUOd3GljU9gmeq7tyfRD00ssMSWXFlVasHXoVvq69EUhKdDHqUk9Jy9E+bTQPlGBBkha9iY69CSoKlCx3+dP9NyFkuuPftL1o4viLr+0aJKv12dt4bDMkn5GMOv1nGvdBqvMTOwnjMdz2LAHH5SdDH/1hrjzYOchW9QuRYdzfbHlC4IuhdHxmtxcwLuZBm9tELov5mBWQNjUUfR5/t3iz9kiEhR528q+Gs+F6Pyx147WatpWdSPA34221Yq2sndf3M2UE1PyfLpekhdT2k2hcaXGxZ4LwLmwW/T+9QxKREK/7FGo//li4kVmnJrB6bjTAOhEHQM9BzK2w9gS786y5/Bhzi1ORy1queh+iMS6F/i06afU9a774INLgNjjqym/dSQSkNB7KeUadn8i5y0SU85tf7QR3j5z32v1ibHxf3D6T2j3EXM21IccHQ2ed6Xlc6X/b1RmSf/DUOl0eLwm+6b1K1YiFceatHaGl9eBWw3IuCULdsrNInf/rPtn1PL35nhFucJexHEDdtUHElbLHZUIuu9/4+L1oOLPWamgsa8zH3TxZ9PbbTjxSUdm9K9Lj7oe2OlUpGab2BAcw3srZF92n58OMXPnVc5E5LeyO9bqyPaXttPftT9KUUmUEMUr+1/hp7M/YbAY7jOD/Pi4OwJgQUFSenah+9RyrcWfXf5kWpNpOIgO6BV6Ft5aSKdFnVh6fOkjW/H3kpyQxqVlskBn2yVy0m8TlzMv8/Kul/liyxeYzKYSOU+RWEw4HZkKQIRr+6cv0ACRJ2SBtquQr/nrU+WuMDzJIr+BWdk8mfK0xaVMpO+iqJeKJ/WyUe7FF1HY2mK8fp3MA4WngRfAxhWGbZBjX9OjYEEvSI0ocvcpvaZQsY4NF90PIyCw/Y/zVHl/HhlWAhUTJHZMGfXIAlLOTseAxt7MGdKQsxM7s/L1FoxpX5maHvZIEgRHpTF7dyjPzz1C46k7GbvsLGvPRpGUaUCr1jKpxySWdllKZaEyoiDyy7lf6LehH8dvFZ3AczcONlZYqeUbLUVfdCy2IAj0rtmbXS/tYoj7ELSilhRFCl9e+ZJei3px6Orjpc2bzRZWfHsYwaRFUht5ZVwX/uq0gIpUxKKwsDJhJd3/7s6pG0XHuz82x35GmxaGZOWM+4tzS+88D8Pdro6nGR99N3cntFhkObS2fXqdeQqjTKRvExwcTPPmzYmMzJ8VFxkZSfPmzQkODi71OShtbXEcOJD/s3fW4VFc3x9+Zz3uLiQBEjw4lOLuTrEiNShQpC1VaKmXFgqlSIGWClKKu7u7BIeEECHuvjrz+2PTACVAEhKS/r68z5OHsHPn3jub3TN3zj3ncwCi5s57Quv7sHY1h+M5VjaXA/qzB2Q8Okrkqx5fUaOnAxEOV8AksHdVFAn9ze6VDqeymDF39FNdB5hX2Y38HHmvUzW2T2zB6Y/b8X3/OnSt7Y6NRkFaroFNF2N5e1UIDb/eS6/5x5i95xZaoztrh67nh1Y/4GLhQmRmJK/vfp1hfw0rUrKIh525kkvKQwVxH0aj1PBR54/Y0W8HbazaIJNkRBHFmONjeHfPuyTkJDyxj8I4vu42pgwNkmCi4xvVcXS1o4ZXDbYM28JIz5EoRAXxQjyvHXqNKZunlH4cd8ZdODgdAKHjl2gcPEu3/5LyTz3D8o6Pvp/7Y6VFszm0snlupCsckiQxatQoTp8+TevWrQsMdXR0NK1bt+b06dOMGjXqmayorQe+hCgIyK5eJfpQMcLFbNzNhtrBz+zy+LM7ZMY9svm4+uPw7CWRaBUFOgWh8dW4VaMycgkarjvBzjOlK8vpaqvhpYY+LBjagPOfdGD16BcY27oy1f9ZZUenM2dfKH0WHKfxN/vYftKFUQEL6enXDyS4aLhIr029mLNvzmNdEv/EcBcna9LF1oWf+v/E3x3/ppaiFgiwO3Y33Td0Z96FeeTon7CRex9Xj8Rw+YD5ZtLxtVoE1qlUcEwmk/Fuh3dZ1XlVwdPC5rTNdFvRjesp14s8xpOI++MVMOQg+TSF4CGl1u9Toc+9lylbnnod/yZ/JW3KiC+o7+noYl+OE3qY50Ya8+Pv2rVrCQgIIDw8nKGtW3Pixx9p16YN4eHhBAQEsHbt2mciI2lVqRJZdcybFjELfi7eyXZeMGIr2PtCarh5RZ1V+GpQEAQmNZlAar0QMtXJqA02hPmMIN3aAp9kuDL3U5Izk5/2cgpFKZfR2N+R9ztXY8fEFpz6uB3f98tfZasVpObo2Xgxlg/XhvLXzka4Zr6DxuCKXqbn17u/0m1pN85HnC+0bxul2YDfii7+Kri6Z3VWDl3J0k5LqedaD61Jy6JLi2izog0/7PnhiW6gkOOhHFppFu9v0jOAwIaFF9MN9Ahk/cvredP3TVSiikQhkSHbhjDvwjz0pqcTh4o5+AceaacREchs8emzL0v1KKJPmjXSbb3NC4mKgo0HCDIMRnnBSxWpUjg8N9IF+Pj4cPDgQaoHBPC1IMN+4SIWOTjQvVYtDh48iI/PsxFjB/AaOwYAm0uXSL11q3gn2/uYDbWtN6SEwtKekJPM5cuXCQwM5PLlywVNBUFgzpAfuFv7BFpFDhqdE6ebjEMUZHQ5o+PbBa+U2kba43Cz1fBSo/xV9qcdWDWqKWNaV6aauw2SBLdjXUkKm4g2oSuSqOSucJeRB19h4trJ5OgeXOVKueY47rASGOl/qOdejz87/8ms1rNwVjiTJ8vjj9g/aL+s/QMSpfe/p3fDEziyPBxJlPCpbUeDLpUeM4J5VT2uzTg29NxAO992GCUjiy4tou+Gvuy/VjzBpn8w5GZiffgzAKI8umEX+GKJ+ikT/nF1VCR/NJhlgW080YvmclkKpQx5BarKAs+N9AP4+PiwbPgInBXmbDD3rGy+M4mo161D1BU9yuCp59GqFZmVfM11EH+cU/wOHCrByC3mXfSkG7C0F99/9iGhoaF8+umnDzSVyWTMffUHwqsfwigYUJj8OdHoZQQJumwOY+mxX0rpqoqGUi6jSYATH3Suxs5JLTn5UTu+61ebzjW9UOe0JSf8bYzZQUiCyP6cXTRf0ZMPtq0nJDodUZQK3B3JOU8XPfFPLPeOATsY6DIQlagiVZbKl9e+pMefPTgRdoJPPvmE0NBQvvzsazb9dB5BVIKFlg4jaxb5qcvXyZcf2/zID61+wFHjSGROJBNPT2T82vHF1uK+u2oydmIa2YINHoN/Kslllx0VQT/6Udh5o5fMexmSrHTEv0qT50b6PqJu3yb3r78AWJSZwTGTCUEUSVm4iDu9+xCzd+8zm4t9fpy0xZEj5KWUIOHCMcDso7Z2g4QrvO18CHsNbNy48aFNUJlMxk9jviOs6iEkRHSWTbhZpSNeqZC6ZAHRT1kX8Wlwt9MwsJEvC4c14MKnHVj5SleG+3+BddpwRKMNRnki25OnMXD9RBp8u5G/r5t90bE5pbN/oFFpmNp1Ktv6bKOlZUtkkowIIhh1dBQJdRNQu6qpadcBtGokuYE+kxphYVX8jaeOfh1Z1XkVdRR1QICDOQfpsrIL20K2Fen8tNtn8Ylca/69yQeobZ+RPnVR0GWbs2OhYm0a/oO9T4GRNkqlq0VeGpTISM+fPx8/Pz80Gg1NmjTh9OnTj22fnp7OuHHj8PDwQK1WExgYyPbt20s04bIiOjqa6Z064ywIpEgSL61cybeiiYkxMaRKEvo7d8h8azwnX32tZEazmFQdOJAcBwdzHcS5c0vWiXMVGLGFdIOS+h5y7kx246/XqvHHD1MeaiqXyZk98Qtu+54AINa7F/GuDel0Us/sJaMxiGUc11sElHIZTQOc+KhrDU5Meo9NvTbRwKEbIKC0P4/efToKu7OARJxWQd8Fx/hpXyiX7ppX2U+Du7078wfMZ3m75VSXVwcBsv2zGfzWBJxV/oiYeHFoJTwruZR8DDt3VgxdwYdBH2IpWpIhz+DDix8yetVo0nPSH3meJIrkrXsLBSZiLarj3XFciedQJkSfBNFo3itxeLwbqFyw80Yvmd0dsgpWlQVKYKRXrVrFO++8w7Rp0zh//jzBwcF06tSJxMTEQtvr9Xo6dOhAREQEa9eu5ebNm/zyyy94eXk99eRLC0mSeKlfP3rn+189xo6hWatWHDx4kNuuLnQNC+WiizMAdsePc71jJ26uWFGmc5LJ5Sj79wNAuWs3kqFkRvJiTB7Nf0kjIU+GvTyPwd6xzA44QvyXNYlY+wl5afciQBRyBd+//yGxXlcAuFZ9GBn2Vem++g5fbpn69BdVylRxduGPntNZ3nUZbjJ3ZIpcLDzXYuH7C4IqifNR6czac4ue847R+Ju9vLP6IptDYknPLflqqbZPbT6u9THZi7OpfKMuDWM6A3Cw8kreiRjDr5d/JSXv6W7iQ5sOZWu/rTRQNQDguPY4XVZ3Yf8jal2mHP0dz9zrGJFj0X8eQkXZLPyHiuzqALDzxiCaV9KyiqVSCpQgLbxJkyY0atSIeflVrkVRxMfHh/Hjx/Phhx8+1H7hwoXMmDGDGzduoFSWbNf0WaSFX547F8X8BQj2dgTu34/M0vxHi46Opn///ixevBir8HAyvp2OZaY5/TmjTm1q/PADtmW0qajPyeFOh46Iqal4zpyJXfduxe6jd+/ebNu2DaVMYnQrH4bVURBslYRcMP/ZjciJs6mLbcvR2NXvB3IFBqOBWd+twjraE5kxl4YXZnGoejxBk7+jR90epX2ZpYLWoOXbXd+yKWkTJpkJSZQTJLTDXujHyduZ5Ojv+RplAtTzdaB1oAttqrlSw8MWmazom1m9e/fm4skbvNvrJ2SCgquqIxwMWoXc2hwhoJAp6FipI4OqDaKuS92nigpad3YdMy/NJFueDUC/qv14t+G72KhszA10WTCvMWTFElN1GF5DixFf/6z4pR3EnIXeC6Hu4PKezcPc2s3VXxdzMHMsSicdo77u8kyGLapdK5aR1uv1WFpasnbtWnr37l3w+ogRI0hPT2fTpk0PndO1a1ccHR2xtLRk06ZNuLi4MGTIED744APkcvlD7QF0Oh26+zbqMjMz8fHxKTMjLYki4d17oA8Px+Xtt3EePerB45JU8EXTZWYS8tFHWO8/gCBJ6NVqVG+Optqbb5ZJiF7SggUk/zQXTc2a+K1dU6wxLl68SL169R563d/FikntPBlcHVzE+6IgrFygzkAMNQdgdKnOvC83Y5nshFqbSv3zM5ndz8CMidtwty999bjS4kr0FQZsnobC2hwVYyfa8W6d93CzfzFfyS+RWwnZD5zjbK2mVaALbaq50KKKC3b/CsG6fPky/fr1Y926dZhMJlo2a8t7febjaONGXHYo0/9+C1Fmwq6xHa0mtuJ27r2CBlUdqjIoaBDdArphpbQq0TWl56Qz58Ic1t42+5xdLFx4o9IbDG4yGHZNgRPzzGFtY0+aC0RUJHRZML0SSCaYdOVeGnZFIuEaF2ZO53jWSCw89bz6aednMmyZGOnY2Fi8vLw4fvw4L7xwT8rv/fff59ChQ5w69XD6brVq1YiIiGDo0KGMHTuWsLAwxo4dy4QJE5g2bVqh43z22Wd8/vnDil1lZaQzd+4iZtIkZLa2VNm/D7m19RPPiT54kPipn2CdbI4ltmreHPfPPkPlXbpuHGNaGmFt2iJptdj+NAevjh2LfG7v3r0LvXH+Q69evfj1q4noz/yJZ9IRs6JePskKT+K8erD9YkOsdc5YZ9/FK3w2S17zZ8Ura8tEPL+0aPjlDtJlF7Hz2Ihebtbw6FW5F+82fBcHjQMx6XkcupnEgZuJHA9LfmiVXd/XgdZBLrQOMq+y+/btw6ZNm8wLE0mGP62o7F6L+LQoftj4Fnn3Jbv06tWLr5d8zeqbq9kevh2tybyRaaW0okdADwYGDaSKQ8mU8M4lnOPTY58SlWVO+68n+TMn+jgOJgMMXQtVO5TwHStDbu2GvwaYbyITyz5rt0RoMzk15X3O5ryEXSUdL3/0H15Jl8RIBwYGotVquXPnTsHKedasWcyYMYO4uMIz4p7lSlqSJO706Yvuxg2cx47FZULRa78ZtVrCfpgFq1Yh6fUIlpZoXn0Fn9GjkZfQtVMYIWPGojpwgIzAqjTdXPRMwDp16jwQF/1vateuzaVLl8z/MRkgbC/ihRWIN7ajwGy4EkzurEz9HqXJBofU68Qrf4aRr/JOh3ee6prKkl7zjxESnc6M/gEciJrL0ayjSEjYq+15q/ZbDKg+oOAmozeKnI1I5cDNRA7eTCI08cFVtoNGRvSZXeRe2U9e1GU+ffVnXJWB5OqymblhHIkZD6aq3/+eZugy2Hx7M6tvriYiM6KgTQO3BgwKGkQ733Yoi1maOs+QxwebPuBA9gEQwNFk4i2dEwPGHCnBO/UM2P0JHP8J6g2DXhXQFZPPoXff40pOF9wrZ9DvvT7PZMwyUcFzdnZGLpeTkPBgokBCQgLu7oU/Ant4eBAYGPiAa6N69erEx8ej1xe+gaNWq7G1tX3gp6zIPnQI3Y0bCJaWOAx7uVjnKjQaqk35GP9NG7Fs2BApN5e8efM517ETsSdPltoc3Ue9gQTY3Qol/ty5Ip936dIlJEl65E+BgQZzHfugLsgGLccw4TKRNceTqPTBTR5PP/svkNCR5lidSjlDOH18CefvFH0ezxqXfElUndGSBX0XsLTLUqo6VCVdl85XZ7+i+7LuXIg014hUKWQ0q+LMlG412PNOK45+0IaveteifXU3LFVy0rQi1rU74DroG15/5SdclYFISHR8vSYJ6dGPfU/t1HYMqzGMzb0380vHX2jv2x65IOdcwjneO/weHdZ2YO6FucTnxBf52iyUFvzU/ye+UbSgil5PqlzOF5bpDFg2gMgyqpL+VBSIKrUs33k8AaPKFQAft5K5pMqSYhlplUpFgwYN2LdvX8Froiiyb9++B1bW9/Piiy8SFhb2QObarVu38PDwQKUqx2KYmFfRyT+bU68dBg9C4eBQon7U/v74Lv0T2dixGJRKbOLiSHv1Nc688y763MIlM4uDW716ZAYFARDxUwnD8YqBhaMXlQZ8heuUK6QO3onJvxYtHOaCJBLv3pS+57swes8I8g5+T1bMzTKfT3GxUZifAm5FmY1fXde6rOq+ipEBI5GLcqKJZuSBkXy46UNydQ/+fbwdLHm5aSV+HdGQP3u5kfD3FCxTbuJnlFNHVQMA28A8gl8suhayIAg09WjK7Daz2dlvJ28Gv4mLhQsp2hQWX1pMp3WdmLB/AsdjjiNKT87wzE25S7uw9ayKiaen1h1BErgh3qDvlr78fur3Z6ba+ES0GRCX7+KoiPHR92GQm7/7FmQ8oeWzp9iOxXfeeYdffvmFP//8k+vXrzNmzBhycnJ45ZVXABg+fDgfffRRQfsxY8aQmprKxIkTuXXrFtu2beObb75h3Ljyj+XMPXkSbcglBJUKp5Ejn6ovQSYjaMJ4fDasJyMoCJkoYr19O5fatSdi586nnqvbqDcAsD5zhszoZ5dc4hj0An6v/0ntLzfh5W/ejEvy6Mqwo02YcGMxVr80Ifa7pkRt+wFDbsX4gEt5+anhMUkFryllSt5t8S4rOqzAX/BHFES2pW+j01+d2BqytdB+vv7yc4wxVzHt/YNeuUpkCFxRGVh9vYgysoXgbuXOuLrj2NV/Fz+0+oHG7o0RJZED0QcYvXc0PTb04M+rf5Khe/R7mbTyLSzJI1vuyhevbGFBswW4iC7oZXpm3ZjFuH3jirU6LzMiT4AkmtUZbSuIEt8j0GOOllEZy0av5mkotpEeOHAgM2fO5NNPP6Vu3bpcvHiRnTt34ubmBkBUVNQDvmYfHx927drFmTNnqFOnDhMmTGDixImFhus9a5IXLgLAfsAAFC4lT0K4H4cqVWi8YT3iu++g02iwSksjd9LbnHrjDYzZ2U/u4BFU6tKFLHd35KLIzZKkij8lMoWS3h+OxcnF7OpSWAxCGVmX5bbWeOZdx/fMF4jfVyFybk/iT60vWtGCMsLN1hzhkJb3sFxpTe+abHx5IxP8J6ARNaTL0vno4keMWDmC5Jx7X9CLFy+yadMmrC3sGN3pS1SSjCS5jt0WRq47tWDu6t1PNUelTElHv44s6bSETb02MaTaEKyV1kRlRTHz7EzarWnH1KNTuZJ85YHzEs9vwzf5AAD6jtORqzQ0D2zO9pe383rg6yhlSo7EHKHPpj4sOLrgmWivPJJ/XB0VfBUNkKnNd8fmPFkO91nzP1s+K/f8BSKHDAGlkiq7dqL0LP07fXZ8PFfenYxdvh9Z4eGBx2fTsG7VqkT9XV38C7JZs9BpNFQ/chi1jU1pTrdISJLE+gnLiDd4IzPp2FRzDqMsLWkXfw47Mb2gXYbMAesX30Bef+gzVz37Y895PtsXh4daz4nPH70JlJSZxEfbP+KUzrzh7aB2YHKjyfQI6EGfPn3YsmUrn7/yGw4KbwxCHt+vH4fbwI9Is/RGgYk5farSrUn1Upt3riGX7Xe2s+rmKm6k3ih4vaZTTQYGDaSjT1tyZzbFxRhLlMOL+E58OGs3PD2cT45/wqUks2/cF1++b/c9Nb1rlto8i8yilmZ3R78lULv/sx+/GCyesAGD3o6ulZfh/97vz2TM5+WznkDyooUA2PXqWSYGGsDa3Z2mK5aj/OZrFF5eGOPiiB79JncmTCDzbvHv2NVGjiDPxhq1VkvcXyvLYMZPRhAEOk/rjm1mKKJcTfdro5kppXB72HriOi8h0rEFOlTYiWnIj3wPc4Lh924k7JqFLrPs0+kBvJ3MN6/7C9IWhoutC78O+pWZDWbib+NPmi6NKUen8OrOV4nXxdOr8es4KLwRMfHHgS+JS4zkyuK3sdfGY0TOOxvDCIlOK7V5Wyot6R/Yn9XdV7OsyzK6B3RHKVNyNeUqnx7/lA5r2vK7bS43FVY4DSq82kqAfQBLOy9lsPtg5KKcKKIYumcoX+/4GpP4DMWD8tIgLn8T9T+wkjaazPtjGv2ji2WUF/+TRjrv6lVyDh0GmQznN94o8/Gq9O1L5S2bcRw5EmQytLv3cKdbdy7Pn1+sx1G5SoVzvu/ftGFDubkUrJwdaTzAC6vsGASZHX0ujeKN/WNI9gqi0oStCJNvEdNkGqeSLZEQIPIobic+R5gVRNSczsQd/QuxDGv8+brYAZAjKjCZnvwedarViXW91zGx/kTUcjVnE8/i3bYW7YLNVXLaDq/GxRsnkSQJgzaXw18PpbKNhE6SMfy3M1yLzXzCCMVDEATqutbl2xbfsnfAXt5u8DZelu5kiXqW2dnS38eJt0O+YV/kPoziwy4duUzOx50+Zmn7pXhL3phkJv5O/JuuS7sWRLWUOZHHAQmcqpoLUlRwRNEcCmmhi4FneTMrAv+TRjol3xdt27UrqkrPRvBFZmmJ24cf4PrbErKdnFDpdCjmzuN0z54kXy96VQ6v4SOQ2digj4gg+2AxKreUMkF9uuOnPo1al4alyYOu11/n5b3DuB57nYS0bFq+NZ+m8+PpeSCA9IYTSZM7o8KAb9oJPPaOIefrACKWvEJa6OPFuUqCj6t5p15CIDalaJuZSpmS12u/zvoe6wnObErLcLOBvuJ1kAirSw+0tbXSsGlyZ+r52pORZ2DYklPciE0v1Wv4B0eNI6/WepWtgi/z4xNpZVIiIHAi7gSTDk6i07pOLAxZSFJu0kPn1vGpw9bhWxnmPgyFqCBWiGXkgZF8uevLQo17qXK/fnQFRzSJCJJZtEMlZUFWBdh0vY//OSN9eft2svbsAXgo/ftZ4NS0KfX27iWnVy9MMhl2YbeJG/AS57/6ClMRRJTk1lY4DDQbkNify7fA6Auzv6Zq+J/IjXm4Z1ehbdjLDN8xgq4DuxZUtFmwfBP23b/AfkooiT3/IsKlHVo02EiZ+EWvx2FFB3LnvghnlpgfkUsBC7USjWA2QpGJ6cU6V5lhSZMb/ZFLCiIdrnDUZyMfXvyQkStHEpd+b0PcWq3gj1caU9PTlpQcPf3mHeLi7bJ5VI47vgrFlbW0yNMxr/MSdvTbwWu1XsNB7UBibiLzL86n49qOvHvwXc7En3kgBE8uk/N+p/dZ2Wkl/pijWlbHr2bo9qHcSitmQYnicOe/s2mYk51X8LtKlmuud1iB+N8z0p99BsAVG2vUVauWyxwUFhoafjcd52VLyfT2RmE0YrF8BWc7dSb9MRmC/2A7ZAiiTIZ4+QpRBw48gxkXjtrWFt8Px1Dryi8IookqKfWpe7cDFiMsqNmk5gMVbQSZDNf63fAbtx7Fh7eJbvoVMVa1EBGwTLkC296BmUFk/96fmAO/IRqfTtfXw94skKWXFV3bOS9Hy/rZp5GZlKDRMmZcLxprGgFwTn+OHht68MfpPwqMoJ2Fkj9faYSL0kCOqGDYkjNciyzdVZhJn4dm38cARLp2AM96eFl7ManBJPYO2Mv0FtOp51oPo2Rkd+RuXt31Kr039eav63+Rpb9XNKCaZzU2DtvIpGqTsFHZcC3lGgO3DuS7I9+h1ZdyIdzcVEjIj0qpqMp395GdYTbSAkbkGMyVwysQ/1NG+uLOndTJMPsPP7t8+ZlUAH8c7g0a0GjXTrQjhmNQKLCNjSVu8BCS5s1HekQ2JoDG05Os4GAAYn8uZh3EUsa/SxdU9TyodnM5AHXj2hGQ1hC38W5YOBcu9qPQWOPTeTxe7x3DMP4SdPwaXGuCSYd15B68Dr1N3td+RCwaSsq1krl0vJ3Nu+WpeUXzL4qiyIrvD0CeBklmoNeEBvh7V2LJoCXMqDcDB9EBnUzHD9d/4I09bxCZac7uc7bRsGZcSxwUerJEJYMXnyQ05mHXQ0mJWvU+DqZkcgQr3Ic8mFatkqvoFtCNpV2WsrbHWgYEDsBCYUF4Rjjfnv6Wdmva8fmJz7mZak44kslkvNbkNTb22kgbnzYYRSPLw5fTaUUnDt0oRddZ5DFAApdq5kr2FZycLLORlst05spez410+bH3m2+RCwKpKhW3TCY+y19VlycyuZx6H32E9/p1qJo1A6OR5HnzCO/bl8h8t0xheI8bC4DN5SvF8mmXBW7vvIMp/hQB4WZdkeYRfbFMdGP41uFP1FZWO/lCs7dgzDHENw4R4d6FHCyxknLwi9uK0+qeJH1VnYi/PyAnKarIcypu1fD1iw6jS1AjIfLCIF+8A9wKjnWu05ndQ3fzatVXUcvVnIo7Rd9Nffl89+fk6fPwc3dk1ZvNsZUbyDApGfjzUaISn951kxl5Ge/b5kpBKQ3eRmPv9si2QY5BfPrCp+wbsI+Pm3xMZbvK5BnzWHtrLf239GfY9mFsDd+K3qTH1dKVOW3m8F6191CLalJlqYw/OZ5J6yY9VDOyRPyHXB0AVhpzNJCFJt8cPnd3lA8XL17kt6tXMclkOOr1DKtSpdBSUuWFY2AgAUt+xfOHmcgdHdGH3SZn/AROjRqNNj39ofbezZuT6e+HTJK4PefZJ7f8Q3R0NG07d2ZyVCTekTvxjD2KgIz2t4ajS5AxeMNg4tIKF9J6AEFA5lUXvzf/RvPxHe62mMldm/qYkOFijMXvxkIs5gfDysFwbTM8wR1iLTevoEOLUJD2yLYLJISYo0ACWljRoOXDsc8alYa3m73Nhp4baObZDL2oZ23cWjqt6MS2kG0Eeruw8o2mWMsMpBpV9Jt7kLjUp4v6yFwzDiVG4tVV8On6bpHOsVHZMLjaYDb02sBvnX6jk18nFIKCi0kX+ejIR7Rf057Z52YTkx3D8CbD2dhrI7UUtZAEiX3Z++i8ojO7rux6qnkXbBr+B1wdAAad+bOi0uQntKQ/X0mXC5999hmhmRnstDQ/go9Ra7C3sKgQq+l/EAQBu27dCNi6lYz69REA28OHuda+A7dWrX6ovUN+KrvF0WPkJJbeI3ZRkSSJ/v37Ex4eTranJ8r+/QgMXYV92lUUkoouN0aRm2lkyMYhJGQUvXq3XKXBu90beL97AN34y0TUeItEpQ8yRLi5HVYPQ5xZlYgFA0i8uLPwUMQ8s4EMj318mm9SdCaXtpnb2Pob6Tq0cA2af/Cx9WFh+4VMrDwRjaghTZZWsLHoZA/LXm2IpcxIkkHFkEXHyNSWLNTw7r5f8M4OwYQMVd+5xa62IggCjdwbMbPVTHb3381bdd/CzdKNNF0av135ja7ruzJu3zjCc8NZPng571V9DwvRgnR5OpPPTmbsmrHk6Euwqs5JhsSr5t//Iytpfb5LTGWRr0j4fCX97PknxddoNPLF5ctkWWiw1mr5pEbNCrWa/geFowNN/1qB/PPPybO2xiI7G9O0aZwcPISs2NiCdlUGDCDb0RGl0ciNuc++OrQgCCxevJjGjRtz8OBBAj7+mDx7O+pcWYJSH4uF0Zqu10eTbdIyeP1gkjOLr4tg6eSN30tf4zrlCtLYk/DiRLDxQKZNxy9xN64bB5L2dRB3lk8iK/ZetIJ7/sZhmvbRcdJ52Xp2LLwCohwLF5GBb7cp8nW/3vx1tvbdSiP1gxuLJ+5u5tehwVgr4U6GyCu/nyFHV8xwN30uDie/BSDauyeOQc2Kd/6/cLF0YXTwaHb228mPbX6kmWczJCQO3z3MuH3j6LahGwYbA0u7LaWeqh4IcCT3CP239OdU3MPyw48l8pj5X9caYOX8VPN+VsTdNW/26qT8v9NzI/3suX+1nKXX87PW7KfsmJtLLWfnRxYfKG8CB75Ejb17yGzZ0ixVeuECt7t2I+wPc4SBTCZDPcCcbqt4ijqIT0NwcDAnT57Ex8cHlZUVrl99iUzU0/jsXCQysdO50OXGG6RJ6QxaP4iU7JJnHQqu1aHDF/D2VRI7LiTKrgkGFDiaEvEP+x2rxY2J/b4pUdtn4WVrjnvN1BeedWgyiexcdIWsFC22LhYM+aAVKlXxtJ3d7Nz4bdBvfF/vexxEB7QyLT9H/sz3Fycxe3glbDUKzkWm8fqfZ8jKLUYExZGZWBlS0Fu44jnox2LN6XEoZAra+bZjUYdFbO2zleE1hmOrsiUmO4Yfz//IkF1D8PL2YqDvQNwt3bmbfZfXd7/O1ENTSc4q4g22otczLITU/Fj6PFO+kdZlmBX8Kgj/E0Y6PDz8gf//ceMGd2xtkYsiXwUEPHS8IqGxt6fJ4kVY/TSHHCdH1FothunfcXfMWAxxcVQbPRocHVBlZpJZCmp7JeH+kl6+7dqR07EDan0m9S/+jEmmwy3bj3ahw0kkkUFrBz228nWRkMlxbTYY37d3Y5p0ncjgycSrA5Ah4Zl7Hd/Tn9PtSE++VfxCNTEUCpGn+WvGPmJD01Fq5HQbUweNdcmLNHSp04XdQ3fT06EncknObeNtPjw5gn5tb2CtljgRnkrfWTvJ0RYhrDDpFhwzPxWpes5GZV0y+dwnUcm2Eu81eo+9A/byRbMvqOVUC4NoYGv4VlZFrUIhU6CWmzdfN0Vsovua7qw6verJHf+HRJX+QZ8vxCVXK8DC0fxiBVpN/88KLMWfO0fKy8OQSRK2M77Hq0fFLLB6P8Y8LVE//ojur7/AYEBmZYVs5AjsZXKS585FXb06/uvXlUmtxeKgz80lpENHrFNSiKzdhlDnPsgkOVfcDnPUfx2egifrBq3DWv3kMmXFIT38POkHf8Yt4QAWuns++kyFC6neHXBsMxbbSrXZuvQYkcd1SEi0eNmP4OZF14Z+EjcSbjArZBYn4k4A4ChzJy68B/q8ytSwNbB+cjc0j1ixS6JI1oK22CZfgKqdYMgqeIZ/yyvJV1h1cxU77uxAZ9IV2qausi4zus7Azc7t4c9ZdhLMrAII8H44WDqW/aRLgRU/7CU9VIZDVZEhVp9D/CUYshoCO5XpuM8Flp6Ae4MGiN26ApA3bx7iY+KSKwoKCw0BH31IwIb1WNSti5iTg3H+AqL+Modp6a5fJ2Hv3nKeJagsLXH/5mtEQaDS5QP4OYcjIVEroSXBsW2JJZax+8eiNZZuEoV9QH38Xv0Fiw9uwYitrDW2IEdSY2tMwi/iL2x/b07IJ/2JPG4W+vespyhVAw1Qza0aizosYnqL6TioHUgV41H7/YKF+1quZRsYNHs7BmPhsdvRO3/ENvkCRhSInac/UwMNUMu5Fl+++CX7BuxjcsPJ+Nr4PtTmouEiPdb3oP2Y9kT/S9c8+dxGAPLsKv9nDDSAMT+6Q6mRg11+odwKFCv9P2ukAWp89hkKFxcMkVGk/v5HeU+nyKirVKHSiuWYXhmJUaHAMuWenzdy1uxynNk9fFq1IreLuaBn1V2/4VPL/EV4IaoXVZLrcyHxAm/uffORK7anQiYD/xZ8Jb1OQ93P7PMaT5xFIOlGN84kDwPkVNEcpkHedNLObYBSFqoSBIFuAd1Y3Xl1wcaiwuEs1pV/4IrpMoN/3PqQ8JM2PRHHMz8AcNd/EDKngFKdU3GwU9sxouYItvTZwqIOi2jr0xaZcM9UaOVaEl9IZOjfQzl/4zxgDsXctXAqAJtCUipOdZgiYNCZ/xYqCwXYeZtfrEBheP/TRlpubY3re5MBSPr5Z9JCQ8t5RkVHkMup9cEHeK5bS0aVe6tB2zt3uDqvYhT8rPf116iCgpAyM2lwcwv+Dc3qdG3ChuKRUZlzCecYvGZw6acl5+PjYkseGjLrj8L6zYP8lfkDOskGR2U47ezmUyn9OA5bRsKPtWHfF4hJpatl4W7v/sDGoqDIwcJrFVct/mTAT388oIAYv3I81lI26TInvAd+X6rzKCkyQUYzz2bMaTuHXf12MarOKJw0TgXH01zTGH5gOD/u+pHWrVtT39Ecstfu9c/L3eVWHEx68w1FbaEE+39W0hXHJ/0/baQBbHv0wBgYCFotNz/+uLynU2ycgoJovHkzpvuqnMvmzefcW28hlkJ9xadBYaHB67vpoFCQtWcvjZ3vElDPBbmkoPPN13HIdSNUF8pLq15Cayh9Q+3rYg9Aaq6Bld8fRtJbIckNtJ7ck5QevxHt1h5JbQuZd+HID8jmNyLxmzpErJtGXlrpaXD8s7HYw6EHgihHYR3KLfu5DPjrM/RGPUmX9+GbYE4gyWv7FQpNxSuG6m7lzvh649nTfw8zWs2gmlU1AARLgSXxS9DbJFDdRY6EgEuDnuU82+Ih5gdFaaxU91bSz410xUEQBBzeew9JELC7fIWwjRvLe0rFRiaTUWvsWGRT7t1kLPfuI7xnL7KPHSvHmYGmWjWcxrwJQMy0aTRqY4mrnw1qkyVdr7+Jpd6WO+IdBv49EP1Tiir9m39SwzNPJ2NIMad8txoegEclV9wa9sBnzDqEyaHQ/3ekqh0REXDVR+J3+UeUc2oQPasdMQd+f2qxJzBnLH7T8xuWt1+Kna4SgszILdMG2v7di0u7JiFDItquMR7Nhzz1WGWJUq6ks19n1vRfwzTfaaTsTSH7ajaNLczuLMG9NliUTURKWWFna/af+1Tyeu6Trqh4t2hOZn6187QZMzFqy+bxu6wJGjaMLA+Pgv8b7t4l+rXXCR0/gez48tPIdXztNbJcXVHpdIRNfoc2r1RBUumw0TvS9fpolCY14WI4A/8eiKEUiwFYyU1U08tRhZofw5sPCqB2k38pHyo1UKsvwtA15I05T0Tg66Qo3FBgwifzLF6HJpH7tT/RS0ZAwtWnnlMdnzocfn0zXd3eRjRakWG6yyQX+NTJGVP3L5+6/2dFdHQ0H7z+AXHL44iYEUHH/LyVLOd65TuxEmDM90lb2WruGemsODA9+7yDwnhupPOp9c3X6NVqrFNSuPR9xfAJlgTrl4cCYJLJsO3bBwQB4549hHXuwtXFv5RLYVKFRoP3d9MRZTLsbt0ibvVyek2shyQ34JzrTcebryATZYSZwhi8ajBGU+kI0osxyXTONYe71e/kS93Wj9+Ms3ILwG/IDzh+fIOkvuuIcO9CLpZYS9n4RG+En5vBwhZIJxYUS+zp38hkMr7r/CoTfKbTPdO8INhga8mAo+NZdGhR+RaPLQLR0dG0bt26QDP82LFjdKxqloR9Z+76h6I+Kjp6rfnzptIowMoF5CpzlfOsImjOPAOeG+l8rN3dkV5+GQDFmrVkREaW84xKRtDw4eTmJ+rkuHtgN38eOQ4OqLVaZLNmcbpPX9LCwp75vDxfeIG8nmZfpfjLr1hL2bQeWRlJMOGTUZ2W4QNBgpvGmwxdMxRRejpDlRCTgjrEgBKBaJWBJr2KHmonyGS41GmP35t/o/44nJgWM9AFdASZEuIvIez6CM38YO7ObMndPT9j0uc9udNCGJ23hm9TEvksBkSdC1qZlnkR8+i1rBdX7l55cgflwP16LQEBARw8eJBmtfzwtxUxibDmVAz9+/f/z0R3iKKILte8YhbkojkyyNbLfLCC+KWfG+n7qD1pIllurigNBq5PmVLe0ykRcqUSu/zVtGzbVjxataLOvr1kd+tqXsnevEl0n75c/O47RNOzreVW74vPyXJzQ6XXc3PS29RoEEC9Xq5ISFRLakqDu50BuKa7xjsH3ynxF12bp2fdrFMoTUqSZSLbLbXIZCWLNpCrLPBqNwr18DXw7k3oMoMs68rIEfHODsH72IfovvEnYsEAkkJ2F7nupDH8KFwwa3DfsX6dnDsT0SV2QBDlRBDBy3tfZuqWqWUW+VJS/q3X4uPjU6B6Z3KtQVBwYxYvXly06I7QUDh//sk/ZRh1pcvTg2Seq0Kdbw4rWBjecyN9H3KlErd842x39hx5Fy+W74RKSMBrryGzs8MQGUX2gQOoLC1p9MMPOPy2hCwPD5QGA+rf/+BM5y7kPsNVtVylwmfGjPyyYWFcmTOHFzsH4/+iWZmw0d0uBCU2AWBf1D7ePfRusQ21KIr8NWM/Uo4GUWZkg5WeTBRo9aXgX7RygiajsJl8ntRB24nw6kW2YI0lefgl7sZlwwDSvg5Ct+87yHz0o7Jo0JHx12sAGGsP4Z23xtPWU4k+pR1Z4ZOw1/tiEkxsSt1E7/W9uZD4jIrHFpH79VqAglRwVWA7Tp48SXB+QYrHEhoKgYHQoMGTfwIDy8xQZ2ean4IkJKys84tU2Ocn8VSQzcPnRvpfVOrYEZvevQCI//IrpGe82iwNZFZWOAwcCEDCL78WvO7ZtCkNdu8ib8hgjAo5ttHRRPXtR/Kixc9MnMmjcSN0ffsAoFi6DENcHN2GNcOtllnLt+2dIXinm8O79kTuYcSaEcXy0W5acpS8WBUSEo36eZIhN58bnZReqtfhWO1F/N5YiuWUO8S2nUu0XeMCsSf1kW9gdg1Y3o/Uw79gyH1QVzpq7RScjPHkYYG+1cfIZDJ+HdeZF90lJIMLd2+/SVMGYoEFMboYhu8YzucnPiejAon+PLBSLhBValn0+OisrCe3eZr2RSQn30gjmJDJ/7WSfu7uqLi4T56MzNoa7dWrpK9bV97TeYjLly8TGBjI5cfUQ7QfOgRRLscQEvJAhRe5Ukn9Tz/FY/UaLF54AUmvJ2n2bML69ntm9RLrTpuGomZNhLw84qZ+giRJ9BvbksDGbkgi9A4fi1OO2S94Ie8CI9eOLJKhPr7rEjHnzDebSk3UNG1XC0uZeVMoKrFsDJxMocKz5XB83t6DadJ10lt+AT5NzRtPYXtx3D8Z0/dViJzXm/gzm8i8ewOPm38CkBg8Dktn82pUJpOxdHxXGjmLSMjYd70un9RbTp8q5hva2ltr6fh3RxYfXlyxNhYz7kLaHRDk4Nu0vGdTbHL+qdwjv+89LTDSz1fSFRaFszPO483JIdHffluu4WuF8cknnxAaGsqnn376yDYqNzey6tYFIG7hooeOO9eoTqXfluD53XRkdnYYQ0PJHjuOU2PHoct8uooiT0KuVOI7YwaCWk3OsWOkr16DIBNoO7w6XkH2GHUS/a5Nwlpnjre9kHeB19a99tg+U2KyOL8pAQEBKx8D3UaYNZhtFGZ3yd3ksr0mAI29K/ZtJ8Jru2D8eXIavkWmYI8GHZWSD+C+bTi2vzZBjZ4cmQ2+vR5MnpLLZayY2IXGHgpEBN5dfZtObhP4rdNvuCvdyRVymXtnLr2X9ebq3acPByw2hfmQD5r96thVhWthT+1DjnYpuRphScjLNhtpQX6fW82uYmUdPjfSj8B+8CCynZxQ5mm5WoE2Ef8pYAA8sWCBz7hxANheu0bS1Ye/1IIgYNerF76bNpJRpzaCJGG7fz9X2ncgbP36srmAfNQB/rhMmgRAzFdfkXz9OnKFjM6jaoFGh8yoYsjVD1AZzX7Cs7lneX3d64X2pc0xsGPhFQRRjtrRxJDJbZHlVzIJ8DCnMQuWdmV6PQ/hVBmr7l9j80k4cR1/IcrhQelOKzGLrPlt4eJfoMsueF2lVLDirQ50qOGG3ijy+p9nyU31YFO/TXSz74ZMknGHOwzdO5RPtnxSJpmahfIoH/Jvn5uPbwspsQ/ZJMD+eja8/p4fXWcEcdm/8ALGZUFejlk7RlA8wkhXgCiV50b6EchVKhzefw8Am+MnuHvkaDnPyMzCDz/kaw9P1jZsyKyGjdgx9RPizp7FVIiKn1ezF8gICECQJMJ/fHQdRAt3d5quXo3sk6nkWVlhmZmJ4eMpnHx5GNkJRS97VVwchw8jy9sbucHA7UlvI5pMaKxU9Hm7IZJcj0xnwas3PkEmmv3Vp7JPMWr9qAf6EE0iu365QkZSHjaOGoZ+1AqV+t5qzNfVHoC0vPJxEQgyOR7NXsJz9CqyBZuC1yXANuUibBwDMwPJ/Ws4ccdXIYkmlHIZ84bUo2WgC3kGE68vPc+xK3eZ3ms6f7b5E1/MG4sbUzfSaXmnp69JWBQe5RP2MxdX4M6/YtuL4ENOt5KzpKszXWcEMnFiJU7VtEYmSlyq/OyMtDbH7B6T37+At8sPwdNnQ97TFxR+Wp4b6cdQpVcvMmrXQpAkYj7/rFx9gbnnL3Bl8BAmRkTSx9aWGlnZdM7KoldoKOkvD+N63XqcbtmKk0OGcvXbb8k+dgxjUhJOr4wEwPLEiSca3KChQ6m+excZzcyuAruzZwnt3IXo1Q/XVywNBLmcSjNnYJTLsY2MJOT7GQB4VnKh/RvVkAQTZFkxNuKrgjCpE1knGL/tnk7J3z8e4O6NNBRqOV3H1sHCRvXAGK7FrBpeVmj3fYe1lEW2YI3undvkvHEK2k4Fx8pgyMHy1iY8do8i60t/Ipa8Rm7kBRYMroufpR4DcsatvcHhS+HUrVSXLcO2MNp3dEGl78nnJvPliS/J1Je9S+cB7ARwkIEoQVTRN9ivpVzjk7u/0n52ED++5E6sswr7LCOvbU1ix3u3GLo3tQwn/SAuTuYK7J4+7vdeVFqYk1qgQrg8nhvpJxD0zTfmSIi7MVz9+ednOrYkSWQfO0bk8BFEDhmC/MIFTJLEzpxsVmjUnLa1Jc7GBqNcjlwUsUlMxO78eWR/LjWng7doiZgvXaowGs2bg/v2PdbnbOHkRNPflqCZ9QM59vZo8vLI/nQad8ePx5CQWOrX6Fa3LsZBg8xzXLGiwC1Tra4fjfp7ICFiTLBkcsp3BeccTD7ItOPT2PHXCdJCzca7aX8fnL0fLiJgpTDfWG/HPPtCvQWkhmN93rwvoG/zGWpbZ6y9qkHL92D8OXh1N9Gu7dCixlbKwC96LQ7L2pEzuxGLgy5QTZOGXpIzauVlTt2IQiaT8Vabt9jcezMNVA0AWH1rNT039GRb2LZnt5j4ZxUdY4InBAcZTAa2h29n2PZhDNw6kI1pR9CpZFSPyOPLX++y952bTFqbgGfKs03FNhnM7gwrm3+t3itQhMf/bGWW4nD2o4+x2rABrYUF1fbuwcLJ6cknPQWSKJK9fz/JixajzY/gkORy1qak8FtqCpH/CpeTCQLH1q/HLi2N7GvXsU1LRXE3Bn1UVKFayRKQa2eH0csL++A6eDZrhiYwEKWPzwNVqfU5OcT/NJecFSvAaERmY4Nx6BCqjx+PTC4vtesVTSbOdO6CbXQ0mb6+NNqxvaD/3atOEXrArL1RqaWajwxmsSb3zAB6XnsLmSTHtbbAgHGFF5FdsussXx5IwEut59jnfUptzkVGkmBFfwjbC/6tYPimR4r5G/OyiD24BPnl1XjkXkOG+atpRMEBqT4rDK05R3WWvtqYelW8C847E3+GL058QURmBAABQgDftP2Gmt41S+86zp83+5vvp5cG6qrgiA72/0sX/Nw5qF+fxNxE1txaw5qba0jRmnXPFTIFHW0aMWTycurczqNIQXv5/ZU2Jzbc5vyuSILb+tD8pft0XVa9DNe3QJcZ0GTUozt4Copq154b6SKgz83lcpu2WGZkYOjWjTo/zCyTcSSjkcwdO0hZvBhdqDnJRNBosH9pAB8cO8bS7dsfeW6vXr3Y+C8FPzEvj/QrV4g+cADVb78/eQIaDVn29og+PqgDA7GpXQu3Ro1QZmcTN/WTghtGpq8v/jNn4FqnTomv9d8kXblC/KBBKIwmtMNept59m7Vr5h8g8bKEIEDr16vw2rmX6XfpXSyMNiQ53ubTr14r2Cj8NzvP3uTNtWHYyAxc/qZ3qc23qMTuW4TnkfeR5CqEMSfAuUqRzsuOCyP5wAJsbm/FyXTPTZUo2bPN1JTgDsOo36p7wet6k54F5xbw+7XfEQURuSinh3MPpnSegkapefoLKcxIV1VAoAJCDHD3nrtDAi4cXslK8Rx7I/dizK/C7WrhyoCgAfQP7I/z9aiH+3scZWSkN8w/QezlPKq+6EDHYfeJQ+38CE4ugGbjoeNXpT4uPDfSpU7YqtUYpk0DhYKAzZtQB5Re5QxRrydj/QZSfv0Vw13z45XM2hqHoUNxHD4MhZMTderUeWxcdO3atbl06dIjjycv/oWkWbNQBwXhNOdHEs+eI+vKZewzMhEiI9Hdvo2kK7xKitbSEr2rKzaRkQj5HxcJyO3Xl3rTpiFXqQo9r7hc+OYbNEuXYVIqqbplM2o/P8CcRXhwxU2uH3swiy/Z8i4ba82hheuL/NT9p0L7vBYZT9efzyFDJOybbo805mWBPjsV3Q/B2EiZxFV9GY+h84vdhySKSHEhyEJWYrq0Grn23kZWgsKbvKo9cG13L976fMR5ph6aSjTmGF9H0ZEpjabQsVbHp7uYwoz0v8hTCexoas/Kdo7cqHTPfVDftT6Dqw+mnW87lLL8Hbp/okWKyq1bULXqk9sVk98+30lenArPBgr6vNHy3oETC2DXR1CzDwz4o9THhedGukyIHjOW7AMHsGr2Aj5Lljx19QkxN5e0VatJ/f13jIlmf6/cwQHHESNwGDoEuY3NE3ooOqaMDELbtEXKzcV1wXyc2rZ94LhkNJJ+4waxJ06Qe/06ptvhKOPisCxCzHR2ndrY9OiBc4OGOFYLKrEhFE0mbgwchHDlChYNGlBp2dIC94vJJLJt/iWir93bVFpe/zOy1Waj1c65HT92+5HLly/Tr18/1q1bR+3atcnJ01Hzc3PdxxPvt8DD8dl9fiJ+GY5fzCYyZA5YTr6E0vIpxzbqubbzV+JPr6WFcBGlYF69mpARZ10b6g7Fo+VwBIWaBQcX8EfkH+hkOpCgqUVTvu36Lc42ziUb+zFG+q6zklXtHFnfwoFMa7OfWiOo6FalB4OqDaKaY7XC+wwNLVomoY1NmRhogMVTdmBIUePfwoKuQ1+4d+DaZlg9DLwbwetlUzf0uZEuA/RRUYR374Gk12Px2TT88je8iospI4PUFStIW7oMU3o6AAp3d5xefRX7Af2RWZRNCFLYhx9h2LiRjIAAmm7fVqRz8lJTSTx7lrSQEJyysxHD76C9eRPxEcbboFSS5+qCc4MGONStiyYwEFXVqijsihanrL8bw52ePRFzc3H76EMcR4woOHZ0bSghe+9lgfX6pAZd9nYo+H97l/bcWXyHTZs20bt3bzZs2ABA0Eeb0EkKVg6vxQs1KhVpHk9LyvWj2K/qgRyRmFaz8Grz+GSc4nA3LZfXFuykae5BBioOUUOIKDgmahyQ1XkJ6g4mVuPKh7s+4oLerP3hpHHiwyYf0qlSp+IvMP5lpEUBTtawZmV7Rw4F2yDlC1h5JeoZtD+FPp+vx65xy0f1VmFY+P52TJkaqne0pW3fhvcOxJyHX9qAtTtMvlkmYz830mXE7S+/Qr9iBXnW1tTcvw91MeZjTE4m9c8/SftrJWKOeTNMWckX5zfewK5nT4RSchs8iqSrV0nqP8CctPL7b3i98MKTTyoESZLIjIggestW5AsWFOmcPGsr9B6eyPz8sKxRHcd69XCtWxeF5mF/adrfq4j/7DNEpQLnpUtxq1eP2+cT2bn4QflOwUrLwE9eoPWme8ZAPC9y7adrgDnxJzg4mAafbCDFoGJmN1/6t6hdomsuDpIokvBdQ9x1t7lrXRfvyYdKfYyI5BwGLDxOUraeF5S3+dzzFD4pR7Aw3kt/z7LwJsW7I+e8a7A4fi2x2lgAmns1Z1KtSQS5BxV9wHwjna2Rsam5PX+3cyLCQ11wuNnlLIbsTaX5pSzkEmXmQy5t5r+9HfI01OvjTLNO9+2x5CTDjHx526mJoFAX3sFT8NxIlxG6zEyutm2HRXY22V270mjWD088xxAbS8qS30hfu7bA76sODMRp9ChsO3VCUCjKetoFnOzXH7urV8lo0ICmK5aXSp+xGzeSM2t2gctGVKux7dkDEpPQ3rqFMa5wRThRJiPX0RGXhg2wqVULdWAg8oAA1B4enO/VG6uwMLI8PXH88Xf2/RqOUS8S3NYHj5oadsy/jiAqUDnrGPhxc15c06yg38RfE0k9mUr37t3ZsGEDbb/cQHiOirdfcGRir5LdmIpD1Jbv8D33DXqU5L16EDvfWmUyzpmb0Qz/4zx5kgIvjZ7Nk9rilHQaLv6FdGMbQn4ldhGBKMtq/B0QyOq8KxhEA3JRTk+Xnnzc6eMibSyGhxxg5cyhbH7RnlwLc+SNVZ6J3kfSGLg/Ff/4fyVTlZEPubSZN2EHgl5Ns2Fe1HvxvpuWJMHX7mDUwoSL4Ohf6mM/N9JlyLUlSxBmzMQkk+G2ehUutQr/EurC75Dy669kbN4MRvMOtya4Ds6j38S6dasHwt2eFZF79pA7fgKiTIbXtq3Y+5fOh8+UlUXizB9IX7UKMG82asa/RfVXXiEnMYnEs2dIDwlBd+sWQlQUFolJKB+hvKdXqRA1GjSZmeiV1pxs8jFGhR1eQXb0nFAPmVzG+aM3OL78LgIybP2NVG5jzejrowFIWJdA0hZzXPTFixeZfy6b3bfSmdy+Mm+1f4R/tJQwZCZhmF0HSymXO1VG4v/yozM9S4Mjl8N5/a/L6CQFlSz0bJncBVsrDfrMJOL2LkBzYz1u+oiC9jeUlkxz8eCa2vzeO4lOTGk8hQ41OzzkzzeJJg7dPcRfN/7iVNypgj4C1J4MdmpPD/tmWMkLcc2VoQ+5tJk3bheCSUn7MZUJCv6XK2xuA0gJgxFbwL/0XTfPjXQZIooip7t2wy4igoygIJpu2vjAce316yQvWkzWrl0Fuf+WLzTFefRoLJs0Kfdy96fatcc2JoasTh1pPKd0jUjEtm0kf/ElVhnmx+6MGjWoPusH7PIjNf5BFEVSb9wkPSQE+4wMdLduor11C93t8IIIElGQcyF4Ahn2VbDITaBm6EI86tVEExSEJiiIU5ESty6YH0NjxQt8/8eHKL2VaKO0SCYJhUJB9+7dafTGNyw+HM7rzf2Z2r1GqV7vQ2x9B84uIUPlgfXkC8hVZZ/ivPdCKGNWXceAnCrWBjZN7oqV5p7rLO32WdIPLcQpeje2UgYSsNnaihmOjmTIhYKNxcR1iWxes5keA3rQ65NerL65mtgcs4tEJsho7d2awdUH08S9/D/DpcW8MXsQJDm93q+Jd4DbgweX9obwA9D7Z6hb+gWCnxvpMibu9BlSR4xAJknIpk0jaPAgcs9fIHnRQnIOHS5oZ922Lc6j3sAiX5GuInD999/hu+/Rq1QEHT6Ext6+VPvXZWURMmUqVnv2IJMk9CoVwsgR1Jo06YmRH/qcHBLPXyD1/AVCQhRkqoJQGHNpcH4mVrkPp7VH+LYnPMCcpJIZuoyzkUc4k5hI9H1RA5//fYTfLmTQM9iTnwaXYaHUmHPwSztAghFbwb9F2Y31L7aeus6kDaEYkVPd1sCGyd3QqB5UlJNEE/En12I4+yc+WRdIN2mZ6WjPZhtzpqa1UU7uLT3GKgIylfnvZK+2p1/VfrwU9BKe1p7P7HqeBSaTyMJxBwEY+X0zcyHa+9n0FlxYBm2mQKv3S33850b6GXBq7Fhs95s1mDXBddCG5Mcpy2TYdumC06hRaIKKEQv6jDAZDFxs3gLLjAyMr4yk9gcflMk4d48cJXbKFGzyfdVZ/v4EL/wZdaUnR1hs/v0o0af0SEjUvLoY96RL5AUF4devH9pbN9HdCiX72jXkRiOhVQZw17s1gmigbsg8HDLCyFUqCUlP55ZOh6xRG854t8YqwJuNH3R/4tglQTQaEBe3QZF4GeoMhL6Ly2Scx7Hu6BXe33oHEzI6VHPi52GNUcgfcVPUZcP1zXDxL07Hn+YLZ0cilfeMukO2knc6TqWzf1c0ilJIhqmAaHMMLHnXXLDgzfmtkf/7vTr4HRz8BuoPh55zS33850a6OJQgXlMSRVLWrydp6if3jiuV2PfuhdPrr6MqgiEqT278+CPSwkUofXyovHMHQimmed+PSa/n4pdfoVq/HoXJhKDR4DJ+PI4jhj9yw/T0/qucXh2PgIBnAwWVcy+g/HkhJpkMv7VrsK5hdlmIJhPJV68yY9x4vD37onCojTx/1W1dyKpbRCDP3g6jpyfyypWxrlEdpwYNcK5Z86nT3CPWTMXv6lyMCisUEy+AjduTTyoD/joYwqe7YzCKEn3reTFzQPAT6zue27eBs8s/Iq+2kTSViT5Z2QTr9GQKdqT5dqJSzw8RnIpeyPe/QmZyHsumnkChlDF6buuHG1xYAZvGQkAbGL6x9Md/bqSLSDEzn6Tr18m8dYvkxYvRh91+4Jjf3ysrlFvjcYh5eYS1boMpIwOvOXOw7fSUGWlPIPnKFXJmzCT3lHkDSla1Klbvv493iwd1llPislj55QkEUYGlp54RU83zujxoMKpLl9DUrInf3ysRlA8+yhv1JtZ8f5rUu3lICh2dumlwyU1Fd+sWCedCyL0Vhp0+p9C5mZRKrKpXRxMUiLpqIBmODjjXr4+NZ9Ee73MS7iD/uQkadETUeAu/l74u7ttTquy8Es+4v85jEiX61HHhh0ENH+tm6t27N9u2bcNoNNKngQejm9rSyikFjXBfxIZPEwgejD6wOypbl2dwFWVP5M14ts6+hsJCYPTsQrRf7hyGP3uAU1UYf7bUx39upItKEdJdAURBIMPWjpTatTEkmSMH/kndztq1C31EBDZdu+JdhJC8ikLinDmk/LwQTXAw/qv+LvPxJEkiY906Er77HjErC1EQyOnQgbrffoPKygpdnpF1350lLT4XpZ2R4Z+1RmNh3gAzJCQS3rMnYkYGLpMm4vzmmw/1n5qYwV9fHUfQq8FCy4jPW2Nta0liWhaNpx/CQZfF0sZguHUT/a1QZHfvYpmcjPwRqnFaS0t07u4Ifn5YVq+GQ916uDaoj8rS8oF2UXO64Jt2nCSlF04fhCBTPNvqIoWxOSSWiSsvIAFtvGDJuC6FGuqLFy9Sr97DfnprjYI3W/vwQWdfnNNDzOXAAAMK4uzqI6//Mh4vDqkQ11pSLhy7yfFlMUgqHW/91OXhBqnh8FM9UFjAlLhHCmOVlOdGuqg8wUiLgkCavT2pjo4Y8z+QckdHc+r2kMHIbWzQXrvGnX79QZJQff8dlXv2LN05lhHGpCRutWmLYDRi8eNs/Dp3fibjZkZGcu3td7C7Zk46ybG3x2HKFK5H+hB5JQVrBzX9P2yIld2DCQQZmzcT+/4HoFBgu3gRXs2aPdR3ZGgcW2ZfQhCVKBy0vPpFR+RyGVU/3oYJGVtH16eWv0dBe5NeT254ONKdO2hv3SL7ylXSLl7E8hHuL0kmQx3gb1YNrFqVhIxwqqUsQW5pIrn337jWK+TLXk78sP4Yc0+nA9DFT878UR0fMtS9e/cuqPRTGL169WLj0p/h8mpyT/yGZXZEwbFswZokj7bYtnwTp2ovlsUllCnHd13iwoZkBEstY2d1fbiBUQdfuZp/f+82WJUwpf4RPDfSReURRtokk5Hq4ECagyOmfH+lwmDA6bVXsX/77YdSt0+++ip2x0+Q7eRE/QP7S010qKw5OWwYdmfOklGjOk3LuGTWv7n+++9o585Dk5tLWEAvonw7IlcI9H2vAa6VHv47S5LE5aFDUZ6/QLaLC/X27C40Y/HK6TAO/n4HQZJj5W1g+McdqPvJZjJNShb0rUzXxk+Olc5LTSXhzBnSL11Cd+MmREWhSUhAVUgFHABJKZDl6onka1YQtA8Oxr1xYyycS/eLXVy++vsQv140l+fqU0XF7Nc7PHC8OMJdkiiSfHkfOcd/xTXhEJbkFbRLUnpj0fRVrJuOBKuylfItLfavP8v13ZnIbbW8+X0hRhpgZhBkx8Oog+BZupFBZWqk58+fz4wZM4iPjyc4OJi5c+fSuHHjJ573999/M3jw4EJlNR/HszTSRrmcVAdH0hzsEWVm46zU63FOTcEuIwPhEemu2XFx3O7cBZVOR97LQ6k/dWrpzrOMiDt9mvThI5AA59WrSlV+tCjkJCax5905xFiZBZ+qhi2n3tv9cOnWrdD2GRERRPTqjUqnI7t7NxrNLFw29uj2i1zcnIKAgGttGXOS0rirVTGltStvdG5UormKoog+Lg7j7dtob94kafty1LEx6LIUZjGLQlB4eqCpGogsIIA0W5vHpsOXFZ8sP8CyK7kADK6u4dsR7Z66T5M+j7jDf8LFv/DIvoycfJeRTAmBnciq3APL4F7PJE68pGxffpw7R7UonXSM+voRT0C/tIOYszBwOVTvUarjF9WuFTvlbdWqVbzzzjtMmzaN8+fPExwcTKdOnUhMfHzVjoiICCZPnkyLFs8udrQkaNUaUpycEGVy1DotnrExVL4Tjn1GxmPFya09PJCGmAPeFatWkxldMcrBPwmPxo3JqFIZAQj/qXC5z7Lk9p107lq1BsAzbj8+d0+Q/O5k7r79Nsbk5Ifa2/n5oRgzBgDLbduJPnz4oTYAzbvWxe8FsyFMvCxSw2B+solLyy3xXGUyGRovL6xbtsR5QGcC610noEsSmi+GYvf7b5gmTCCrQwcyqlQhz9oKAGNsHNmHDpH5++/I5/xExshXuFm/AWeat+DkoMGcmzqVW6tWkRUZSVk91H75chv6B5pdRyuva/li5dNrichVFni3fxPvyYfRvRVCcsP3wCMYRAPc2IrNttHovgkg4ueBJF3ai1SOpecehS7XnHWpUD/mm/1PhZb08vs+F3sl3aRJExo1asS8efMA8+rCx8eH8ePH8+GHHxZ6jslkomXLlrz66qscOXKE9PT0x66kdToduvu0jTMzM/Hx8XkmK2kJiHNzxyY7C+ucnIcN82OEY0wGA+fatccmMZGMhg1punxZ6c61jAhbvwHDxx9jVMjx37sXa3f3J59UCsRHJ7N2+jkEkxKlk45h7zUj9eefyVy+HEwmZLa26IcOoeb48Q/4UkVR5HT/Adhdu0a2kxP19u5FYVH4ynTjwuPEXNQiCbDGUkfnNj581L0UtDT+Hgo3tmLwbIzi9V2Fpvgb09PRh4WhvXmTxDNnybh86bHp8HI7O9SBgYg+PmQ4OOAQXAe3xo1LLdnorUW72JpfMHZ639oMauxbKv0+QMI19Gf+RH9uOdbSvSroKQo3sgK649xmLNYeRSt8UNas+mk/ydfAxs/I8A8fEd20awqcmAdNx0Hnb0p1/DJZSev1es6dO0f79u3vdSCT0b59e06cOPHI87744gtcXV157bWiyTV+++232NnZFfz4+PgUZ5pPhQB4JsRjU5iBfgJypRLXKR8D5iKukXvLRoe2tAno3YtsFxcURhM3HlNVvDTJy9GyfvZpBJMSNDoGv98SC3s7vD76EL/Vq1BXr46YmYni54Wc6da9oPYhmD9zNeb8iE6jwTolhfMff/TIcXqNeoGqjdwQJOiVoyIzIe+RbYvMrV1wYysIcpS95jxSg0Vhb49lw4Y4Dh1KtR9n02TfPmqFXMRl/XqEjz8mp1cvMmrVIsfBAeRyTBkZ5J45g3b9etRLlpA7YSJ3mr7AucZNONm7N2feeYdrv/5K5vXrSKaiF379h5/e6EDv6mZj8NGGy2y8EPNUb0OhuNVA1f07LKfcIab1j0TbNsKIHCdjAn63lmC5qCGpc9vBlXVgKN/iwHqt+Yal0jwmRt4+/0aWUX4r6WIZ6eTkZEwmE25uDwbqu7m5ER8fX+g5R48eZcmSJfzyyy9FHuejjz4iIyOj4Cf6P+I6APDr1ImM/JV2yrfTK+Rj3r+RyWRoBg4EQL5rF0Zt2X55RFHkrxkHkXI1SDIDPcfXw8bOquC4Rc2a+K36m5x+fTHJ5djeuUP8wIGc/+xzTPmrUFsfH5TjxgJgtXMXiY9YJAgygXbDq6Nwt0CNgOO5dGIjS16U1pCbQfYa87i8MBbciqcFIpPJcK5RnWrDh9Hwu+k0XbuGhieOE3T+HP7r1+Ex/VvEHj3ICAhAm785bZmZid2Nm1hv34Ew8wdi+vTlZv0G3OnXn1vjx3P+s88IW7eOjMjIJ449e3hzXm7qiyTBu2tCWHH4Wonehydep0KFV+tX8HlnL8ZJ14ioPYkElR8yJBxTzsLaV2FmILp1Y0g4u6VcvieuTuYnRh8/70c3qgAFactUhi0rK4thw4bxyy+/4FyMXW61Wo2tre0DP/8lqn/zNZKFBRYxMaSvW1fe0ykS1V9/DdM/1cG3PbqWYmlwflck2ngVEiIvDPTFp/LD7hWZSkXDr7/GZcVyMn19UBhNWPz9N+c6dCTm+HEAar7xBjn16iKTJLK+/hrxEZEXcqUMt/bOJMtELEU5G2adJSM1u9C2TyLm73exNiSTJdhiavFeifooDJlajaZGDex796bmjO9pun0b9S6cx3vfXpTTvyVvyGAyGjUiy90dwUKDpNOhvXoV0569WPy9CsOUqcR26szFuvU42bkLp0a/yaXZs8k8fx7xvpuuIAh80bMW/ep7YRIlpm4PZ9m+C6V2HYWhsXfHr9/nuH0cQtrLe5Gavwu23qDLQH35L9y2vkz6V1W4s3QcmdFlc9MoDMlofla2tbd6dKMCI/0f8Unr9XosLS1Zu3YtvXv3Lnh9xIgRpKenPxRv+U+gvPy+lNt/ys3LZDJu3rxJ5cpPTjetSBmHRdXJTfnjDxKnf4fcwYHKO3cgL2JlkvIkZckSEmfMRF21Kv6bN5WJ0tmdS8ls//kSSFC3qxsv9nxyRWvRZOLSrNnIli5FaTAgCgKyAf0JmjIFMTeX8O49MKWk4PTGG7i++06hfRwMuc34FTcZlqXCSpIht9XyyuftUVsUPVQyLewMNss7ocBEdLNv8Ok4rsjnliaSyYQhOhrtrVtEHDpM7vVrKGJisXzU5rZMhsrXF62bG7murljXrIldcDDjdkdwIU2JHJFvu1bipZbPMLJHFCHiCLE7ZuKcdAIV5ickCYjXBGKo2R/3NqNQWTuU2RQ2z7lA9PU02r9Sg6Amj9iHyU2F7/PlfKfEg7L0olXKLASvSZMmNG7cmLlzzYIjoiji6+vLW2+99dDGoVarJSws7IHXpk6dSlZWFnPmzCEwMBBVEeKJK6J2x5OQDAbC+/RBH3YbWffuBM2c8ZSTLHtMmZmEtW6DmJuL9+JF2LQsXQ3d6LBEdsy9jkFnolYrL1oNLkZlECA9PJwb77yL3Y0bAKgCAvD48guMqanEjJ9gFrZaMB+v1q0fOjc8Npm2P53C1QjDc1QIkhyNh55XpnZE9igRovuQRJH4GU3xyLtJrGUNPCYfKxc98MehTU8n8dw50i6GoL15E9ndaOzS0jGlpRXa3qhQEG3rxg0bbyJt3enauR7t+nZE4VB2hrEwdJkpJBxYjPL6Wjy09+yFHhXK4H4IdYdCpRehlN/vPz45SE6SSMthAdR+0a/wRpIE33iBIQfGn4dS1DApMyO9atUqRowYwaJFi2jcuDE//vgjq1ev5saNG7i5uTF8+HC8vLz49ttvCz1/5MiRT4zuKOnFVDTSDh8mftRoJEHA9pfFeDdv/uSTypnIadPIXbWaTH9/muwoPbdHalIGf31xAsGgwqOKHb3ervew6lgREEWR5M1bSJ85E1N+iJ6+XVvUWdlIp0+T4+BAnT27UVlbP3CewWgicOoOJAQWNHElfFcGAjIcq0kMnvTkuOGoHT/ie2oaRuRkD9+LfUDFLw0F5gQgU3Iy2pu3uL1/P3k3ruenw6c8Mh1e4epKjrMzOg93LKtVw6FePVzrP5wOXxZkRl4m5eACHCJ3Yi/eKzos2flw17E5Ni1Gldp7P3/iDtCpaTrYgwatqj+64bzGkHwThm2EyoVofJSQotq1YtdtGjhwIElJSXz66afEx8dTt25ddu7cWbCZGBUVVeJq0f/fcGjZkps1a2J39Soxn32O5+5dFf69sRo4iOzVa7C9c4e7R4+Wyo1FrzewesYxBIMGSamn9fAqJTLQYHaTufbuhVPrViTMmEHGuvWo9u3HoFCgAKzS0rj4wQc0nj//gfOUCjkWgolcSYFlgCNVW4uEHcwh9YbA0c1Xaf4Yt4suMxnH0+YnoWi/l/D/jxhoMPugFS4uWLu4ENz8Xuq2Sa8nMSSE1AsXybh8hcirUbinJ+Cem4YxMRF1YiLqa9dg336ygAxBINfBAZO3F+qqgVRp3w5NYCAKT89SdYvZVqqN7YifkUQRw51jKK+uhqsbETKi8clYCXdWkqD2RxvUB7e2Y9DYu5Z4LMkkIAAWNk+oX2jvYzbS5bR5+DwtvIxJuXmT2H79UBhNmCZMoNbYMeU9pSdycsAA7C5fIaNePZqu/Oup+1s6fTdZEQokwUSnsUFUrV168blh6zeQMX06lv+qXl6YFkmTTzeQoFfxVUdPXm5bjzXzD5J4WUQQoMuYOvjXKXxzO/b3kXhGbiBd5oj1+5dRaKwLbfdfJi0rl54/7CIlS6S6NpG3XNOxjLoNkZFoEhMfmQ4vs7Ym28kJg6dnfjp8HdwaNcLSpRSV8gx5pBxfiu7UH7jnXkeG2WQZUBBvVx95g2G4NxtcbLGnf6qydH+3OpWqejy64ZaJcO4PaPUhtHl0uGdxKbOMw+cUD6egIHTdzULzhl9/JS819QlnlD+e+QpzNhcvkvavPYXism3ZcbOBRqJuD5dSNdAAVfr2odbePWS2bYt034oub9LbaDMyHmhrpzIfj0s1S5b2H9uK6s08kCTY/esVEiIeNPTmxpfwiDJviOe1+eL/pYEGcLCxZMPbHfHxdOCcjS/vyRvhMv1HmuzdQ+2LF3DbshnZtE/J6dsXY7NmqAMDQaFAzM7GMjISuxMn0Pz5J9p33iWyRUvON2zEyZ49ufjee2Rs24YuNBTpEUk8j0OSJFBa4NRqNJ7vnyB39Bkiqr5CqtwVJUZ8Mk7juX884qwasOdTSLxRpH5Fk4gg5RfUtXnCZmA5R3g8X0k/A/S5uVxu3QbLzEyy2rejcX62ZkXmVIeO2EZHk9m+PU3mlawqxbnD1znxVwwCMtyDZfQb07p0J/kvog4cIPn9D7C4bxO4yr69KL28ABj4wxZOJcnoH6hi5qtmoSGTSWT7/EtEXUtFUIp0n1gL3yr5O/2iCL91grunoUYveGlpmc6/IpCeq2fQ4pPciM/CzUbFkiG1HlANvB9Jryc3LIzwAwfIu3ED8U4Eqrg4LHIK1+0WlEqy7O0xeXmhrFoFm1q1cG3YEFt//0LdgCEhIYwaNYq1a9c+kNAWHR1N//79WDDlDZzu7sY96Sga6V66f7ZtIMneHXBtNxZLp8JjoLMyclj6gVnb/LXZzQskcQsl5G/YMNpcjHbElke3KybPVfAqGDdX/IX45ZeIMhlOy5biXgQN6/LkxtJlSN98g16lIvDgASwcHYt1fmp8lnmjUFSgcdfzyqcPy2SWBUatlpDefbCMiCh4ze3jj3AYOpTPN4Xwx+k4Bjf05Nv+9xTN9Fojv0/djzFbgaTSMWRqMxxd7Ujb9xMORz4BpRW8dQbsvMp8/hWB5GwdA34+xp2UPGzlBtaOeZFA76K7L7ITEkg8c4aMS5ewTExEHZ+A7tYtxNzCdVP0ajVaV1csa9TA+8VmaIKCUFWuTLN27Th9+jQBAQEcPHgQHx8foqOjad26NeHh4TRu3JiTJ0+CUYcQuhtCViKF7kYQzZmEJmTE2QRD8GA8Wo5ArronHRAXlcz6by4hITJ2QdvHfzYjjsEfXcExACaUXkz5cyNdATnZoyd2oaGoGjcm4M8/KnTFZdFk4vyLzbFKT0c7dAj1PvnkySflo9caWT/jHCkxOcitDYz4vBUWVs+2Tt65Tp2xvC8DT6palVP93uTzGxJdarnz88sP3iQTYlJY8+0ZBKMKmbWWgRODsFjyIhbkkfPix1h1KJs6kBWV27HJ9Jt/lHSTEgeFng1vtcLPvXg36vuRRJGcOxHcPXaM7KtXMN4ORxETg2V6ekF1+H+TY2tLrEJBqF5POBJDf/yRYSNGEB4e/oDhvh9DeiwxO+dgFbYZF2Psvb6wJMm9FTbNR+NUszVh1+6ya24okszIWwueUJUoLRLm1AG52hwrXUqLjedGugKSExZGdJ++SAYD3vPmYnOfBkpF5Oqs2cgWL0bh6UmV3bseWZPwfiRRYseiy9wJScbSVsWAjxpi7fDsC5kaMzO506MnxoR7tQ5NMhl/V23HzXZ9WTOh9UPnhF2NZuf86wiiAmeL6wywnUqa0hX790MeWIX9r3AjKoEBC0+QJSpxVurZNLENXs72pTqGPieHhHPnSLtwAZvUVOTRd9GG3sKU9LAC4sykRH5LTX2kgf43KdcOk3V0MS5x+7GS7nPBuNYk1mMkG3ZVwdJOwSvfPSEfwGQwi/9LIrx7q9TqVz430hWUxB9/JGXhIpReXvhv3YLcouLq7YpaLWFt2mJKS8Prx9nYFqFyy7oFh4m/ZESukNH7nXq4B5RfpmX20WNEv/46ACaVCnl+hEK0jSuBX32MX6dOD51z7vB1Tv51F5BTx3ILgYNa4da49zOcdcUi5HYsQ5acJkdU4qbSs2lSO9wdy/47mBsXR+zJk2Reuoxs82bUOTl8m5jAsrQ0jh07RrN/VeWRJOmRT6aiUU/c0RWI55fjnR2CIBqI0gWzJe0zbFXxtO6ajEfrVx+/KTyrBmTGwOv7wbt0XJXPozsqKM6jRiF3d8MQE8P5Tz4t7+k8FplGg8PgwQCk/PZbQUr/o9i/4Szxl8z+wCb9fMvVQANYN38Ryz69AdCp1cQNHk6a2hqfrERyJ07i1BtvoP1XNl69ZpVp6vAHAJdye3DqSvlWVilvgit78ueIBlgIRhL0KvrN2UdKZuEbg6WJpYcHVfr0wXnEcIzZZp2Vs/k+7cGDBz8guhYdHU3Tpk0JCQkptK97Yk/7EN4LhW6z0DuYU+CtpFR8Tn6CcXplIub3JeHc1ofEniRJKjTC41mtb58b6WeMzNIS48svA2CxY8cDEpwVEYehQ5CUSrSXLhOxY8cj2107F8613WaDZ19VpF6bgGc1xcfi+t575FlbY5mVhfpOKKPbvccen4YIgO2Ro1zr0JHMgwcL2ket/YQG6q00slkBQPRpPWHnHl/Q4v87DYN8+GVoHdSCkRiditHLL5CnL75UanGJjo7mtXbtsRIEciUJmb9ZQyMqKormzZsTHR1dsJF4+vRpRo0a9WTDaeEAjV4jqZZZyVCvsSZLsEWDFr+kfbhtGUr611W5s/QtTKmRhISE0LRpU3KU+f74fCP9pBtDafLcSJcD1V59lcxKlZCbTNyeUrHLbCmcnMisb46ESPzl14eOX758mSYNXmTfb7cQJDkKBy0DJ5Ze6uzTYuHoiG2+3rTjyRMEpUczq8EgYiZMJs/GBovsbGLeHEPMe++Tcf0sHjd+A8CliQ81WphD8fb+fo3YsPTyuoQKQfNa/iwaXBtrtZyzURmMWnYWraHsDLUkSfTv3x/3/LwCm8aN2bF7N76+5jj7qKgoOnfuTKtWrQo2EteuXVvkzfjE+BQAcizdsZ56h7j2PxPl8AJ6lDiYkvEPX4bsp2B0v3QmUHuBddsPmE/MuFv8G8NT8txIlwMymQzfL79AFATsbtzg1qrV5T2lx+I3YQIAtjdukHDx4gPHpn36GX0bTkBmUiGpzeL9CsVjRNTLgSp9+5KR78OccGENlgYtWcFNqbFnN/bDh4NMRuaWLcQPGYk2Qk6Cwge/vp/QanB1/IOdMRlFts67SPj18tMUrgi0rhPAn682xlIl50hoMiMXHyFPV/wElaIgCAKLFy+mQ36Mu2OLFvj4+HDkyBFaNujEwNbjSI/XcufOnSJvJN6PPs/sllOoBQS5Ao/mQ/CduBPpnZtE1fuAHJd6CEg0ds5lWR8Lhlczy72mhIcUhAAW98ZQUp4b6XLCo3FjsluZd5UzZ8/GmFe+VSoeh3uDBmQEVkUA7sy5Vwfx/PnzVLNpg7XggigYqNHZGluHipmRV3fWD+Ta2OCSl8HrV7YQk5qFxt4ej48/wu/vlagqeSDmmYg96cDdY+6khoYhkwl0eK0mtu5KDFqR7QuukBRb8TNGy5IGlRxZMqIRShmcjM7hpdnb0RuMZTJWnTp1aGpriwQkuwRydHUo+xdE81LD92kR1JcOdc2FKpYtW1bs6k16rfkpQKF+cEGhtnXCt9fHWI07CBNDoPXH5GnuyZheOXPksSGAZcFzI12O1P7yS7QWFlilpxPy9VflPZ3H4vKaOUrC6vRpsmLMZZfmTf8NL0tzZZJLUUeYu3hWuc3vSWjs7bH/xOxa6hJ5Cu3xY/eOVQ/Ev3M6zrUykWRgeSeGmH79ufD118jl0HVMbSSVDsGgYs3Mk+RklUIJrv8wL1R24ouO3sgQuZyuYNCP2zEYS9f1IYoil7ce56Z9K443/ZJ9u0yE7I8mJ91c+zRTm8yu82ZdmWHDhhW7epNRZ57vY0tnOfhB6w/QvH+d49U+ZfFVDZ8fMo9fkhtDSXlupMsRSxcXFK+MBEC1aTPa2NjHn1CO+PfoTparKwqTiRtz5nDx4kU27VhLRq7Zt1fXpy3VFF05sOnMM9v1Li6Ve/bkRLXGALTYvQZTfvp4xMp3kWXcxqmxBY6//EymlxdKoxHNsuWc7dARfWQoPcbXRZIZkHI1LP/2AMYyWj3+VxjcOphP2noiIHE+Rc7wn7ZjMj1dCSxRFLl+/g4rZ+9jwcTdHNmmI8q3PTrNg0k0F8IPs/TEF6zb9hcBAQGEh4fTunXrYhlqo878GVVZPDn2/25MDMOmLGD02kQORJiNe0luDCXluZEuZ2qOG4ehcmUUBgMps2aX93QeiUwmw3LwIACUu/fw9bRpZGpT+HzlcLac/o08XTbeTpW5tiOL9TPOE3OrcKH58iZj+FhirJyxzckgYfp0MiIu4R3+NwB3a47B/cXWNNq9C+3wYRgUCmxiY0kZORJx3VJaDPFFEkwYUzUs/37fE0MS/7/zSscGfNDCFQGJE4kyXpu/o9jviSRJpMRkc3LTbZa8f5D9i++QelNAMKgQRAOWufclI4lG1hydy4Hby9i9dwfNmjXj4MGDBYa6f//+RV4gGA3meaotHq+cd38aekBAAMeOHSvxjaGkPDfS5YxMLqfq99+BIJC5dSu5Z86U95QeSbVXXsFgZ4daq0U6dBij0YjeqGXXhRV8tnIYey7+jd6oIz48g42zLrDlp4skRRWh4s0zxM/fi9n1ByIhkLFuPWk/vIYSI3Gaqvh0eRsw/03qffwxXuvWklGlCnJRRPvHH9h89wF16umRkMiJVrJ+0eFyvpry581ujZnQ1LzSPRgLYxbuKtRQ/9t43r4azeq5+1n2yTH+/vI053ZEos8GSRBRueio0cmWqkkH0Oavom0cNdTv70ieVewDvmAfHx8OHjxI48aNWbx4cZE38cT8/U6N1aOFlf6JMLnfB/00N4aS8jzjsIIQN+0z0letAj8/AjdvQl6EsmLlQcpvv5P4/ffc1unoGXGHf3947CydeLPfVCpZByOK5qOV67vSpKc/Du6PKfj5jDgamszLS07x/u0dtLm8D4WFiUpdkskesQ3HoBceai+KImmbN5Py3ffmMlSCwPUXhhGnagJAu5HVqdb0MVrE/yN8u/oIi86bpV5HNnTls/6NCo6ZVev6881nM0kNN5IYqgXtPaF9mUKgUk0nAuq74FXNFrVazf5fLnD7qvkGX6mmA+1frYXGSvnIzMLHZRwWxvJpx8lI0NJxVDWq1vd8ZLvHK/H1Z/HixQQHBxd53Pt5nhb+H8OYlsb1tu1Q5OWhHfYy9aZMKe8pFYopO5uLDRthCbx5N5rDhchS1q5dm8N7T3J6yx1CzyaABIJMoNoL7jTq5o+NY/npYFyJTqH7/JN4kskf+z7DlCXDWMWW2ltPPfY8Y1oaCd9+S+Zms1Tl9WoDiHNvjUwm0H18MD7VSy4+9P8BSZJo9PIHJPu0AuDNF9z5sFcDrl64xS8zVuFtWwML7tVOlBBRORqo2siNZp3roM73DafEZLNz8RXSE3IRJBNBeWdo++dHpR7mtnTKcbJStPT7oAHu/o/PjC2tG8O/eZ4W/h9D4eCAaZA5pEi2ajWZdytmTK7c2hr3YcMAmNmyFZIkPfRz6dIl7F0t6fhaTQZOaYxfHWckUeL6sTiWf3qCo6tDycsqvNJHWeNoaTYGLyu2490kBQQJRVgmN5Yue+x5CgcHvL7/Hvnnn5FnbU21G2txTTiLKErs+PkSd65X3E3fZ4EgCGyYPh7h8hZsRYHr+5OZ/+Z+Di66S1XbF7HAAQkJhYOWyq0sefnrJoz6pgtt+tQvMNDXj8exdvpZ0hNy0ci01LvwI7XrqMokDlmvNW/8qjRP3jh81PjPSsXyuZGuQNR+5x2yXF1Q6fVc+/jj8p7OI9H074coCFiHhxN9+PF+WWdva7qNrUPf9xrgWdUe0SgRsj+aZVNPcGpLeEFSwbPC3cGGQCGaN+TbsHQ2kNvQXP09b/ZssuPinnh+4MCB1Ni7h6wWzal+Yxn26aEY9CI75pwnNvJ/N308NjKJc7simOzbn9GZGhrr7m3IJeVF4FZfZMgXDRn9bVc6D26KvZNNwXGD3sS+P6+xf+l1jAYR3xqONIv4FfvMcCzKQHddFEV0uebPnUxR4R0Jz410RUKuVOLykTmF2fb0GaL27SvnGeUTGgrnzxf8OOXkkFUtCICY2T/eOxYa+sguPCrb0fudevQYH4yLrw0GnYmz2yJYNvUEF/ZEYXwGWhAAMkHgK+XvKAUTkTYNqb3wb3IcHNDk5XFl0ttF6kNjb0+TXxZjM+cHAmJWYZkTh4Ql2z/fT+rN8DK+gopDQkwKm38/ys+Tt7Ph28vEnDWA9KBJWWqdh66ZA/1HtcfR9WG3Qlp8Dmunn+XGiXgEAZr0DKDzQE8Ivw6CgGX90i/6q8vT889milxVcTXd/+G5T7oCcnLwEOwuXCDL3Z2G+/Yik5djmnVoKAQGPvRytJcX2dY2iIKAR3wcjunp5gO3bkHVqo/tUhIlbl9I4tTmcNITzMpmVvZqGnXzo3ozD2QlrCReJC6thvVvkCepGHyjA19O/Qi7xESy3xpvFp9//32qv/pKkbsz5OVx7MMvCM1sjF5th336LTp0tcHl5cEIFbwyfEnIzdRz+3wiFw7eJiv+0TdWo6BlixRGmH1lBCTG1bNg8sB2D7S5dTqeAytuYtSZsLRV0fG1mngFOZC5cycxk95GXa0aARs3lPo1JMWlsfrzC0hIjJ3fpmw/b4/huU/6P0y1b77GoFRiEx/PlfvSsMuFrMJD6HxiYsi0tUEmSYRWqfrE9vcjyASqNHBl8KeNaTOsGtYOanLSdRxccZO/Pj9F6NkEJLH01w7a9AQM294HYK6xN2E6Oz799FN827Uju4O5AIO0cCHGYhQLVlpY0HrOtzTu5YjMpCPdPpDD66O51LMX8efOlfo1lAepiRlsX36CVdNP8scHRzn8963HGmiDkMuaczOZ9nJ93HJuIyEw/0Iuc9cdBMBoMHFwxQ32/HYNo86EV5A9L01phFeQeWMx98xZACwbNiyT68nJzM8YFUzlZqCLw5O95s955tj7+3O7bx+Uq1ajXLUK0+uvIa+ATxD2GRmIggyLvDzyNBostMXTH5HJZdR40ZPAxm5cPRzL2R0RZCTmsfvXq5z3iaRJzwAq1XIqtQ2a+L/ewk+XRjRu/GrqhqX1GTauWEhISAh1p08nIjQM0507xH/5Jd6zi5dYFNy7FbkWIZxfn0SCe2M0kanIhw3nbs8e1P3sMxSa/1Zll/TkTE7uvkrkpTQM6WoECv8b2LtZ4lfbiUuHIhENMvTksObsTFatX46Pjw8rvbwZ9ON2Ei0qMftMFo6q8yguGUmOzgYBGnbxo1F3f2Sye/3nni1jI52V/zmV/zeSkZ4b6QpK8EcfEXnmLPrwcJLmzsN9SsXbSKwaGsr5uvWwys3levXq1L/wcJFOSZIwiRIGk4RBFDEYRfPvJjH/x/y7WNWaGl7ViD2dSOLZJJKjs9k2/xIqdwusGjkjc1FjMInoTRLG/HPv/72wPg0mEaNJQm8Sccu8wvfpe0CAqbrh6FFibeWAQqHgs88+Y8OGDfjMmEHEwIFk7dhJRseO2HXpUqz344VOwWSknuT2oVwiK3VGo03Fa+MmLhw9itsXX+Dbtm1pvfVlgjbXwOEt57kTkoIhVYWADNAUap59ajgS3NYHGycNm3+8gGiQIWgM7Ly0sMBAAwT4+7FyUleGzN2LHV4kbk9DJQlorJV0eLUGvjWcHujXlJ6O7tYtACwblk2x5rxss5EW5BXe0ws8N9IVFoVGg/vUKUS9+hppK1Zg168vFtWqlfe0ABgx4DOy1FYYZArqpIfz8s095JqUNB/9K9rNCRi27M43nmbDXNxdDwsNNBEU1NMpID4P/ZZobitMHNUYSCzBbrwMkfWqechkEptMzTgkmfWx74bfxGg0snHjRkJCQggODsZ59CiSF/xM5MdT8KtVC9tiiuh0HtyUdWmHiL9k4mbQYORiDu4JF8ke9xanW7ciePp01HblW7HmfvJydERdSSPsXCJR11IQjRKPMsxypYygpu7UaeONk6c1UaEJbJx1nrwsA46eVvSaVI8xNh0fevLx8/bl2wYvcv2IOXomVinSfWTgQwYaIPf8BZAkVP7+KJzLpipOXo5ZJEn4D0R2wHMjXaGxatYM644dyd69mysTJ9Jgx47Hl55/Rlz0CCLDwhxCdcPVj24RJ3DSZVI5O45DWnfg8Y+RCpmAUi5DIRdQyWWF/p4ul3HGJOCfaMQt2Uhlo5zK2XIyXZSkV7ZEsFEWep5SLkP1r98dLiygbmw4eahZcdeH5COfYdRmo4s1r9juX007jR5NxOo1WCcnc23iJBqvXVPs97zvmJbsX3qdGyfiuVlnFGLKWjzP78fmwEGudexE4OxZWP2rRt+zJCcrj1N7r3L7fBK6ZCWC9Pjrs7JTUbuNNzWae2Jhbc6EvX7+Dvt+vYUgKnH2sabnxLoFx+4nMzmPXb9cITHSvFcR467g77wsNq0+zzxTIK2DKz/QvqxdHQDaHHNOuPzxsh0VhufRHRWclJs3ie3bD4XJhGnSRGq9+eazncD58/CvWNU9VRojCjJUJiNKkwErmQGNSkQyigiL/kRZuxbKfCNp/nnw9+L6mNMTcjm9JZzQs+Y4ZEEmUL2ZB426+T2xEnlOYiTyBY3RoOWix2DqvbnokW0vXrxIcHAw0UeOkDlqNDJJQpw0iZpvji7WfAFMJpFt80KIvp4GCiMNqseh+n0uFtnmDE27Pn1w++B95Pb2xe67JOTlaDm17xphZxPQJikQpHsRQxb2CqxsNOSk68jLuifi71rJhuD2PlSu74r8vg22K6fDOPhHOIKoQLDUMnxaa6ztLB8a805IEvv+vI4u14jaUkH7kTVwrWbPoJ+PcikuB7Vg5I9hwbxQw+/eOQMHog25hOf332HXs2eZvBdnd93m1IZIPKtb02di4zIZoyg8Twv/f8TZDz7AatNmtJaWVN+/D80z+mIDhRrpf2OUywmtXAUEAfWE8QSMHVsmU0mKzuLUpnAir5jlUeUKGbVbe1G/c6VCV3EAUT91wzf1KMkKT0adrcqGTVse2X+vXr3YuHEjAGcmT8Z66zb0ajV+mzZi5+dX7Pnqcg0smboPKVeFpNIxYGItpBV/kLZyJUgSkr0d0muvUf2118rkCcloMBF1NZXzB8KIv5X9gGGWlHocKymxs3UgLVpHRpI54kEQIKCeK3Xb++Dmb/vQDfXCsZscWx6FIMmRWWt5+ZNW2Ng9qMliMomc3BjOxT1RALj529Lx9ZrYOlkAkJKRQ49Zu4nVqbAQjCx7pT4NA30Qc3K42aQpGI1U2bcXZX5VltLm3M4ITm4Mp3ozD9oOr14mYxSF5yF4/4+o8+mn5NraosnN5dInn5T3dB5CYTKRke9nTdy6tczGcfGxoftbwfSZXB+PKnaYjCIX95qzF89su1OQ6ltAxDF8U48CIHadSVh4xGP7Dw+/l4hS76uvyHZxQaXTcX3ipBLJkqotlfR7pxGSQo+gV7P+58vYT36fSiuWo/DzQ0jPQPbDLE736Uv67dsF512+fJnAwEAuX75c7DF1Wj3Hdoawaf4Zfn/vKDsWXibhZh6CJEdS6HEIFGk8wJO6LSuTE6Mk4nw6GUl5qC0V1Ovgy8tfvUDnUbVwD7B7yECfOXitwEDLbbUMn9bmIQOdnaZl4w8XCgx0cFsf+rxbv8BAAzjZWbF+YjvcVHryJAUj/jjH5Ttx5IWEgNGIwtOjzAw0gD7vH8H//4a39/lK+j/CjWXLkL7+BlEmw2n5MtzLIBOrUIqwkgZIcHElxdERAXD4a0WZz0+SJKKupnJy021zOBegsVbSoHMlarXyQiETYWELSLqOVH8EQs/ix5vHHD9O+utvIBNFjG+9Re23xpVorqFXotg1/waCpEDtquPVaZ0w6rSETJ2K5Y6dyCQJg1KJNOxlar/7Ln379WPTpk307t2bDRuenMyh1xs4d+gGN07GkhMnIIj3jI+1g5rKDVxx9JNjZ+vA5QN3Cb+YVLCZa+9mSZ023gQ1dX+s0Tq55zJn1ycgSDIU9lqGf9IWC6sHXU2RV1PY+9s1tDkGVBo5bUdUp3I910f2GZ2YRu+5B0kxqLCVG1iluQ4rlmLbswde33//xOsuKVsWnSHqQhbVW7nQdnDtMhvnSTx3d/w/QxRFTvfshV1YGBkBATTeuuXZbCI+IuOwME42boxdRiYZTZrQ9M8/ynZe+UiiRNj5RE5tDicj0fzIbu2gpkFgGDUiJiGztIfx58CyZCp1Zz/4EKtNmzBpNATt2oXS7dFG57H9HLzGyb9jEZBhV9nEy+91ACDm+AliPv4Ym/h4ANI8PRl75TIhSUnAPT/5vxFNImcPXefaibtkxzxomCW5AQc/OW37NMS1ki1h5xMJ2Rf9gLa3T3UH6rT1oVJNJwTZ4/cI7oQksWPRZSQRlE46Rkxth9rinntJNImc3nqHczsiAXDxtaHTGzWxc3nYT/1vwmOT6Tv/KOkmJT8cnU+N5Du4f/E5Di+99MRzS8pvn+8kL06FZwMFfd5oWWbjPInnRvr/IQkXL5I0ZChyUcTm66/x7tf32QwcGlqkTMLwkBB0332PSS7Hd9dObL29n8HkzJhMIjeOx3FmW0RBHTx7+V0at9ZQpd+AJxqiR/ar13OrT1+4fRvrVq3wXvhziZNr9q07w4095vcx4EUrugwza1KbDAZCvvkW5ZrVKIwmTDIZ27OyOJWTje0LL/D7tm0F1xgXlkHY2QRuX0hCm31vk0+SG7D1Eaj1oi/BzQLR5xq5eiSWy4fukpthVhyUK2UENckPofMqWsHgsHOJ7FlyFVGUcAu0oOe4hqjU98IicjJ07P71KrGh6QDUaunFiwOqoFAWXcrgZnQig+cf5vfNn6MSjTiu3YhbraAin19cFk/ZgSFFjX9zC7q+/LCG+LPiuZH+f8rlDz5EsWkTSm9vArZuQVaBMtlEUeRs27bYxCeQ3b0bjWbOfOZzMBpMHP1iKreTm6CVzJ8VF18bmvQKwLeGY4kMrC40lDt9+yEZDHh88w32ffuUeH7rFx0i7oIJBOj8Ri0q17+3Mj+xcSNp33yLf2ZmwWsSAqnewcT5vkiy0h9RuOfbVagFNG56ajTzoV7zIBQKOSkx2VzaH83N0wmY8ktEWdqpqN3am5otPB+5wVoYBzee59qudCQJqjZyo/3I6g+kUd+9kcruJVfJyzKgVMtp83I1qjZyK9H7cm3bHoR3J5CmtuarV35g5agXsLMsmxi5he9vx5SpoXpHW9r2LbtQvydRVLv23/CcP6eAmtM+5fapUxju3iVlyRJcxpXMT1oWyGQyrIYMhVmzUO7dhy4rC7WNzZNPLEUSjy+ntXwBTV3+4KTfX9wKkZEUlcXWuSF4VrWnae/KeFQuXjKJumpVnCeMJ+mHWdz94guk2rVweIKI1KPo/UYLDq+8xdUjsez57RqWtio8qtgD8N0ff7DtwnmaaCzoXKUpfr4vkOcYjF5tX3C+wpCDW/ZNKrkb8W3ij3XTRigr+RF1LZWQfdHcvXGvtqSLrw3B7Xyo0sAVuaJ4rrGdK08SdigHAYGqjV1pP7JGQeq2KEqc2xHB6a13QAInLys6vVHrqSrvuEaHkwSEulXhWnwW/ebuZ9WbzXGyK/1qPqYilM6qSDxfSf8Hydyxg5i33wGVCtdVf+NUvfzCiP6NSa/ncvMWqDMzcfn0U5yHDH5mYxvzssiZURs7MY0Ij+74jV5BXpaeczsjuXIoBpPRvLL0q+1Ek16VcfYu2iM/gGQ0cq5zZ6zuxpBROYDGW0q+JyCaRHYsukLEpWTkKug0Noj0vET6dBpMq7o9qVe5FUrp3opZkvTYidH4ZV7D8doBZAazO8coVxPv1oS7ldqRqzZn5wkCBNR1IbidD+6VH47QKApblx4j8rh5DOtKBoa936FgBZ2bqWfv71fN8d9A9Rc9aDEwEKXq6ZQao15/g5yjRxEmvEv/OA+yDeBroWfzu52xt7Z4cgfFYN6EHQh6Nc2GeVHvxbJzqzyJ5+6O/8dIksTVfv2QX7tORvXqNN2wvryn9ACpf/5JwrfTUfn7E7Bt6zOT7Iz4fTR+kX+TLdigfDsEte29tOOsVC1nt93h+ol4s8KeAFUbutGkp3+RNrgA4s+dI3nYcOSiiP6N1wl+990Sz9WgM7Hsi8PkpZi/fibJgFy493gvYiRRe5szt/Zx4Ow2unTtxMaNGxHz8kg6doHLB+5yO9kWo2BeDSqMuXjGHscr5hDWFiIWDRtg1agRlo0bow4MRCii3O3GX4+YdaEBu8omhrzbruBmFBuazu5fr5CToUehlNFqSBDVXnj6+o6S0citJk0Rc3Lw37Cek3oVo1ZeRY+cACs9m97tgo1l6bn15o3bhWBS0n5MZYKCK5Vav8Xlubvj/zGCIOD4/vukvfIqdtevE7p2LVX79y/vaRVg168/SfPmo79zh+yDh7Bp26bMx0wPP4d35BoA0pp8gI/tg7oQNo4a2gyrTt0Ovpzecoewc4mEnkng9rlEqr/oQaNu/ljZqwvrugD3Bg2I6d8fy9WrEf74k5Tu3XEKKt5KTBRFQi9Hc+FAGLlpIgJm4/mPgT4XdoDozKscu7SLPF1uwXnh4eHE3c4gZF8U4Re0SJIzCGDnoqF6FQmPzJsYTHHkxeZiSteSvXcf2XvNRSNktrZY1q+PZaNGWDZuhKZ6dQTFw1/9dQsPEX/RHEPsGCQxcKLZQEuixIU9UZzcFI4kSji4W9JpVC2cPIv+JPI4tDduIubkILOxQR0YSGu5nJ8MRsavvUl4jor+s3eycXI3LNSl5KMWzTcdK5uKs5/zOJ6vpP/DnBo1GtvDh8lxcKDu/v0oLCrOhy5hxgxSl/xGXuXK1N9WdgkuAEgSWQs7YZNwiliL6ni8d/yJq/ekqCxObrpN1FWzdrRcKaNOa2/qd6qExvrRxsBkMHC2c2dsY2LJ9Pej0bZtRXJ7hF2J5tyBUJJCdQj6wm8GCns9TQa689LAl1i3bh21a9fG9H/tnXdcVfX/x593cS8bZKMooCgOQGW6cmQ2TKWyHfoty/pl45t9K0tL03I0zDS/X9NvpVl9XeUozVyRWxFBcCtXAZEt47LuPL8/LqKkIJeNnufjwR+c8znnvN+M1/2cz+c9DCZSKkPorta/AOgQ6EzIMB9zKdfrIlcEnY7y4ycoO3KEsrg4yuPjMZWVVXuO1NYW66uiHR6GqmdPNnx7iMxE8wzarZeEsS8PRiqVUlGiZ8fyk1VZnl0jPRj8ZLdGTQTJX76cnLnzsBs8GJ+vl1Qd33jgJJM3pmBESi9HAz+/+QBKq4YJtdFoYsmkWADGz+uHnWPjLqVYgrjccQdQmpPLuREjUFZUUPbYo4TOnNnSJlVRcO4cl0ePQSoI2P7n33Qc2oSz6RMbYO14BKkVmphtOPj1qfOll88VcGC9mix1EQBWKhl9RnQkeJhPjUKUnZBAzjMxyI1GtM8+S+933r7puIKsUs7H53A+Pocrl691VRcwoXTV07mvG5H39OT88XT2fJ+GRJBSIFHz/pIXePShJ3j7hTkcj71E6dUQOrmUrpEehAzzqXMInWAwUHHqFGWH4yiLi6MsPh7TdeGUAqDu+gip3uYyqu07XGH026ORWlmRpS7ij2XHKSnQIpNLueuJrnQf4NXoDVjTX3mFkh07cf/Xm7g8/3y1c6v/SuLd31MxIaWvi5G1b45CVs9wSjAXV/rmzT0AvLR4SLWaJM2NKNJ3CEkLvkSxZAl6uZyOmzbi5O/f0iZVcbUNWFFwEFFr1jTNQ7Qa+CoCNJdh8Dsw1PK624IgkHo8n4Mb1ORnmLMXre0VhN7vS69B7ZEpbvxHPjpzJtY//Q+DXE7Als2oOnYEIPVcJkd2nCHrbDmUX5sxS6Qgd9Li38eFyBE9b0in3v1rAkmbryBBQnaJGmdVe6zk5uttHKwIGtKenoPaY23fsIgEwWhEe+YMZXFxlByO41imB2nuAwAIOLcWn4xYUCrJCn2SU1ZhCEhwdFVx74tBuPk0fqSOYDJxrv8AjIWF+K76H9a9e98wZsWOo8zYcRkBCY+FdWDuw8HVmgRYQnFeOSunHUCukPLioiENM76BiCJ9h2AyGjky/B7sMzMp6t2bqFX/a2mTqri0dy+a51/AJJHguf4XXJqgHnbmigl4XVgHzr7w8kFQ1P/1VTAJnIvP5tCmCxRXFhyya6ck4kE/ukV6VosRNhmNJI+Jxur8eQxhgzk38Akyz5RB+bUlJ4kEfHq40CXUHf/erihvEff77sRP6SC9loJfrM/h4YlD6hVCdytMRhM/fLIDTar5bSGscxHtL/1FUXwyJzxGkuvWGwD3nKN0V6/Grmc3bMLDzEskffogtanbZuut0J47h3rUaCTW1nQ7dBCJ1c0/hH4+fIG31p/EJMC4fp34cHTPes3o08/lsunzZKxspLwwf0gDrW8Y4sbhHYJUJsPzg/cp+b+XcUxMpDQuDtvw8JY2C4AOAwdy0NcXx4sXOb/gS1yW/KdR759/cjceF34GoLD/NJwaINBgLoHaNdyTzn3dObUvkyObL1ByRcuuCFVv9QAANXZJREFU70+TsC2NyNH++PdxQyKRUFqkp+jR97i47RQaO19INAEqBATkTlo6BTsTeU8P2rnVLSY7MTGRucveZmRkDM7WXhw4/TspWck88FoiMrlng/z6OwaDkZVzdlCWoUBAYMBj/vQZ5kdO6t0cXXqc4vwKpBKBXvITeORuwlhRQnl8POXx8eQv+Rrkcqx79sQmIhyb8HCs+/ZFZle/TcSr9aOte4fUKNAAj0T4IVUomLzmGN8fSCU/J4tFE4ZZHAaZl21eW9cayutlb0sgzqRvEzKmTaN43c8oAwPx+3ldnUOumpqzq1djnD4DvUJBl107sXFza5T7CiYjOfNC8dBe4JJ9Xzq8+Wej3Pd6DDojybEZxP9xEW2poeaBggmnovPYRbVn4JODcPFwsvhZ0dHRbN68GYPh2nPkcjkPPvhgnYos1RW9zsD3s3dQkWWFgED3e8xZd8f/ymDvunOYDAL2LirufaEXHr4OCIKAPjWV0rjKNe24IxgyM6vfVCpF1aNH5UZkODahfZHVsftMxuQ3Kd6yBddXX6lTYtYPBy4wbeNJAEb7y1k48V6L/N//RxIJ6/OQ2FTw8vwHLLq2sRGXO+4wDAUFpNx3P6aiIjzef592Tz/V0iYB5pCz+IGDsLtyhbJHHyV0VuNsbqZtnEPHhLnoUFDx/B4cOjRNQk9uZgH7fjtBRrzuhnNSuYSAQQ7Y//gJDmeTKO7QgfA/tiK18AMyMTGRPn1q3uysqciSpei0elZ8tANdrhIBE70eaEf/e4L588fTnK9sqOAX4sqwcd1R2da8NKO7lFEp2OYvfXp69QESCcpu3aqiR2zCw5E7O99wH0EQOD9kKIbsbDouX45tVGSd/JjxUyzLk8wbsY92U/Lps8Pr+BOAXb8c4dS2YmQOFbz0iSjSjYYo0nXjyk8/kT1zFgalkk6bf2vWAke1kTT/CxRLl4KrK4F/7kKiaFgYVfmVywgLQ7GhjIsBz+H7tGWdvW9FfnYhB7edJD25EENxzZ2ywSxqXXsKlL/8DHKDgfKnnqTvBx9Y9Lzo6Gg2btxY4/nrmxHUl4pyHd/P2oH+igoBE71HuxIY3JmtS49TlFOOVCqh38OdCbnbx+K1Xn1mpjnkrzKCRHfx4g1jlAFdrs20w8ORu7qiS08n5Z4RoFDQ7fAhpNZ1X66asmInq06ZG8qO62XDzGfqFj205YcDXNhbjsJFy8SPLWs03Ng0qUgvXryYTz/9lKysLEJCQli0aBERETdvQ7Ns2TK+//57jh8/DkBoaCizZ8+ucfzNEEW6bpgMBuKHDsMuN5eiyAiiVqxoaZMAMGq1pNw9HGNeHt6ffoLjqFENul/q4ofolLuLKzJ3HN9JRmbV8PjwilI96oRczsdnk376CgjXhEpiW4F3dzsihnfH29eN4vxyjmy+yOkDmea6zBJws8mjy86FKPSFuP+wEo9aZsZ/Jzg4uNYC/0FBQSQlJdXbN73OyKp5eynOMCJITIQ94oGDyoXdq89i1Juwc1Zy7wvmQv+NgT4nh/IjR6qWSHTnU24YY+Xnh/7SJQS9HoW3N1127bT4Oa8v28bGFHNs98S+9rz32K3Ljq5ftpvL8QasvXU898F9Fj+zMWkykV69ejXjxo1jyZIlREZGsmDBAtauXcuZM2dwd7+x1u7TTz/NgAED6N+/PyqVinnz5rF+/XpOnDhB+zp2XxBFuu5c2LKFislvIgB2TR2fbAF5S5aQu+BLlD264/fzz/WOtc1P2ka7Xx5FAmTd/y2ekY/U26aiKyUc3HaCi8fyMRapEK5vvmJdgVd3WyKGB9LB/+aV3QqySjm0SU3KUXPtZ4lgxPvyXly0ifTfvA5ZA98YGgNdhYEt/04i42whEplA6EOeaNIlnDlkrl/dsacLw5/tblF1PEsxXLlCWdyRquUR7dmz/L2FvKJjx6qlEdvw8Dp1ZjGZTLz89Ta2phoBgcn93XhtdO1LJqsX7iLvJNj7Ghg3ZURD3GowTSbSkZGRhIeH89VXXwHmH5SPjw+vvvoqU6ZMueX1RqMRZ2dnvvrqK8aNG1enZ4oibRkHn3gSx8RENF5ehO3YbvEaaVNgKCjg/NChCBVaVPPm4TemHk1GTUaEpUOQZCWR4XYX7SfV3K+wJjRFpRzadgJ1Qj66Kwok13WQc+lgR5dQd7r0dcPJo+7V13JSizm4UU36SXP2otSow9M+i/tnPV3r2m5Toyks5Y+lp8hWF6NQyRg4NoDEnekUZJYikUDkGH/6juhU71rb9cVYWEhZfDyXJr1S4xiFt3dVGrtNeDgKn5svw5hMJp5b/DuxGSCVwJdP9GFUiHeN9/3hk+0UqWW4BAo88c+7G8Wf+tIkIXg6nY74+HjefffdqmNSqZThw4dz4MCBOt2jrKwMvV5Pu3Y1d8rQarVotdqq74uvq68rcmsC58wmbdRo7DMzOb5wIcFvvNHSJiF3dqYoLAyHvfvIXrasfiId9w2SrCRQOdJ+/Dd1vkxXYeDU4Usc3nYKbd5VYVaaV5qVWty7qgi/uxu+gTX/c9eGeycHRr/Wm4wzBez89x40Wjsul3Xk+3f30vd+P0KG+aBQNu8HZWFeMT/N3otQpsLKWk5glCd71pzFoDNh42jFiAk9ad/1xs285kDm5ISqVy/zN1IpXXbuQHv2LGVxcZTGxVFx/AT6y5cp2riRosq1ermHR7U1bSs/XyQSCVKplG9evp8pPx9j7dHLvLE6EaVcyoieNw9bdHZ0oYhCvDrUr+51S2CRSOfl5WE0GvHwqO6gh4cHp0+frtM93nnnHby9vRk+vOYd2Tlz5vDhhx9aYprIdTj5+ZHy8EMo1qzFtOJ7Sp9+Blv3xgl9awh+r71G3t59OJ4/T+bhOLwi6h7PXZZzEetdM83CevcHYFd7G6vy0gpOHb5EzrlyUpPzMehNXBVmwUqLW4CSvkO7ENCrY0Ncqkb7bs48PX8ku554kwxlKKV27Tm0UU3Sn5cIu9+XnoO8Gz0p5WbkZxeyau5+KFchSIzYtbMm6c9LgLnmxz3P9cTGoWVrKV+Nj1YFBqLw8kLh5YXd4MEAmEpLKUtIrFoeKU9OxpCdTfFvv1Fc2ehY5upabXlkziMhGAQJ6xMyePnHeGaN6MCTQ26MiJFhfrNp5+rUPI42As2azDJ37lxWrVpFbGwsqlo6irz77rtMnjy56vvi4mJ8fHyaw8TbhpB33yNx+w5sCwpI+fhjgr9c0NIm4R4cjLp7II6nTpO6aBFeK7+v87V5P71IR62GCpceqEKfvemY8jItcTtPcvZIFhU5ciTCtdmrg5s1Tp2kdA33JCDIp8n6Q8pkMoYsmkLKqDFkWncjtc/TlBbDntVnSdyRRsQoP7pGeNY7rflW5F6+wpp5h0Br/v+SSmRcySgHCYSP9CPsAd8me7YlXBVpm/AbO6NIbW2xGzgAu4HmdHVTeTnlx45VRY+UHzuGMS8Pze9b0fy+FQCZszNvhIbiZ3BhvaQ97/9uQKWQ8dCAXtXufbWjvJV128njs8hSV1dXZDIZ2dnZ1Y5nZ2fj6Vl7VtRnn33G3Llz2bFjB8HBwbWOVSqVKJW1l40UqR25tYp2b72F9r33UOzYQcXZs6jq2FC2KfF88UXK//kGdvHxFKWm4tjp1vV8M/evpmPhQQRAc9eHqKTXxFdbriPuz5OcicuiPEtWKcyVM2aFjqCBnejRrwOuPnaNXhioJhSenni+OwXhvfdw/zOZon8t5swJE5r8CnYuP1WVvegX4tqoNmWm5fHzZ3HVquwJJnMdknue64lP9/o1420Kyo/EA2Bdh070UmtrbKOisI2KAsCk1VKRlFQVPVKekIixoIDSHTu4B7gH0CisOXnIl71DIwl9eCSq7oFI5HKKCsy1WYzoa35gK6NeG4cREREsWrQIMC/cd+zYkVdeeaXGjcNPPvmEjz/+mD/++IOoyh+0JYgbh/Xn0quvodm+HZuICDquWN5sQlUbh4cOwz4zk5IH7id8/vxaxxp15RTP64WzMY+L7vfg+/I6jAYTl04XcP5INmeOZCIYrivVKdfh7CcnZJAvPcL8m6ej+k0QBIEzMeMQjhxB4+FB8ObfObkvh6N/pKItM8/m3H0diIr2xyew4eJ5SZ3Nhi8SkOirL2N4BzgxYkLPW9bKbk4MBQWc69cfgID9+5DXsj9VF6rKs15NsDl6FOFm5VlD+/K75D4MEiciH3MnbFivGu5YeV9BuOn/S03HLaVJQ/DGjx/P119/TUREBAsWLGDNmjWcPn0aDw8Pxo0bR/v27ZkzZw4A8+bN44MPPuCnn35iwIABVfexs7PDro75/qJI1x99RgYpD4xE0GpRTZ2KX8wzLW0SJ//7DZLPPkOnVBK4ZzfKWn6nF1e+hm/KCjSCPUlhqzl3rARdnhJ9xbV4OUGmw6mTjKBBnQiK6FKtEFJLUqhWkxr9EFY6HaXR0YTNnYO2TE/C9jSO7UzHoDP70CHQmagxnfHwq9/fdmFOGb98doTy4uqp633v60TkKL9W8/O4imbnTi5NegWrzp3p3AS1xgWDgfz4RJZ88SMdMlPpla/G1mAORNjX7yO0SmfCk+bjGehRFT2iCgpCel3tkGPHjjFx4kTWrVtXbak1PT2dsWPHsnTp0gZngTZpMstXX31VlczSu3dvFi5cSGSkOT5xyJAh+Pr6snz5cgB8fX1JTU294R7Tp09nxowZjeqMyM1Rz5mLdsUKym1t6bFzByonpxa1x6jXc2zAQKyLi3GeMgXPf4y/6bgr6mMUL3uNCxVRnNbehcl0LSPN2sGKLn3c8A91w7uzU6sToqskL1qEfPG/MUmlOP33v7Tv3w8w9wo88vtFTuzOwGQ0/wv693YjcrQ/7bzrHv5XkFXKhi8SKCu6lrautJUz/B898A1ybVxnGonsufO4snw5To8/jteHM5rsOfnFpYyev43Mcjndi9OZ28XI3jNdMEmVRB2agU15btVYiVKJde/e5oJR4WHc9+qr7IuLw9/fn9jYWHx8fEhPT2fIkCGo1WoiIiI4ePBgg2bUYlq4SBVajYbjw+7GRqNBM+IeIhYubGmTyPv+e3Jnz8GqUyf8t2yuKghlMgmknsphz6/H0KaVozNdq2EsSPXY+0DwQF9CBnRtFRtgt8JkMnH4oYdxPHMGjbsbfbdtQ37dpnlxXjlxv13gzKEsBMFc3rRrpCcRD/rh4Fp7mvS55DT+Wn4Bbamx6pinvwMjnu+FfbvW06Xn71wY+ygVx4/j/emnOI56sEmflVOgYdQXO8jWWSGtKObNCnNk2kPjnFGpT5L3118U7N2Lw99lUKHguFbLnitXuOTkyL+WLSPm+edRq9XVhLshiCItUo3T369EmD0bk1SK608/4nGT4urNiam0lHNDh2EqLsZ74UKy3buTfaaM80dzqs8KJRqs3HQEDulB30HdkCvazq78VYouXuTimGistFpKRo0i/NNPbhhz5XIph35Vo04wz+6kMgk9B7Un7AHfm4bLnTyqZtd/zyMxXft59B7uQ9RDnVu028itMJaUcjYiAkwmuvy5C4VXwxvZ3orMKxoGfbAWqa0HrxeZP/gmzB9Abn5O1cx4TGgo3775JuWVmZGG3Nxq98g1GBh1QY2rr2+jCDSIIi3yN0wmE4dHjcYxJYWiLp2J2LSpxTbVrtqT8P4CMhLzyfIMQ6+4VjfCylqGr2wPXRU7cImMwC76RlFraxz/z3+QfbkQk0SC07KltB848Kbjsi8Wc3BDCpdOFwAgt5ISMsyHPiM6VjUNSDp0jt0rLlQJtJVKxt3/6IF/75aPhb8VJXv2kv7CCyg6dKDLju3N9tzE02piFu3jJWN7jAh4j4J3Xpt405mxIAjoLlzk7KuvIk8x1x25KtK/79lD//79G8UmUaRFbiA7IYG8p59BajIhmfoegTExzfp8k8nEqaMXOLb7AlfUBiSG62eIenx7u9Ozvw8+Wf9Btv8zcOgAkw6BsnG6UrckJpOJuLGP4nDyJFZdu+K/bm2tRe4vnb7CgQ1qci6as23lSgmxJ37mqQkPk7rbWBUD7upjy30Tg3F0a7mGqpaQ88UC8r/+GsfoaLznzmnWZ/++NQ71Bg3lEoEliktc+OZ1fD1dbpgZF5w7x9nXXsPhwkUA9pSWMjXzMnlGY6MtdUDdda31vheJNDoeffpQere5XkHpoq/QlZbe4oqGIwgCuekaDmxI4Zu3Y4n9byoFZ6VIDFYIEiP25WcIOv41vXO/ZeRLfXC0TkFyoLL06P1zbwuBBnP5hL5Lv0bm7Izu7FnyliypdXyHwHaMfSeU+18KwtnLFoNWYGCXh0n7iyqB7nGXF2PfDm8zAg3XJbGE3To+urHp6esLgA4TFQYTUitrVq5cWU1wTyz5mrRHxuJw4SIGmYwVKiXzrBRs3L0bf39/1Go1Q4YMIf3vNbSbEFGk7zCCZ82kwtYWm+Jirnz7XYPvl5ycTNeuXW8otXkuOY3VC3exYupe1nwcx9GtqehKQJAYUbpr6fmAExM+G8TdL/bGLS8J55PJ5CYnU/HzK0gFI5l2QRDYtJtKzY3C1RXP6eZa03lfLyXv0KFax0skEvx7u9F9lBXHM/bdcN67szMSWevfPL3K1SQUAJuwGzMNm5rcytZZJQUZZP34DobCLGJiYkhPT6ckO5uDjz+BdMECrHQ6chwdGZeXy1qNhtjYWPr3709sbGyVUI8dO5bmWoQQlzvuQPI3biTnnSlIVCo6b/6tTmUha+Jqwfro6Gg+n72I+J3nyDlXAdpryRMyuZROvVzoHOpG+0BHbO2rz/wOPjASR7UaTa/2RPSKQ4+csn/swtG34d1IWiPqSZPQ7txFSbt2hOzYjtUtmrpGR0fjz1A6ewbdcK6dty1RY/zxDW7c7MWmoCwujtSYccjcXAnYvbtZ7U1PT+eFxyYzKuT/uFRwjlGvBxETE4NarebJnj35l1KFdWkpJomEsgfuR/7EE7z0yittN066uRFFunERBIG0ceMpi4vDfsQIOiz8sl73SUxMZMSQkTw07B90dQ9FhdO1Z2DCykVPQJgHA+4PxkpVc1TGubVrMbz/ARK5QMDoLDZrezH68731sqktoMnIIGXkgygrKtDcO4KIL2v++V9treXn0YMu3kHsObEJk0ng56V/kpWsq8pe9PBzICq6Mx26tUxlu7qQ95//kPvlQuzvv48OXzRuN53aEASBqKgo7A0+PBT+Mk4d5Tz93l2kpaTw4333E10Z/lnq6IjbR7PodM89Vde1yYzDlkAU6can4sxZLjz8MBiNyD/6iICxdS+eLwgCl04X8N95v+Cq9EUqMa+aCZhQtNPh19uVyOE9cGxXt/Vkk8nEyf4hyAoN2ATp6L4plQOH4xulr19r5dR338G8TxAkEuy+WkTHu29e27i2BrX/+2ENCdvSSNqVXlnlD3y6OxMV3Rn3Tq3v/yTtuQmU7t+Px/vTaPf008367GPHjrH88010sRmAykPHfffYUT5nLvrK6A3dsKF0mz27WRO9RJEWuSWHJk7EYfceSp2d6b1rF3Lr2hMgdOUGTh/M4vhflyjIulYbIaPoLCn5Cew4vJ5df223WFzzju9CMucZcuIduWItY8jxM43eJbs1cvDxx3E8lkSpszPBO7ZjZVs907CuDWpLi7TEb7nIib2Xq7IXO/dxI2K0P+286p692JQIej1nIqMQysrw27gRVbfmL/a15qs/yT0uYG86T+jeL5GaTMhcXfGaNQv7oUOa3R4xukPklvT66GO0KhW2BQUcm1NzOFRBVim7V51l+ZR97Fl9loKsMgwmHbtPbGTW6n8wZ9X/sWb7UopLC+qU6l9tXmAyYdz4OmVZ5nC0Q9kFGAwGNmzYwLFjxxrqYqum5xdfUGFtjW1BAYnvvHPD+Vv9LKdPnw6AraOSu57sxlMzougW6QkSSEnIZdXMQ+z8/hTF+eVNYb5FVJw6hVBWhtTREWVAlxaxQZdfBIDzpYtITSaKAgPx3bC+RQTaEkSRvoOxdXdDWtnCTLF+PYUXLlSdM5kE1Im5bFyQwE8zDpEcewm91oiThw3+A22YsvwR1uxdSHbhtVCkuojrsWPHiIqKuhbClPA99pezKMmwxigILMrLA8yv9HWt7dJWsff2RvXGPwGw27mLi3/8Ue28Wq2u9fq/n3d0s2b4sz14YloEfiGuCAKc3p/Jj9MPsmf1WcqKdTXcqekpi6sMvQsNRdLMSVQmk4mkBV9ifdQcgSQRtOhfnEjELz9j5do665tcj7jccYdjMho5cvdw7LOyKOrTh97LVnBy32WO/5WB5kqFeZAEfINcCR7agQ6Bzjz00ENsrGxrdDPGjBnDhg0bbjh+dQPn8OHD+Pv7s/v3X3BfM5KMrUrK86xYU1jAjL/VKr/6Sn87c/DJp3BMSEDm40OXXzchraUhhiVkqYs4uDGFjDOFAMiVMnrf7UPvezqibOai9+n/9zIlf/6J+1tv4TLhuWZ7riYjgxOvvILjqdMc7/4sOR5heAaU8Mib9Wjf1siIyx0idUIqk+H5/jSK7Tpwuawn3729mwPrU9BcqUBpK6fPiI7EzOrHyJeD8eneDolEYvEM7yoSiYR169ZVxZoe/WQ0FRf1lOdZUW4ysTgv/4Zrrr7S386ELFqIzM0NY3o6uQvqF2lzMzz9HRnzzz6Mfr037p3sMWiNHNlykZXT9nN0WyoGnfHWN2kEBJOJsqNHgZt3YmkqSv76i8uPPYbjqdOYpFKKXc2NSWy9a2+91tpoe9VqRBoNo8FESkIOyfFOZIVVNhc2gauPHcFDOxAQ5oHc6sYGqkmVCQn1wcfHh9jYWKY8NYQHvfNQbzXXm/i+4Aq5RsMN42/1gXA7YO3qitesmVx66f+4smIF1kOH4FBZ+rehSCQSfLq3o0OgM+rEXA5tVFOQVcaBX1JI2plO2Eg/ug/watKiTNpz5zEVFSGxsUHVvXuTPecqeo2GvM8/p3DVagAkHTviMG0qul9LQAMq25bt72gpokjfgZQWajmxJ4MTey5XrVNKpOCWm4BP6k663hVDu/4RTfZ8Hx8f5r4wgqLtG9AVKyg0Gnnsf/9jQS3NiW937IcMwSE6muINGzj32uv02vYHSkfHW19YRyQSCZ37uOMX4saZg1kc/k1NyRUtf/10hsTtaUSM9iMg1ANJE5R/LTsSB4BN795IFIpGv//1pO3cSc57U7EtMm8Sths/DrfJk5Eqldhu34NGo8fDq/WvQ1+PKNJtkXPnQKO59Th7ewgIAMzrwVkpRSTHXiLlaC4mk3krwsbBip53tafnIG+0v2aS/dEF8r78Eof770Pu3DSJEenp6Yz4cBvfyG1xlsCS/Dz2vvhioxWuaas4TZ5M9vbt2BQVkfjWW0QuXdroz5BKJXTv70XXcA9O7M3gyJaLFOWWs/2bkxzdmkbUGH86Bbk0ajZgbU1nGwujVsvRqVOx2bwFW0FAa2dHl4VfYnd9xTqTDNDj7Np4H37NgSjSbY1z58CChrL6E6c5V2BPcuwl8tJLqo57dXYkaEgH/Pu4IZObX3VtnnicwrVr0Z45Q8rMmXRrgqywq90thhQW4uzmjtGlHYf0uqrCNXeyUNu6u2H39tsYp0/HYfceUjZtovPoptngkimkBA/1IbCfF0m7LpGwLZX8jBI2/zsJr86OREX74x3Q8A9pQRCuK6rUNCKdnZBA6huTsc/KAqAoOJheixZi5+FRbVxVp/Basl9bI+LGYVujLjNooNjek/2RE1nx9WX+XHmavPQSZAop3ft78dh74Tz8VigB4R5VAg0gkctxqWwmbPx9K+mxsY1quiAIjB07lvyLF3nJ1bwW3eGtt9jeQoVrWiNdH3+MokjzUlPhRx9RUVjYpM+zUskJe8CXmI/702dER2QKKZkpRaz/PIFfFyWSm1a3v7ea0KemYszNQ6JQoAoObiSrzZhMJhLnzSMnJgb7rCx0VlYYX3+NqDWrbxBok8mErtws0jKr1l3j5O+0rY8UkVoRgEvtQ0nqFc3FTlHmhWatgL2Lil6D29Ojvzcqu9rXBB37RXEqJATHY8e4PHMW7QcNQiq7cfOwPkgkEpYuXcqOmHHY6XQou3bFcdQonGQyYmNjqwrXtPZCQU1NyPz5nLr3PmyKNRx7800iv/mmyZ+pslXQ/+EuhAzzIW7LRU7tvUzaiSuknbhCl1B3Ikb54expefbi1Vm0KiQYqbLxOpYbcnNRv/kmysPm9e4iX1+6LvySdjW8ZWrLdQiVvYul8rY1CRBF+jZAp7DhdNcRJPccQ6Fzx6rjPulHCJowmE7RERb1AwycM5u00WNwuHyZ4199RfDrrzearT3c3VFi/kBxf3NyVW9DHx+fBjf2vF2wdnHB4d0p6KdOw2Hffs7/sp4uDz/ULM+2dVIy5Klu9LnHh8O/XuBsXDbn43NIScglsJ8n4SP9LOqfeC2JpfGWOoq3byfr/Q8wFhYiyOWUP/ooEdOm1jqZKCk2Z10KCNjatZ362yCKdJvnTMBw/hr4Onorc7lLha6UwDN/EHRyE86F6TArHizcsXfy9yfloWgUa9dh+m45ZU89hY1b47Rmyl30FYJOh014OLZ33VXtnCjQ1+jyyCMc/G0zjgcOoPviC4wjRiCza746HI5uNtzzXE/6jOjEoU1qLiblcWpfJmcPZdNrcHtC7+uEtf2tQ9nK4uOBxlmPLs/PJ/mfb2AfZ549K7t3p/0n81BWbo7XRmmlSCMxttrO8jXRtqwVuQHngjT0VjY4F6Ry196F/OOHJ7hr/2KzQDeAkPemUurkhLKiguRp7zeKrRVnz1JUmYno/q83RVG+BSHzP0fm5YUkN5ecTz9tERtcO9gx8uVgHn4rFO8AJ4wGE8d2prNy2gEO/6quWue9GfrMTPSXLoFUinUthaLqgvq3zZy6737s4+IQAJeJE/FbvapOAg1QqqnMnpWZGmRHSyCKdBvHPe8sj2x4lSfXPEfQiY1Y6ctufVEdkFurcHxzMgB2u3dz+RZdROpC7hcLwGTCfsQIrG/zVO/GwNrZmfZz5wJQuHo1JXtbrsa2V2dHoif3YdSrIbh1tEevNRK3+SIrpx0gYXvaTbMXy46YZ9GqHj3q/RZgKK/g8KuvUfGvf2Gt0VBub4/1/M9xn/xGrT0i/055iVmkJbK2tR4NokjfFnhmn6Qp5qQBjz5KUfdApIJA2ZcLGxR1URYfT8mff4JMhts//9l4Rt7m2EZG4PzMMwCcf2My5ZUFqFoCiURCx54uPPpuGPe+0AsnDxsqSvXs//k8P3xwkBN7MjAZr81UGxp6d/nQIRJG3IP99u1IgKKwMLpv/R2/Bx6w+F7lpVqzD21s0xBEkRa5BUHz5yNRKtEfPYrmb1Xa6oogCOR89jkATo88gtLfrzFNvO1xef01yhwcUGo0HHtjckubg0QioUuoO09+EMHQmEDsnJWUFmqJ/fEMP314iHNHshFMQr2TWASTifNffMGVZ5/DLjcPrUoF77xN1A8rsXZxqZfNFaV6AKRNm/DYJIgiLVIrtn5+uLzwAgDZc+dhrEeH8ZJduyhPSECiUuE6aVJjm3jbo7C3x/mDDxAAx7g4zq5a1dImASCVSekxwJunZ0Yx8NEAVHYKinLK2fbfE6yedYDLBSoEwLpv3zrfU5+ZSdpzE9B/vRSZyURRQAB+G9bT/dlnG2Srva05y9DFrfW2F6sJUaTbGvb2TTv+Jrg8PwG5tzeGrCyOTp1q0bWCwUDOfHPmYrvx41F4tK0KZK0F/wdHohlsjoYp/eRTSnNyWtiia8gVMkLu9iHmo35EjPLDSiUjP7OCpOCXSez3Hjn5dVuMO/vNN6jHRFN28CASa2uc33uXiI0bcPT1bbCNCpk5Rrudm1OD79XciCF4bY2AADh71uLaHQ1BqlJhGDcO5s7Fett2cpKScK9j9ljRhg3oUlKQOTri8vyEBttyJ9P7009JvmcEtkVFJP/zDaJ++rGlTaqGlUpO+Eg/ggZ3YPeHq0kpdKVA2Z71nx2lUy8XIsf44+Zz46ShJDub46++imOSuSi/KjgY73lzUfo13rKYrtxYaWPjJGY1J6JIt0UaQXgtpdu4GA6vWYOjWo166jTcf910y2tM5eXkLvoKAJf/ewlZI8zq72SUDg64fjiDsn++gePRo5xeuZLAmJiWNusGVHYKuqT8gvv5y2Q/MZOUSwpSj+eTejyfgDB3Ikb54+Rhjus///PPaGbPwbG0FJNEQvmoUQTO/hiJvHGlqTC/GABB0jw1tBsTcblDpE5IpVJ8P5qFSSrF8dw5zvx461nclR9+wJCdjcLbG+ennmoGK29/fO+7D82wYQDoFy7C2MS1PeqDUaNBe/oMSl0RwyaE8NT0SALCzbU0zh3J4acPD7Hju2T2TPwn+qnTUJWWUuroiP1Xiwj7ZF6jCzRAZoa5409+YW6j37upEUVapM549u1L6bChAJR8uRBdLZuIxsJC8pcuA8D1tVeRWhDTKlI7vefNhQ4dkGs0ZH08u6XNuYHyhAQwmVB07IjCwwMnDxtGTOjJ49PC6RTkgmASOHMol+Pcz7nOD5Hffyi9/thKx7vvbjKbDDpz6J3Suu2Fd4giLWIRQTNnUmFjg01xMUkzZ9U4Lm/pMkwaTVURJZHGQ2lvj+/nn4FUSvGvv6LZsaOlTapGVb2Ov8VHu3jZECU/RN+kL3EsPI9JqiDdZzgnHR4neV9BVSnRpsCkN4u0ykYUaZHbHOt27VA8/zwAqt9+ozz9xvRzfWYmBT/8AFQvoiTSeFiHhOAywbwRe3HKu2gyMm4Y01IlX2+WxFKqVpMaM47cL77A6cpZ+lof4O4n2+PqY4e+wsjhXy+wctoBEnekYdA3/rqxqVL/21rrLBBFWqQe9HjpRfQBAciMRvI/n3/D+dqKKIk0Hq6vvkJJu3bIS0o49uqr1c6lp6cTFRXFsWPHmtUmU3k55cePA+YkFpPJRNL8L1CPHkP50aNIbW3xmjOH7t9+S+Dgbjz2bjgjnu9pzl4s0bNv3Xl+/OAgJ/ddrpa92GC7DOYwQGu7xiuX2lyIIi1iMVKplK6ffQpSKZqtWyk9cKDqnFhEqfmQKBQsUSgwSSS4nDzFwcpOOle73xw+fJiJEyc264z65IYNoNcjtGtHhUTC4YcfQbF0KXKDgTI/X/w2bsTpoeiqvwuJVEJAmIc5e/EZc/ZiSYGWP1ee5n8zD3M+PgfB1Aj2Gyu7D9nVvcxqa0EUaZF6oerWDecnnwQgffoMDBXmAjZiEaXmQyKRMOOHlfxVmSqt/G45f23axJAhQ1Cr1fj7+7Nu3bpm/aD8c/FiAApLS0kZNRrH06cxSaWUjX2E3ps2YdWh/U2vk8qk9Bhozl4cMLYLKlsFhdll/LHsOGvnHiHtRH7DPmxMZqmztRdFWuQOInvYUMrkcoS0NJLmzqPsyBFzESWplEn79zX7q/adiI+PD/d/9y359naodDqyZ82qEujm7heZmJiIfeUehbNWi6q8nJJ27XBc+jWhH32ErA6dwuUKGb2HdyTmo36EP+iHQiUjN03Dr4uOsWF+AlnqIovtMhiMSATzvoiDs53F17c0okiL1AtBEJg4eTI/VDYUkP/8M5dnfQTA73o9m+Ljm/1V+07FLyAA7YsvYgSCNCUEqVSsXLmy2Rv6zpw+nd7WNlXfJ3T0IWT7NjoMHGjxvays5UQ86EfMR/0IGe6DTC7l8rlCfv4kns3/TiLvUsmtb1KJQXttbdvWoW11ZQFRpEXqiUQiYd26dfxaWkqWvR0KvR79mTNUCAJzL1xokVftO5X09HQmzpnDvOxsJqank1xRQUxMDOk3ibxpKhITE1m/aROXtFquKBS8q9fx9PbtnDp/vkH3tbazYuDYAJ6eGUWPAV5IpBIuJuWx+uPDbPvmBEW5t66ffrUxgVwhRdbGurKAKNIiDcDHx4c/Y2P52nRtprLiyhXsO3Vs9lftO5Wrm4RqtZr97ZyZt31bVef1IUOGNJtQz5gxA7lcTvTFCww8nsxGtRq5XM6MGTMa5f727VQMjenOU9Mj6RLmDgKci8vmp+mHiP3pDKWF2hqvLSk2C3lb6xJ+FYnQBt5Hi4uLcXR0pKioCAcHh5Y2R+Rv7N+/nx/HPko3iYT3sjLZtmcP/fv3b2mzbnsEQSAqKorDhw9XW4O+XrgjIiKavMFvYmIifWppj5WYmEhII28i56ZpOLhRTdqJfMA8Sw4a2oG+93ZCZXtt7VsQBBL3n2X/ygwEKy2vLLy/6nhLv+XVVdfEmbRIg0hPTycmJoZ/Z17m9csZlJpMzf6qfacikUhYunQpERER1d5cfHx8iI2NJSIigqVLlza5GN1qtjx9+vRGf6ZbR3tGvRrCQ2/2xauzIwa9iYRtaaycup8jWy6gqzBw7NgxoqKiyMowl3WVVnZlaakY8voizqRF6s31MzZ/f39WrlxJTExMi0UX3KnUNCtsrtlicHAwycnJNZ4PCgoiKSmpyZ4vCAKpx/M5uFFNfuWGorW9gr9O/cJPvy/mqQdfJMLrIWQOFYx8NahZ3zJqo666Joq0SL1oLa/aIiJXEUwC5+NzOLRJTVFuOQBF5XkUVmTSyTkIHDTM/3lyq5lEiMsdIk1Ka3nVFhG5ikQqISDcgydnRDLk6W7YOlrhaO1qFmggMzuj1Qi0JdRLpBcvXoyvry8qlYrIyEgOHz5c6/i1a9cSGBiISqUiKCiILVu21MtYkdZFSEgIBw8evOGP3cfHh4MHDzb6ZpGISF2QyaT0HNSeZ2b1o//DXZBamRcLLmacA2iRGPKGYLFIr169msmTJzN9+nSOHj1KSEgI9957Lzk19Fzbv38/Tz75JBMmTCAhIYHo6Giio6M5XlmERaRtU9NMWZxBi7Q0cisZrt0lLPzjdZb+8QFr/1oC0PY2tgULiYiIECZNmlT1vdFoFLy9vYU5c+bcdPxjjz0mjBw5stqxyMhI4cUXX6zzM4uKigRAKCoqstRcERGRO5S0tDTB399fAAR/f39h37591b5PS0trUfvqqmsWzaR1Oh3x8fEMHz686phUKmX48OEcuK4S2vUcOHCg2niAe++9t8bxAFqtluLi4mpfIiIiInVFEATGjh1bbQ26f//+xMbGViX7jB07tk2ULbBIpPPy8jAajXh4eFQ77uHhQVZW1k2vycrKsmg8wJw5c3B0dKz6akvrRyIiIi3P7bSx3SqjO959912KioqqvtrU+pGIiEir4HbZ2LaoLa+rqysymYzs7Oxqx7Ozs/H09LzpNZ6enhaNB1AqlSiVba+DgoiISOvidtjYtmgmbWVlRWhoKDt37qw6ZjKZ2LlzJ/369bvpNf369as2HmD79u01jhcRERERuYZFM2mAyZMnM378eMLCwoiIiGDBggWUlpby7LPPAjBu3Djat2/PnDlzAHj99dcZPHgwn3/+OSNHjmTVqlUcOXKEpUuXNq4nIiIiIrchFov0448/Tm5uLh988AFZWVn07t2brVu3Vm0OpqWlIZVem6D379+fn376iWnTpvHee+8REBDAhg0b6NWrV+N5ISIiInKbItbuEBEREWkBxNodIiIiIrcBokiLiIiItGJEkRYRERFpxYgiLSIiItKKEUVaREREpBVjcQheS3A1AEUstCQiInK7cFXPbhVg1yZEWqPRAIiFlkRERG47NBoNjo6ONZ5vE3HSJpOJy5cvY29vb1HOfXFxcVXfvdsxvvp29w9ufx9F/9o+9fVREAQ0Gg3e3t7VEgD/TpuYSUulUjp06FDv6x0cHG7bPxC4/f2D299H0b+2T318rG0GfRVx41BERESkFSOKtIiIiEgr5rYWaaVSyfTp02/b2tS3u39w+/so+tf2aWof28TGoYiIiMidym09kxYRERFp64giLSIiItKKEUVaREREpBUjirSIiIhIK0YUaREREZFWTJsX6cWLF+Pr64tKpSIyMpLDhw/XOn7t2rUEBgaiUqkICgpiy5YtzWRp/bDEv2XLljFo0CCcnZ1xdnZm+PDht/x5tDSW/v6usmrVKiQSCdHR0U1rYCNgqY+FhYVMmjQJLy8vlEolXbt2bdV/p5b6t2DBArp164a1tTU+Pj688cYbVFRUNJO1lrF7925GjRqFt7c3EomEDRs23PKa2NhY+vbti1KppEuXLixfvrxhRghtmFWrVglWVlbCt99+K5w4cUJ44YUXBCcnJyE7O/um4/ft2yfIZDLhk08+EU6ePClMmzZNUCgUQnJycjNbXjcs9e+pp54SFi9eLCQkJAinTp0S/vGPfwiOjo7CpUuXmtnyumGpf1e5cOGC0L59e2HQoEHCmDFjmsfYemKpj1qtVggLCxMeeOABYe/evcKFCxeE2NhYITExsZktrxuW+vfjjz8KSqVS+PHHH4ULFy4If/zxh+Dl5SW88cYbzWx53diyZYswdepU4ZdffhEAYf369bWOV6vVgo2NjTB58mTh5MmTwqJFiwSZTCZs3bq13ja0aZGOiIgQJk2aVPW90WgUvL29hTlz5tx0/GOPPSaMHDmy2rHIyEjhxRdfbFI764ul/v0dg8Eg2NvbCytWrGgqExtEffwzGAxC//79hf/+97/C+PHjW71IW+rjf/7zH8Hf31/Q6XTNZWKDsNS/SZMmCcOGDat2bPLkycKAAQOa1M7GoC4i/fbbbws9e/asduzxxx8X7r333no/t80ud+h0OuLj4xk+fHjVMalUyvDhwzlw4MBNrzlw4EC18QD33ntvjeNbkvr493fKysrQ6/W0a9euqcysN/X1b+bMmbi7uzNhwoTmMLNB1MfHTZs20a9fPyZNmoSHhwe9evVi9uzZGI3G5jK7ztTHv/79+xMfH1+1JKJWq9myZQsPPPBAs9jc1DSFxrSJKng3Iy8vD6PRiIeHR7XjHh4enD59+qbXZGVl3XR8VlZWk9lZX+rj399555138Pb2vuGPpjVQH//27t3LN998Q2JiYjNY2HDq46NarWbXrl08/fTTbNmyhfPnz/Pyyy+j1+uZPn16c5hdZ+rj31NPPUVeXh4DBw5EEAQMBgMvvfQS7733XnOY3OTUpDHFxcWUl5djbW1t8T3b7ExapHbmzp3LqlWrWL9+PSqVqqXNaTAajYaYmBiWLVuGq6trS5vTZJhMJtzd3Vm6dCmhoaE8/vjjTJ06lSVLlrS0aY1CbGwss2fP5t///jdHjx7ll19+YfPmzcyaNaulTWu1tNmZtKurKzKZjOzs7GrHs7Oz8fT0vOk1np6eFo1vSerj31U+++wz5s6dy44dOwgODm5KM+uNpf6lpKRw8eJFRo0aVXXMZDIBIJfLOXPmDJ07d25aoy2kPr9DLy8vFAoFMpms6lj37t3JyspCp9NhZWXVpDZbQn38e//994mJieH5558HICgoiNLSUiZOnMjUqVNrLX7fFqhJYxwcHOo1i4Y2PJO2srIiNDSUnTt3Vh0zmUzs3LmTfv363fSafv36VRsPsH379hrHtyT18Q/gk08+YdasWWzdupWwsLDmMLVeWOpfYGAgycnJJCYmVn2NHj2aoUOHkpiY2Cpbq9XndzhgwADOnz9f9QEEcPbsWby8vFqVQEP9/CsrK7tBiK9+IAm3Qa23JtGYem85tgJWrVolKJVKYfny5cLJkyeFiRMnCk5OTkJWVpYgCIIQExMjTJkypWr8vn37BLlcLnz22WfCqVOnhOnTp7f6EDxL/Js7d65gZWUlrFu3TsjMzKz60mg0LeVCrVjq399pC9EdlvqYlpYm2NvbC6+88opw5swZ4bfffhPc3d2Fjz76qKVcqBVL/Zs+fbpgb28v/O9//xPUarWwbds2oXPnzsJjjz3WUi7UikajERISEoSEhAQBEObPny8kJCQIqampgiAIwpQpU4SYmJiq8VdD8N566y3h1KlTwuLFi+/sEDxBEIRFixYJHTt2FKysrISIiAjh4MGDVecGDx4sjB8/vtr4NWvWCF27dhWsrKyEnj17Cps3b25miy3DEv86deokADd8TZ8+vfkNryOW/v6upy2ItCBY7uP+/fuFyMhIQalUCv7+/sLHH38sGAyGZra67ljin16vF2bMmCF07txZUKlUgo+Pj/Dyyy8LBQUFzW94Hfjzzz9v+j911afx48cLgwcPvuGa3r17C1ZWVoK/v7/w3XffNcgGsZ60iIiISCumza5Ji4iIiNwJiCItIiIi0ooRRVpERESkFSOKtIiIiEgrRhRpERERkVaMKNIiIiIirRhRpEVERERaMaJIi4iIiLRiRJEWERERacWIIi0iIiLSihFFWkRERKQV8//ldVR7GVvDnQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use same initial td as before\n", + "model = model.to(device)\n", + "out = model(td_init_test.clone(), phase=\"test\", decode_type=\"greedy\", return_actions=True)\n", + "\n", + "# Plotting\n", + "actions = out[\"actions\"]#.reshape(td_init.shape[0], -1)\n", + "print(\"Average tour length: {:.2f}\".format(-out['reward'].mean().item()))\n", + "for i in range(3):\n", + " print(f\"Tour {i} length: {-out['reward'][i].item():.2f}\")\n", + " env.render(td_init[i], actions[i].cpu(), plot_number=False)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch200-py39", + "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.9" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/3.quickstart-ffsp.ipynb b/examples/3.quickstart-ffsp.ipynb new file mode 100755 index 0000000..5ca74be --- /dev/null +++ b/examples/3.quickstart-ffsp.ipynb @@ -0,0 +1,215 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PARCO for the FFSP\n", + "\n", + "\n", + "Learning a Parallel AutoRegressive policy for a Combinatorial Optimization problem: the Flexible Flow Shop Scheduling Problem (FFSP).\n", + "\n", + "\"Open \"Open\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import torch\n", + "from rl4co.utils.trainer import RL4COTrainer\n", + "from rl4co.models import POMO\n", + "from parco.envs import FFSPEnv\n", + "from parco.models import PARCOMultiStagePolicy\n", + "\n", + "# Greedy rollouts over trained model\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Environment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "env = FFSPEnv(generator_params=dict(num_job=20, num_machine=4),\n", + " data_dir=\"\",\n", + " val_file=\"../data/omdcpdp/n50_m10_seed3333.npz\",\n", + " test_file=\"../data/omdcpdp/n50_m10_seed3333.npz\",\n", + " ) \n", + "td_test_data = env.generator(batch_size=[3])\n", + "td_init = env.reset(td_test_data.clone()).to(device)\n", + "td_init_test = td_init.clone()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "Here we declare our policy and our PARCO model (policy + environment + RL algorithm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "emb_dim = 128\n", + "\n", + "# Policy is the neural network\n", + "policy = PARCOMultiStagePolicy(num_stages=env.num_stage,\n", + " env_name=env.name,\n", + " embed_dim=emb_dim,\n", + " num_heads=8,\n", + " normalization=\"instance\",\n", + " init_embedding_kwargs={\"one_hot_seed_cnt\": env.num_machine})\n", + "\n", + "# We refer to the model as the policy + the environment + training data (i.e. full RL algorithm)\n", + "model = POMO( \n", + " env, \n", + " policy=policy,\n", + " train_data_size=1000, \n", + " val_data_size=100,\n", + " test_data_size=1000, \n", + " batch_size=50, \n", + " val_batch_size=100,\n", + " test_batch_size=100, \n", + " num_starts=24, \n", + " num_augment=0, \n", + " optimizer_kwargs={'lr': 1e-4, 'weight_decay': 0},\n", + ") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test untrained model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "td_pre = td_init_test.clone()\n", + "\n", + "policy = model.policy.to(device)\n", + "out = policy(td_pre, env, decode_type=\"greedy\", return_actions=True)\n", + "\n", + "print(\"Average makespan: {:.2f}\".format(-out['reward'].mean().item()))\n", + "for i in range(3):\n", + " print(f\"Schedule {i} makespan: {-out['reward'][i].item():.2f}\")\n", + " env.render(td_pre, idx=i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "In here we call the trainer and then fit the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trainer = RL4COTrainer(\n", + " max_epochs=5, # few epochs for demo\n", + " accelerator=\"gpu\" if torch.cuda.is_available() else \"cpu\",\n", + " devices=1, # change this to your GPU number\n", + " logger=None,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trainer.fit(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluating the trained model\n", + "\n", + "Now, we take the testing instances from above and evaluate the trained model on them with different evaluation techniques:\n", + "- Greedy: We take the action with the highest probability\n", + "- Sampling: We sample from the probability distribution N times and take the best one\n", + "- Augmentation: we first augment N times the state and then take the best action" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Greedy evaluation\n", + "\n", + "Here we simply take the solution with greedy decoding type" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "td_post = td_init_test.clone()\n", + "\n", + "policy = model.policy.to(device)\n", + "out = policy(td_post, env, decode_type=\"greedy\", return_actions=True)\n", + "\n", + "print(\"Average makespan: {:.2f}\".format(-out['reward'].mean().item()))\n", + "for i in range(3):\n", + " print(f\"Schedule {i} makespan: {-out['reward'][i].item():.2f}\")\n", + " env.render(td_post, idx=i)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch200-py39", + "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.12.5" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/generate_data.py b/generate_data.py new file mode 100644 index 0000000..de19afd --- /dev/null +++ b/generate_data.py @@ -0,0 +1,53 @@ +import os + +from parco.data.generate import generate_dataset + + +def generate_with_agents(problem, size_agents_dict, **kwargs): + """Helper function to generate data for a problem with different number of agents.""" + for graph_size, num_agents_ in size_agents_dict.items(): + for num_agents in num_agents_: + kwargs["num_agents"] = num_agents + + print( + "Generating instances: N {}, m {}...".format( + problem.upper(), + graph_size, + ) + ) + + kwargs["graph_sizes"] = graph_size + fname = os.path.join( + kwargs["data_dir"], + problem, + "n{}_m{}_seed{}.npz".format( + kwargs["graph_sizes"], + kwargs["num_agents"], + kwargs["seed"], + ), + ) + + generate_dataset(problem=problem, filename=fname, **kwargs) + + +if __name__ == "__main__": + data_dir = "data" + + kwargs = { + "data_dir": data_dir, + "seed": 3333, + "dataset_size": 100, + "graph_sizes": 100, + "num_agents": 100, # NOTE: dummy, generate more for mixed graph sizes and agents training + } + + problem = "hcvrp" + print(50 * "=" + f"\nGenerating instances for {problem.upper()}...\n" + 50 * "=") + kwargs.update({"seed": 24610, "dataset_size": 1280}) # same as 2D-Ptr paper + size_agents_dict = {60: [3, 5, 7], 80: [3, 5, 7], 100: [3, 5, 7]} + generate_with_agents(problem, size_agents_dict, **kwargs) + + problem = "omdcpdp" + print(50 * "=" + f"\nGenerating instances for {problem.upper()}...\n" + 50 * "=") + size_agents_dict = {50: [5, 10, 15], 100: [10, 20, 30], 200: [20, 40, 60]} + generate_with_agents(problem, size_agents_dict, **kwargs) diff --git a/parco/data/generate.py b/parco/data/generate.py new file mode 100644 index 0000000..057b5a2 --- /dev/null +++ b/parco/data/generate.py @@ -0,0 +1,215 @@ +import argparse +import logging +import os +import sys + +import numpy as np + +from rl4co.data.utils import check_extension +from rl4co.utils.pylogger import get_pylogger + +log = get_pylogger(__name__) + + +def generate_env_data(env_type, *args, **kwargs): + """Generate data for a given environment type in the form of a dictionary""" + try: + # breakpoint() + # remove all None values from args + args = [arg for arg in args if arg is not None] + + return getattr(sys.modules[__name__], f"generate_{env_type}_data")( + *args, **kwargs + ) + except AttributeError: + raise NotImplementedError(f"Environment type {env_type} not implemented") + + +def generate_omdcpdp_data( + batch_size=128, + num_loc=200, + min_loc=0.0, + max_loc=1.0, + num_agents=5, + use_different_depot_locations=True, + capacity_min=3, + capacity_max=3, + min_lateness_weight=1.0, + max_lateness_weight=1.0, +): + """ + Generate a batch of data for the omdcpdp problem. + + Parameters: + batch_size (int): Number of samples in the batch. Default is 128. + num_loc (int): Total number of locations (pickups and deliveries). Default is 200. + min_loc (float): Minimum value for location coordinates. Default is 0.0. + max_loc (float): Maximum value for location coordinates. Default is 1.0. + num_agents (int): Number of agents involved. Default is 5. + use_different_depot_locations (bool): Whether to use different depot locations for each agent. Default is True. + capacity_min (int): Minimum capacity for each agent. Default is 1. + capacity_max (int): Maximum capacity for each agent. Default is 3. + min_lateness_weight (float): Minimum lateness weight. Default is 1.0. + max_lateness_weight (float): Maximum lateness weight. Default is 1.0. + + Returns: + dict: A dictionary containing generated data arrays for depots, locations, number of agents, lateness weight, and capacity. + """ + batch_size = [batch_size] if isinstance(batch_size, int) else batch_size + num_orders = int(num_loc / 2) + + # Generate the pickup and delivery locations + pickup_locs = np.random.uniform(min_loc, max_loc, (*batch_size, num_orders, 2)) + delivery_locs = np.random.uniform(min_loc, max_loc, (*batch_size, num_orders, 2)) + + # Generate depots + n_diff_depots = num_agents if use_different_depot_locations else 1 + depots = np.random.uniform(min_loc, max_loc, (*batch_size, n_diff_depots, 2)) + + # Initialize num_agents and capacity + num_agents_array = np.ones((*batch_size,), dtype=np.int64) * n_diff_depots + capacity = np.random.randint( + capacity_min, capacity_max + 1, (*batch_size, np.max(num_agents_array)) + ) + + # Combine pickup and delivery locations + cities = np.concatenate([pickup_locs, delivery_locs], axis=-2) + + # Generate lateness weight + lateness_weight = np.random.uniform( + min_lateness_weight, max_lateness_weight, (*batch_size, 1) + ) + + data_dict = { + "depots": depots.astype(np.float32), + "locs": cities.astype(np.float32), # Note: 'locs' does not include depot + "num_agents": num_agents_array, + "lateness_weight": lateness_weight.astype(np.float32), + "capacity": capacity, + } + + return data_dict + + +def generate_hcvrp_data(dataset_size, graph_size, num_agents=3): + """Same dataset as 2D-Ptr paper + https://github.com/farkguidao/2D-Ptr + Note that we set the seed outside of this function + """ + + loc = np.random.uniform(0, 1, size=(dataset_size, graph_size + 1, 2)) + depot = loc[:, -1] + cust = loc[:, :-1] + d = np.random.randint(1, 10, [dataset_size, graph_size + 1]) + d = d[:, :-1] # the demand of depot is 0, which do not need to generate here + + # vehicle feature + speed = np.random.uniform(0.5, 1, size=(dataset_size, num_agents)) + cap = np.random.randint(20, 41, size=(dataset_size, num_agents)) + + data = { + "depot": depot.astype(np.float32), + "locs": cust.astype(np.float32), + "demand": d.astype(np.float32), + "capacity": cap.astype(np.float32), + "speed": speed.astype(np.float32), + } + return data + + +def generate_dataset( + filename=None, + data_dir="data", + name=None, + problem="hcvrp", + dataset_size=10000, + graph_sizes=[20, 50, 100], + overwrite=False, + seed=1234, + disable_warning=True, + **kwargs, +): + """We keep a similar structure as in Kool et al. 2019 but save and load the data as npz + This is way faster and more memory efficient than pickle and also allows for easy transfer to TensorDict + """ + + fname = filename + if isinstance(graph_sizes, int): + graph_sizes = [graph_sizes] + for graph_size in graph_sizes: + datadir = os.path.join(data_dir, problem) + os.makedirs(datadir, exist_ok=True) + + if filename is None: + fname = os.path.join( + datadir, + "{}{}_seed{}.npz".format( + graph_size, + "_{}".format(name) if name is not None else "", + seed, + ), + ) + else: + fname = check_extension(filename, extension=".npz") + + if not overwrite and os.path.isfile(check_extension(fname, extension=".npz")): + if not disable_warning: + log.info( + "File {} already exists! Run with -f option to overwrite. Skipping...".format( + fname + ) + ) + continue + + # Set seed + np.random.seed(seed) + + # Automatically generate dataset + dataset = generate_env_data(problem, dataset_size, graph_size, **kwargs) + + # A function can return None in case of an error or a skip + if dataset is not None: + # Save to disk as dict + log.info("Saving {} dataset to {}".format(problem, fname)) + np.savez(fname, **dataset) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument( + "--filename", help="Filename of the dataset to create (ignores datadir)" + ) + parser.add_argument( + "--data_dir", + default="data", + help="Create datasets in data_dir/problem (default 'data')", + ) + parser.add_argument( + "--name", type=str, required=True, help="Name to identify dataset" + ) + parser.add_argument( + "--problem", + type=str, + default="all", + help="Problem" " or 'all' to generate all", + ) + parser.add_argument( + "--dataset_size", type=int, default=10000, help="Size of the dataset" + ) + parser.add_argument( + "--graph_sizes", + type=int, + nargs="+", + default=[50, 100], + help="Sizes of problem instances (default 20, 50, 100)", + ) + parser.add_argument("-f", action="store_true", help="Set true to overwrite") + parser.add_argument("--seed", type=int, default=3333, help="Random seed") + parser.add_argument("--disable_warning", action="store_true", help="Disable warning") + args = parser.parse_args() + + logging.basicConfig(level=logging.INFO) + + args.overwrite = args.f + delattr(args, "f") + generate_dataset(**vars(args)) diff --git a/parco/envs/__init__.py b/parco/envs/__init__.py new file mode 100644 index 0000000..6cb38e8 --- /dev/null +++ b/parco/envs/__init__.py @@ -0,0 +1,3 @@ +from .hcvrp.env import HCVRPEnv +from .omdcpdp.env import OMDCPDPEnv +from .ffsp.env import FFSPEnv \ No newline at end of file diff --git a/parco/envs/ffsp/__init__.py b/parco/envs/ffsp/__init__.py new file mode 100644 index 0000000..5bb6b63 --- /dev/null +++ b/parco/envs/ffsp/__init__.py @@ -0,0 +1,2 @@ +from .env import FFSPEnv +from .generator import FFSPGenerator \ No newline at end of file diff --git a/parco/envs/ffsp/env.py b/parco/envs/ffsp/env.py new file mode 100644 index 0000000..35adf3a --- /dev/null +++ b/parco/envs/ffsp/env.py @@ -0,0 +1,326 @@ +from math import factorial +from typing import Optional +from einops import rearrange, reduce +import torch + +from tensordict.tensordict import TensorDict +from torchrl.data import ( + BoundedTensorSpec, + CompositeSpec, + UnboundedContinuousTensorSpec, + UnboundedDiscreteTensorSpec, +) + +from rl4co.data.dataset import FastTdDataset +from rl4co.envs.common.base import RL4COEnvBase + +from .generator import FFSPGenerator + + +class FFSPEnv(RL4COEnvBase): + """Flexible Flow Shop Problem (FFSP) environment. + The goal is to schedule a set of jobs on a set of machines such that the makespan is minimized. + + Observations: + - time index + - sub time index + - batch index + - machine index + - schedule + - machine wait step + - job location + - job wait step + - job duration + + Constraints: + - each job has to be processed on each machine in a specific order + - the machine has to be available to process the job + - the job has to be available to be processed + + Finish Condition: + - all jobs are scheduled + + Reward: + - (minus) the makespan of the schedule + + Args: + generator: FFSPGenerator instance as the data generator + generator_params: parameters for the generator + """ + + name = "ffsp" + + def __init__( + self, + generator: FFSPGenerator = None, + generator_params: dict = {}, + **kwargs, + ): + super().__init__(check_solution=False, dataset_cls=FastTdDataset, **kwargs) + if generator is None: + generator = FFSPGenerator(**generator_params) + self.generator = generator + + self.num_stage = generator.num_stage + self.num_machine = generator.num_machine + self.num_job = generator.num_job + self.num_machine_total = generator.num_machine_total + self.tables = None + self.step_cnt = None + self.stage_table = torch.tensor( + [ma for ma in list(range(self.num_stage)) for _ in range(self.num_machine)], + device=self.device, + dtype=torch.long + ) + + def get_num_starts(self, td): + return factorial(self.num_machine) + + def select_start_nodes(self, td, num_starts): + raise NotImplementedError("Shdsu") + + + def pre_step(self, td: TensorDict) -> TensorDict: + self.stage_table = self.stage_table.to(td.device) + # update action mask and stage machine indx + td = self._update_step_state(td) + + # return updated td + return td + + def _update_step_state(self, td: TensorDict): + + batch_size = td.batch_size + + mask = torch.full( + size=(*batch_size, self.num_machine_total, self.num_job), + fill_value=False, + dtype=torch.bool, + device=td.device + ) + + # shape: (batch, job) + job_loc = td["job_location"][:, :self.num_job] + # shape: (batch, 1, job) + job_finished = (job_loc >= self.num_stage).unsqueeze(-2).expand_as(mask) + + stage_table_expanded = self.stage_table[None, :, None].expand_as(mask) + job_not_in_machines_stage = job_loc[:, None] != stage_table_expanded + + mask.add_(job_finished) + mask.add_(job_not_in_machines_stage) + + mask = rearrange(mask, "b (s m) j -> b s m j", s=self.num_stage) + # add mask for wait, which is allowed if machine cannot process any job + mask = torch.cat( + (mask, ~reduce(mask, "... j -> ... 1", "all")), + dim=-1 + ) + mask = rearrange(mask, "b s m j -> b (s m) j") + + td.update({ + "full_action_mask": ~mask + }) + + return td + + + def _step(self, td: TensorDict) -> TensorDict: + + batch_size = td.batch_size + batch_idx = torch.arange(*batch_size, dtype=torch.long, device=td.device) + actions = td["action"].split(1, dim=-1) + + for action in actions: + job_idx = torch.flatten(action["jobs"].squeeze(-1)) + machine_idx = torch.flatten(action["mas"].squeeze(-1)) + skip = job_idx == self.num_job + if skip.all(): + continue + + b_idx = batch_idx[~skip] + + job_idx = job_idx[~skip] + machine_idx = machine_idx[~skip] + + t_job = td["t_job_ready"][b_idx, job_idx] + t_ma = td["t_ma_idle"][b_idx, machine_idx] + t = torch.maximum(t_job, t_ma) + + td["schedule"][b_idx, machine_idx, job_idx] = t + + # shape: (batch) + job_length = td["job_duration"][b_idx, job_idx, machine_idx] + + # shape: (batch, machine) + td["t_ma_idle"][b_idx, machine_idx] = t + job_length + td["t_job_ready"][b_idx, job_idx] = t + job_length + # shape: (batch, job+1) + td["job_location"][b_idx, job_idx] += 1 + # shape: (batch) + td["done"] = (td["job_location"][:, :self.num_job] >= self.num_stage).all(dim=-1) + + #################################### + all_done = td["done"].all() + + if all_done: + pass # do nothing. do not update step_state, because it won't be used anyway + else: + self._update_step_state(td) + + if all_done: + reward = -self._get_makespan(td) # Note the MINUS Sign ==> We want to MAXIMIZE reward + # shape: (batch, pomo) + else: + reward = None + + td["reward"] = reward + + return td + + + def _reset( + self, td: Optional[TensorDict] = None, batch_size: Optional[list] = None + ) -> TensorDict: + + device = td.device + + self.step_cnt = 0 + + # Scheduling status information + schedule = torch.full( + size=(*batch_size, self.num_machine_total, self.num_job + 1), + dtype=torch.long, + device=device, + fill_value=-999999, + ) + job_location = torch.zeros( + size=(*batch_size, self.num_job + 1), + dtype=torch.long, + device=device, + ) + job_duration = torch.empty( + size=(*batch_size, self.num_job + 1, self.num_machine * self.num_stage), + dtype=torch.long, + device=device, + ) + job_duration[..., : self.num_job, :] = td["run_time"] + job_duration[..., self.num_job, :] = 0 + # time information + t_job_ready = torch.zeros( + size=(*batch_size, self.num_job+1), + dtype=torch.long, + device=device + ) + t_ma_idle = torch.zeros( + size=(*batch_size, self.num_machine_total), + dtype=torch.long, + device=device) + + # Finish status information + reward = torch.full( + size=(*batch_size,), + dtype=torch.float32, + device=device, + fill_value=float("-inf"), + ) + done = torch.full( + size=(*batch_size,), + dtype=torch.bool, + device=device, + fill_value=False, + ) + + return TensorDict( + { + # Index information + "t_job_ready": t_job_ready, + "t_ma_idle": t_ma_idle, + # Scheduling status information + "schedule": schedule, + "job_location": job_location, + "job_duration": job_duration, + # Finish status information + "reward": reward, + "done": done + }, + batch_size=batch_size, + ) + + + def _get_makespan(self, td): + + # shape: (batch, machine, job+1) + job_durations_perm = td["job_duration"].permute(0, 2, 1) + # shape: (batch, machine, job+1) + end_schedule = td["schedule"] + job_durations_perm + + # shape: (batch, machine) + end_time_max, _ = end_schedule[:, :, :self.num_job].max(dim=-1) + # shape: (batch) + end_time_max, _ = end_time_max.max(dim=-1) + + return end_time_max.float() + + + def _get_reward(self, td, actions) -> TensorDict: + return td["reward"].float() + + def render(self, td: TensorDict, idx: int): + import matplotlib.patches as patches + import matplotlib.pyplot as plt + + total_machine_cnt = self.num_machine_total + num_job = self.num_job + + # shape: (job, machine) + job_durations = td["job_duration"][idx, :, :] + # shape: (machine, job) + schedule = td["schedule"][idx, :, :] + + makespan = -td["reward"][idx].item() + + # Create figure and axes + fig, ax = plt.subplots(figsize=(makespan / 3, 5)) + cmap = self._get_cmap(num_job) + + plt.xlim(0, makespan) + plt.ylim(0, total_machine_cnt) + ax.invert_yaxis() + + plt.plot([0, makespan], [4, 4], "black") + plt.plot([0, makespan], [8, 8], "black") + + for machine_idx in range(total_machine_cnt): + duration = job_durations[:, machine_idx] + # shape: (job) + machine_schedule = schedule[machine_idx, :] + # shape: (job) + + for job_idx in range(num_job): + job_length = duration[job_idx].item() + job_start_time = machine_schedule[job_idx].item() + if job_start_time >= 0: + # Create a Rectangle patch + rect = patches.Rectangle( + (job_start_time, machine_idx), + job_length, + 1, + facecolor=cmap(job_idx), + ) + ax.add_patch(rect) + + ax.grid() + ax.set_axisbelow(True) + plt.show() + + @staticmethod + def _get_cmap(color_cnt): + from random import shuffle + + from matplotlib.colors import CSS4_COLORS, ListedColormap + + color_list = list(CSS4_COLORS.keys()) + shuffle(color_list) + cmap = ListedColormap(color_list, N=color_cnt) + return cmap \ No newline at end of file diff --git a/parco/envs/ffsp/generator.py b/parco/envs/ffsp/generator.py new file mode 100644 index 0000000..687d13c --- /dev/null +++ b/parco/envs/ffsp/generator.py @@ -0,0 +1,62 @@ +import torch + +from tensordict.tensordict import TensorDict + +from rl4co.envs.common.utils import Generator +from rl4co.utils.pylogger import get_pylogger + +log = get_pylogger(__name__) + + +class FFSPGenerator(Generator): + """Data generator for the Flow Shop Scheduling Problem (FFSP). + + Args: + num_stage: number of stages + num_machine: number of machines + num_job: number of jobs + min_time: minimum running time of each job on each machine + max_time: maximum running time of each job on each machine + + Returns: + A TensorDict with the following key: + run_time [batch_size, num_job, num_machine, num_stage]: running time of each job on each machine + + Note: + - [IMPORTANT] This version of ffsp requires the number of machines in each stage to be the same + """ + + def __init__( + self, + num_stage: int = 3, + num_machine: int = 4, + num_job: int = 10, + min_time: int = 2, + max_time: int = 10, + **unused_kwargs, + ): + self.num_stage = num_stage + self.num_machine = num_machine + self.num_machine_total = num_machine * num_stage + self.num_job = num_job + self.min_time = min_time + self.max_time = max_time + + # FFSP environment doen't have any other kwargs + if len(unused_kwargs) > 0: + log.error(f"Found {len(unused_kwargs)} unused kwargs: {unused_kwargs}") + + def _generate(self, batch_size) -> TensorDict: + # Init observation: running time of each job on each machine + run_time = torch.randint( + low=self.min_time, + high=self.max_time, + size=(*batch_size, self.num_job, self.num_machine_total), + ) + + return TensorDict( + { + "run_time": run_time, + }, + batch_size=batch_size, + ) \ No newline at end of file diff --git a/parco/envs/hcvrp/__init__.py b/parco/envs/hcvrp/__init__.py new file mode 100644 index 0000000..dff3d1b --- /dev/null +++ b/parco/envs/hcvrp/__init__.py @@ -0,0 +1,2 @@ +from .env import HCVRPEnv +from .generator import HCVRPGenerator \ No newline at end of file diff --git a/parco/envs/hcvrp/env.py b/parco/envs/hcvrp/env.py new file mode 100644 index 0000000..b5aea96 --- /dev/null +++ b/parco/envs/hcvrp/env.py @@ -0,0 +1,327 @@ +from typing import Optional + +import torch + +from rl4co.envs.common.base import RL4COEnvBase +from rl4co.utils.ops import gather_by_index, get_distance +from rl4co.utils.pylogger import get_pylogger +from tensordict.tensordict import TensorDict +from torchrl.data import ( + BoundedTensorSpec, + CompositeSpec, + UnboundedContinuousTensorSpec, + UnboundedDiscreteTensorSpec, +) + +from .generator import HCVRPGenerator +from .render import render + +log = get_pylogger(__name__) + + +class HCVRPEnv(RL4COEnvBase): + """Heterogeneous Capacitated Vehicle Routing Problem (HCVRP) environment. + In HCVRP, vehicles of various types with different capacities and costs are used to serve all customers exactly once. + The agent selects a vehicle and customer pair at each step, based on the vehicle’s current location and its remaining capacity. + The remaining capacity of the selected vehicle is updated upon servicing a customer. If a vehicle cannot serve any remaining + customers due to capacity constraints, it must return to the depot. A vehicle can return to the depot to refill its capacity + at any time. The challenge is to minimize the overall cost, which is a function of the total distance traveled and possibly + other operational costs depending on vehicle type. + + Observations: + - Location of the depot. + - Locations and demands of each customer. + - Current location of each vehicle. + - Remaining capacity of each vehicle. + - Type of each vehicle and its associated cost factors. + + Constraints: + - The tour starts and ends at the depot for each vehicle. + - Each customer must be visited exactly once by one of the vehicles. + - Vehicles must not exceed their remaining capacity when visiting customers. + - Each vehicle type may have different operational cost structures, affecting the optimization goal. + + Finish Condition: + - All vehicles have visited all required customers and returned to the depot. + + Reward: + - The reward is the negative of the total cost, which includes the total distance traveled by all vehicles and may include + other operational costs. Maximizing the reward is equivalent to minimizing the total cost. + + Args: + generator: An instance of HCVRPGenerator used as the data generator for vehicle types, customer demands, and other + scenario specifics. + generator_params: Parameters configuring the generator, possibly including number of vehicles, types, capacities, + cost factors, and customer locations. + """ + + name = "hcvrp" + + def __init__( + self, + generator: HCVRPGenerator = None, + generator_params: dict = {}, + **kwargs, + ): + super().__init__(**kwargs) + if generator is None: + generator = HCVRPGenerator(**generator_params) + self.generator = generator + self._make_spec(self.generator) + + def _reset( + self, + td: Optional[TensorDict] = None, + batch_size: Optional[list] = None, + ) -> TensorDict: + """ + Returns: + A TensorDict containing the following keys: + - locs [batch_size, num_agents + num_loc, 2]: locations of the depot + customers, note that the depot + is repeated for each agent + - demand [batch_size, num_agents, num_agents + num_loc]: demand of the customers + - current_length [batch_size, num_agents]: current length of the tours + - current_node [batch_size, num_agents]: current node of each agent, initialized to the respective depot + - depot_node [batch_size, num_agents]: depot node of each agent, wouldn't change, used for action mask calculation + - used_capacity [batch_size, num_agents]: used capacity of each agent + - agents_capacity [batch_size, num_agents]: capacity of the agents, different for each agent + - visited [batch_size, num_agents + num_loc]: if the node is visited, 1 means already visited + - action_mask [batch_size, num_agents, num_agents + num_loc]: mask for the actions of each agent + + Notes: + - [Enhancement] The repeat of depot could be done in the generator. In the current state, for the + convience of comparison with baselines, we keep it here. + """ + device = td.device + + # Record parameters + # num_agents = self.generator.num_agents + # num_loc_all = self.generator.num_loc + num_agents + num_agents = td["speed"].size(-1) + num_loc_all = td["locs"].size(-2) + num_agents + + # Repeat the depot for each agent (i.e. each agent has its own depot, at the same place) + depots = td["depot"] + if depots.shape[-2] == 1 or depots.ndim == 2: + depots = depots.unsqueeze(-2) if depots.ndim == 2 else depots + depots = depots.repeat(1, num_agents, 1) + + # Padding depot demand as 0 to the demand + demand_depot = torch.zeros( + (*batch_size, num_agents), dtype=torch.float32, device=device + ) + demand = torch.cat((demand_depot, td["demand"]), -1) + + # Repeat the demand for each agent, for convinent action mask calculation + # Note that this will take more memory + demand = demand.unsqueeze(-2).repeat(1, num_agents, 1) + + # Init current node + depot_node = torch.arange(num_agents, dtype=torch.int64, device=device)[ + None, ... + ].repeat(*batch_size, 1) + current_node = depot_node.clone() + + # Init visited + visited = torch.zeros((*batch_size, num_loc_all), dtype=torch.bool, device=device) + + # Init action mask + action_mask = torch.ones( + (*batch_size, num_agents, num_loc_all), dtype=torch.bool, device=device + ) + + # Create reset TensorDict + td_reset = TensorDict( + { + "locs": torch.cat((depots, td["locs"]), -2), + "demand": demand, + "current_length": torch.zeros( + (*batch_size, num_agents), dtype=torch.float32, device=device + ), + "current_node": current_node, + "depot_node": depot_node, + "used_capacity": torch.zeros((*batch_size, num_agents), device=device), + "agents_capacity": td["capacity"], + "agents_speed": td["speed"], + "i": torch.zeros((*batch_size, 1), dtype=torch.int64, device=device), + "visited": visited, + "action_mask": action_mask, + "done": torch.zeros((*batch_size,), dtype=torch.bool, device=device), + }, + batch_size=batch_size, + device=device, + ) + td_reset.set("action_mask", self.get_action_mask(td_reset)) + return td_reset + + def _step(self, td: TensorDict) -> TensorDict: + """ + Keys: + - action [batch_size, num_agents]: action taken by each agent + """ + num_agents = td["current_node"].size(-1) + + # Update the current length + current_loc = gather_by_index(td["locs"], td["action"]) + previous_loc = gather_by_index(td["locs"], td["current_node"]) + current_length = td["current_length"] + get_distance(previous_loc, current_loc) + + # Update the used capacity + # Increase used capacity if not visiting the depot, otherwise set to 0 + selected_demand = gather_by_index(td["demand"], td["action"], dim=-1) + + # If the agent is staying at the same node, do not add the demand the second time + stay_flag = td["action"] == td["current_node"] + selected_demand = selected_demand * (~stay_flag).float() + used_capacity = (td["used_capacity"] + selected_demand) * ( + td["action"] >= num_agents + ).float() + + # Note: here we do not subtract one as we have to scatter so the first column allows scattering depot + # Add one dimension since we write a single value + visited = td["visited"].scatter(-1, td["action"], 1) + + # update the done and reward + done = visited[..., num_agents:].sum(-1) == (visited.size(-1) - num_agents) + reward = torch.zeros_like(done) + + td.update( + { + "current_length": current_length, + "current_node": td["action"], + "used_capacity": used_capacity, + "i": td["i"] + 1, + "visited": visited, + "reward": reward, + "done": done, + } + ) + td.set("action_mask", self.get_action_mask(td)) + return td + + @staticmethod + def get_action_mask(td: TensorDict) -> torch.Tensor: + batch_size = td.batch_size + num_agents = td["current_node"].size(-1) + + # Init action mask for each agent with all not visited nodes + action_mask = torch.repeat_interleave( + ~td["visited"][..., None, :], dim=-2, repeats=num_agents + ) + + # Can not visit the node if the demand is more than the remaining capacity + remain_capacity = td["agents_capacity"] - td["used_capacity"] + within_capacity_flag = td["demand"] <= remain_capacity[..., None] # TODO: check + action_mask &= within_capacity_flag + + # The depot is not available if **all** the agents are at the depot and the task is not finished + all_back_flag = torch.sum(td["current_node"] >= num_agents, dim=-1) == 0 + # has_finished_early = (all_back_flag != td["done"]) & all_back_flag + # has_finished_early = all_back_flag != td["done"] + has_finished_early = all_back_flag & ~td["done"] + + depot_mask = ~has_finished_early[..., None] # 1 means we can visit + # depot_mask = torch.ones_like(depot_mask) # dummy!!! + + # If no available nodes outside (all visited), make the depot always available + all_visited_flag = ( + torch.sum(~td["visited"][..., num_agents:], dim=-1, keepdim=True) == 0 + ) + depot_mask |= all_visited_flag + + # Update the depot mask in the action mask + eye_matrix = torch.eye(num_agents, device=td.device) + eye_matrix = eye_matrix[None, ...].repeat(*batch_size, 1, 1).bool() + eye_matrix &= depot_mask[..., None] + action_mask[..., :num_agents] = eye_matrix + + return action_mask + + def _get_reward(self, td: TensorDict, actions: TensorDict) -> TensorDict: + """ + Min-max + """ + current_length = td["current_length"] + + # Adding the final distance to the depot + current_loc = gather_by_index(td["locs"], td["current_node"]) + depot_loc = gather_by_index(td["locs"], td["depot_node"]) + current_length = td["current_length"] + get_distance(depot_loc, current_loc) + + # Calculate the time + current_time = current_length / td["agents_speed"] + max_time = current_time.max(dim=1)[0] + return -max_time # note: reward is negative of the total time (maximize) + + @staticmethod + def check_solution_validity(td: TensorDict, actions: torch.Tensor): + """Check the validity of the solution. + + Notes: + - This function is implemented in a low efficiency way, only for debugging purposes. + """ + num_agents = td["current_node"].size(-1) + num_loc = td["locs"].size(-2) - num_agents + batch_size = td.batch_size + + # Flatten the actions of all agents + actions_flatten = actions.flatten(start_dim=-2) + + # Sort the actions from small to large + actions_flatten_sort = actions_flatten.sort(dim=-1)[0] + + # Check if visited all nodes + for batch_idx in range(*batch_size): + actions_sort_unique = torch.unique(actions_flatten_sort[batch_idx]) + actions_sort_unique = actions_sort_unique[actions_sort_unique >= num_agents] + assert ( + torch.arange(num_agents, num_agents + num_loc, device=td.device) + == actions_sort_unique + ).all(), f"Invalid tour at batch {batch_idx} with tour {actions_sort_unique}" + + # TODO: double check the validity of the demand + + def _make_spec(self, generator: HCVRPGenerator): + self.observation_spec = CompositeSpec( + locs=BoundedTensorSpec( + low=generator.min_loc, + high=generator.max_loc, + shape=(generator.num_loc + 1, 2), + dtype=torch.float32, + device=self.device, + ), + current_node=UnboundedDiscreteTensorSpec( + shape=(1), + dtype=torch.int64, + device=self.device, + ), + demand=BoundedTensorSpec( + low=-generator.min_demand, + high=generator.max_demand, + shape=(generator.num_loc + 1, 1), + dtype=torch.float32, + device=self.device, + ), + action_mask=UnboundedDiscreteTensorSpec( + shape=(generator.num_loc + 1, 1), + dtype=torch.bool, + device=self.device, + ), + shape=(), + device=self.device, + ) + self.action_spec = BoundedTensorSpec( + shape=(1,), + dtype=torch.int64, + low=0, + high=generator.num_loc + 1, + device=self.device, + ) + self.reward_spec = UnboundedContinuousTensorSpec(shape=(1,), device=self.device) + self.done_spec = UnboundedDiscreteTensorSpec( + shape=(1,), dtype=torch.bool, device=self.device + ) + + @staticmethod + def render(td: TensorDict, actions: torch.Tensor = None, ax=None, **kwargs): + return render(td, actions, ax, **kwargs) diff --git a/parco/envs/hcvrp/generator.py b/parco/envs/hcvrp/generator.py new file mode 100644 index 0000000..7080ca8 --- /dev/null +++ b/parco/envs/hcvrp/generator.py @@ -0,0 +1,164 @@ +from typing import Callable, Union + +import torch + +from rl4co.envs.common.utils import Generator, get_sampler +from rl4co.utils.pylogger import get_pylogger +from tensordict.tensordict import TensorDict +from torch.distributions import Uniform + +log = get_pylogger(__name__) + + +class HCVRPGenerator(Generator): + """Data generator for the Heterogeneous Capacitated Vehicle Routing Problem (HCVRP). + + Args: + - num_loc: Number of customers. + - min_loc: Minimum location of the customers. + - max_loc: Maximum location of the customers. + - loc_distribution: Distribution of the locations of the customers. + - depot_distribution: Distribution of the location of the depot. + - min_demand: Minimum demand of the customers. + - max_demand: Maximum demand of the customers. + - demand_distribution: Distribution of the demand of the customers. + - min_capacity: Minimum capacity of the agents. + - max_capacity: Maximum capacity of the agents. + - capacity_distribution: Distribution of the capacity of the agents. + - min_speed: Minimum speed of the agents. + - max_speed: Maximum speed of the agents. + - speed_distribution: Distribution of the speed of the agents. + - num_agents: Number of agents. + + Returns: + A TensorDict containing the following keys: + - locs [batch_size, num_loc, 2]: locations of the customers + - depot [batch_size, 2]: location of the depot + - demand [batch_size, num_loc]: demand of the customers + - capacity [batch_size, num_agents]: capacity of the agents, different for each agents + - speed [batch_size, num_agents]: speed of the agents, different for each agents + + Notes: + - The capacity setting from 2D-Ptr paper is hardcoded to 20~41. It should change + based on the size of the problem. + - ? Demand and capacity are initialized as integers and then converted to floats. + To avoid zero demands, we first sample from [min_demand - 1, max_demand - 1] + and then add 1 to the demand. + - ! Note that here the demand is not normalized by the capacity by default. + """ + + def __init__( + self, + num_loc: int = 40, + min_loc: float = 0.0, + max_loc: float = 1.0, + loc_distribution: Union[int, float, str, type, Callable] = Uniform, + depot_distribution: Union[int, float, str, type, Callable] = None, + min_demand: int = 1, + max_demand: int = 10, + demand_distribution: Union[int, float, type, Callable] = Uniform, + min_capacity: float = 20, + max_capacity: float = 41, + capacity_distribution: Union[int, float, type, Callable] = Uniform, + min_speed: float = 0.5, + max_speed: float = 1.0, + speed_distribution: Union[int, float, type, Callable] = Uniform, + num_agents: int = 3, + # if False, we don't normalize by capacity and speed + # note that we are doing this in environment side for convenience + scale_data: bool = False, # leave False! + **kwargs, + ): + self.num_loc = num_loc + self.min_loc = min_loc + self.max_loc = max_loc + self.min_demand = min_demand + self.max_demand = max_demand + self.min_capacity = min_capacity + self.max_capacity = max_capacity + self.min_speed = min_speed + self.max_speed = max_speed + self.num_agents = num_agents + self.scale_data = scale_data + + # Location distribution + if kwargs.get("loc_sampler", None) is not None: + self.loc_sampler = kwargs["loc_sampler"] + else: + self.loc_sampler = get_sampler( + "loc", loc_distribution, min_loc, max_loc, **kwargs + ) + + # Depot distribution + if kwargs.get("depot_sampler", None) is not None: + self.depot_sampler = kwargs["depot_sampler"] + else: + self.depot_sampler = ( + get_sampler("depot", depot_distribution, min_loc, max_loc, **kwargs) + if depot_distribution is not None + else None + ) + + # Demand distribution + if kwargs.get("demand_sampler", None) is not None: + self.demand_sampler = kwargs["demand_sampler"] + else: + self.demand_sampler = get_sampler( + "demand", demand_distribution, min_demand - 1, max_demand - 1, **kwargs + ) + + # Capacity + if kwargs.get("capacity_sampler", None) is not None: + self.capacity_sampler = kwargs["capacity_sampler"] + else: + self.capacity_sampler = get_sampler( + "capacity", + capacity_distribution, + 0, + max_capacity - min_capacity, + **kwargs, + ) + + # Speed + if kwargs.get("speed_sampler", None) is not None: + self.speed_sampler = kwargs["speed_sampler"] + else: + self.speed_sampler = get_sampler( + "speed", speed_distribution, min_speed, max_speed, **kwargs + ) + + def _generate(self, batch_size) -> TensorDict: + # Sample locations: depot and customers + if self.depot_sampler is not None: + depot = self.depot_sampler.sample((*batch_size, 2)) + locs = self.loc_sampler.sample((*batch_size, self.num_loc, 2)) + else: + # If depot_sampler is None, sample the depot from the locations + locs = self.loc_sampler.sample((*batch_size, self.num_loc + 1, 2)) + depot = locs[..., 0, :] + locs = locs[..., 1:, :] + + # Sample demands + demand = self.demand_sampler.sample((*batch_size, self.num_loc)) + demand = (demand.int() + 1).float() + + # Sample capacities + capacity = self.capacity_sampler.sample((*batch_size, self.num_agents)) + capacity = (capacity.int() + self.min_capacity).float() + + # Sample speed + speed = self.speed_sampler.sample((*batch_size, self.num_agents)) + + return TensorDict( + { + "locs": locs, + "depot": depot, + "num_agents": torch.full( + (*batch_size,), self.num_agents + ), # for compatibility + "demand": demand / self.max_capacity if self.scale_data else demand, + "capacity": capacity / self.max_capacity if self.scale_data else capacity, + "speed": speed / self.max_speed if self.scale_data else speed, + }, + batch_size=batch_size, + ) diff --git a/parco/envs/hcvrp/render.py b/parco/envs/hcvrp/render.py new file mode 100644 index 0000000..4c144a9 --- /dev/null +++ b/parco/envs/hcvrp/render.py @@ -0,0 +1,88 @@ +import matplotlib.pyplot as plt +import torch + +from matplotlib import cm +from rl4co.utils.pylogger import get_pylogger + +log = get_pylogger(__name__) + + +def render(td, actions=None, ax=None, plot_depot_transition=True, **kwargs): + # Process the data + td = td.detach().cpu() + + if actions is None: + actions = td.get("action", None) + + # if batch_size greater than 0 , we need to select the first batch element + if td.batch_size != torch.Size([]): + td = td[0] + actions = actions[0] + + num_agents = td["current_node"].size(-1) + + # Plot + fig, ax = plt.subplots(1, 1, figsize=(5, 5)) + + # Plot Depot + ax.scatter( + td["locs"][0, 0], td["locs"][0, 1], marker="s", color="r", s=100, label="Depot" + ) + + # Plot Customers + ax.scatter( + td["locs"][num_agents:, 0], + td["locs"][num_agents:, 1], + marker="o", + color="gray", + s=30, + label="Customers", + ) + + # Plot Actions + # add as first action of all the agents the depot (which is agent_idx) + actions_first = torch.arange(num_agents).unsqueeze(0).expand(actions.size(0), -1) + actions = torch.cat([actions_first, actions, actions_first], dim=-1) + + for agent_idx in range(num_agents): + agent_action = actions[agent_idx] + for action_idx in range(agent_action.size(0) - 1): + from_loc = td["locs"][agent_action[action_idx]] + to_loc = td["locs"][agent_action[action_idx + 1]] + + # if it is to or from depot, raise flag + if ( + agent_action[action_idx] == agent_idx + or agent_action[action_idx + 1] == agent_idx + ): + depot_transition = True + else: + depot_transition = False + + if depot_transition: + if plot_depot_transition: + ax.plot( + [from_loc[0], to_loc[0]], + [from_loc[1], to_loc[1]], + color=cm.Set2(agent_idx), + lw=0.3, + linestyle="--", + ) + + else: + ax.plot( + [from_loc[0], to_loc[0]], + [from_loc[1], to_loc[1]], + color=cm.Set2(agent_idx), + lw=1, + ) + + # Plot Configs + ax.set_xlim(-0.05, 1.05) + ax.set_ylim(-0.05, 1.05) + + # remove axs labels + ax.set_xticks([]) + ax.set_yticks([]) + + plt.tight_layout() diff --git a/parco/envs/omdcpdp/env.py b/parco/envs/omdcpdp/env.py new file mode 100644 index 0000000..4ddaea1 --- /dev/null +++ b/parco/envs/omdcpdp/env.py @@ -0,0 +1,438 @@ +from typing import Optional + +import torch + +from rl4co.envs.common.base import RL4COEnvBase +from rl4co.utils.ops import gather_by_index +from rl4co.utils.pylogger import get_pylogger +from tensordict.tensordict import TensorDict +from torchrl.data import BoundedTensorSpec, UnboundedContinuousTensorSpec + +from .generator import OMDCPDPGenerator +from .render import render + +log = get_pylogger(__name__) + + +class OMDCPDPEnv(RL4COEnvBase): + """Open Multi-Depot Capacitated Pickup and Delivery Problem(OMDCPDP) + + Problem description: + - Open: agents do not need to go back to the depot after finishing all orders (optional) + - Multi-depot: each agent has its own depot (i.e., its own starting node) + - Capacitated: each agent has a capacity constraint (cannot hold more than a certain number of orders) + - Vehicle routing: the agents need to visit all nodes (pickup and delivery) while minimizing an objective function + - Pickup and delivery: the orders need to be picked up and delivered in pairs (first pickup, then delivery) + + The stepping is performed in parallel for all agents. + Note that this environment has capacity constraints. + We support two reward modes: minmax and minsum. + + Args: + num_loc (int): number of locations (including depots) + num_agents (int): number of agents + min_loc (float): minimum value for the location coordinates + max_loc (float): maximum value for the location coordinates + capacity_min (int): minimum capacity for each agent + capacity_max (int): maximum capacity for each agent + min_lateness_weight (float): minimum lateness weight for each agent. If 1, the reward is the same as the lateness. + max_lateness_weight (float): maximum lateness weight for each agent. If 1, the reward is the same as the lateness. + dist_norm (str): distance norm. Either L1 or L2. + reward_mode (str): reward mode. Either minmax or minsum. + problem_mode (str): problem mode. Either close or open. + use_different_depot_locations (bool): whether to use different depot locations for each agent + num_agents_override (bool): whether to override the number of agents in the TensorDict if it is provided in :meth:`_reset` + td_params (TensorDict): TensorDict of parameters for generating the data + check_conflicts (bool): whether to check for conflicts (i.e., if an agent visits the same node twice) + """ + + name = "omdcpdp" + stepping = "parallel" + + def __init__( + self, + generator: OMDCPDPGenerator = None, + generator_params: dict = {}, + dist_norm: str = "L2", + reward_mode: str = "lateness", + problem_mode: str = "open", + td_params: TensorDict = None, + check_conflicts: bool = False, + check_solution: bool = False, + **kwargs, + ): + kwargs["check_solution"] = check_solution + super().__init__(**kwargs) + if generator is None: + generator = OMDCPDPGenerator(**generator_params) + self.generator = generator + + self.dist_norm = dist_norm + assert reward_mode in [ + "minmax", + "minsum", + "lateness", + "lateness_square", + ], "Invalid reward mode. Must be minmax, minsum, lateness or lateness_square." + self.reward_mode = reward_mode + assert problem_mode in [ + "close", + "open", + ], "Invalid problem mode. Must be close or open." + self.problem_mode = problem_mode + self.check_conflicts = check_conflicts + # raise warning if check conflicts + if self.check_conflicts: + log.warning("Checking conflicts is enabled. This may slow down the code.") + self._make_spec(td_params) + + def _reset( + self, + td: Optional[TensorDict] = None, + batch_size: Optional[int] = None, + ) -> TensorDict: + device = td.device + + # TODO: check + num_agents = ( + td["depots"].size(-2) + if "depots" in td.keys() + else td["num_agents"].max().item() + ) + + # Check if depots is in keys. If not, it is the first location + if "depots" not in td.keys(): + depots = td["locs"][..., 0:1, :] + cities = td["locs"][..., 1:, :] + else: + depots = td["depots"] + cities = td["locs"] + + # Pad depot if only one + if depots.shape[-2] == 1 or depots.ndim == 2: + depots = depots.unsqueeze(-2) if depots.ndim == 2 else depots + depots = depots.repeat(1, num_agents, 1) + + # Remove padding depots if more than num_agents + depots = depots[..., :num_agents, :] + + num_cities = cities.shape[-2] + # If num_cities is odd, decrease it by 1 + if num_cities % 2 == 1: + cities = cities[..., :-1, :] + num_cities -= 1 + num_loc_tot = num_agents + num_cities + num_p_d = num_cities // 2 + + # Each agent starts in their respective node with index equal to their agent index + depot_node = torch.arange(num_agents, dtype=torch.int64, device=device)[ + None, ... + ].repeat(*batch_size, 1) + current_node = depot_node.clone() + + # Last outer node, used for open problem + last_outer_node = depot_node.clone() + + # Seperate the unvisited_node and the mask, 1-unvisisted, 0-visited + # available still include the depot for the calculation convenience, + # so the size will be [B, num_loc+1] + available = torch.ones( + (*batch_size, num_loc_tot), dtype=torch.bool, device=device + ) + + # Depots are always unavailable + available[..., :num_agents] = 0 + + # Only pickup nodes are available at the initial state. + # num_pickup = int(td["locs"].size(-2) / 2) + num_agents # bug! + action_mask = torch.cat( + ( + torch.zeros( + (*batch_size, num_agents, num_agents), + dtype=torch.bool, + device=device, + ), # depot is not available + torch.ones( + (*batch_size, num_agents, num_p_d), + dtype=torch.bool, + device=device, + ), # pickup nodes are available + torch.zeros( + (*batch_size, num_agents, num_p_d), + dtype=torch.bool, + device=device, + ), # delivery nodes are not available + ), + dim=-1, + ) # 1-available, 0-not available + + # Variable to record the delivery node for each agent, + delivery_record = torch.zeros( + (*batch_size, num_agents, num_loc_tot), dtype=torch.int64, device=device + ) + + # Number of orders for each agent + num_orders = torch.zeros( + (*batch_size, num_agents), dtype=torch.int64, device=device + ) + + return TensorDict( + { + "locs": torch.cat([depots, cities], dim=-2), + "current_length": torch.zeros( + *batch_size, num_agents, dtype=torch.float32, device=device + ), + "arrivetime_record": torch.zeros( + *batch_size, num_loc_tot, dtype=torch.float32, device=device + ), + "current_node": current_node, + "depot_node": depot_node, # depot node is the first node for each agent + "last_outer_node": last_outer_node, # last outer node is the last node for each agent except the depot + "delivery_record": delivery_record, + "available": available, + "action_mask": action_mask, + "i": torch.zeros(*batch_size, dtype=torch.int64, device=device), + # Capacity or max orders + "num_orders": num_orders, + "capacity": td["capacity"][ + ..., :num_agents + ], # remove padding capacity if any + "lateness_weight": td["lateness_weight"], + }, + batch_size=batch_size, + ) + + def _step(self, td: TensorDict) -> TensorDict: + """Note: here variables like the actions are of size [B, num_agents]""" + + # Initial variables + selected = td["action"] + num_agents = td["current_node"].size(-1) + + num_cities = td["locs"].shape[-2] - num_agents + num_pickup = num_agents + int(num_cities / 2) + arrivetime = td["arrivetime_record"] + + # Use for debugging only + if self.check_conflicts: + self._check_conflicts(selected, num_agents) + + # Get the locations of the current node and the previous node and the depot + cur_loc = gather_by_index(td["locs"], selected) + + # Update the current length + backtodepot_flag = selected < num_agents + + if self.problem_mode == "open": + # Update last outer node + last_outer_node = td["last_outer_node"].clone() + prev_loc = gather_by_index(td["locs"], last_outer_node) + current_length = ( + td["current_length"] + + self.get_distance(prev_loc, cur_loc) * (~backtodepot_flag).float() + ) + # last_outer_node[~backtodepot_flag] = selected[~backtodepot_flag] + ## + last_outer_node = torch.where(backtodepot_flag, last_outer_node, selected) + # current_length = td["current_length"] + self.get_distance(prev_loc, cur_loc) * (~backtodepot_flag).float() + else: + prev_loc = gather_by_index( + td["locs"], td["current_node"] + ) # current_node is the previous node + current_length = td["current_length"] + self.get_distance(prev_loc, cur_loc) + + # Update the arrival time + arrivetime = torch.scatter(arrivetime, -1, selected, current_length) + + # Update the visited node (available node) + available = torch.scatter(td["available"], -1, selected, 0) + + stay_flag = selected == td["current_node"] + + # Update number of orders of agents, note this number is the current pickup orders + # instead of the total finished order + new_orders_flag = torch.where( + (selected < num_pickup) & (selected >= num_agents), 1, 0 + ) + new_orders_flag &= ~stay_flag + finish_orders_flag = torch.where(selected >= num_pickup, 1, 0) + finish_orders_flag &= ~stay_flag + + num_orders = td["num_orders"] + new_orders_flag - finish_orders_flag + + # Update the delivery record + delivery_record = torch.scatter( + td["delivery_record"], + -1, + torch.where(selected < num_pickup, selected, selected - int(num_cities / 2))[ + ..., None + ], + 0, + ) + delivery_record.scatter_(-1, selected[..., None], 1) + + # We are done there are no unvisited locations except the depot + done = torch.sum(available[..., num_agents:], dim=-1) == 0 + + # The reward is calculated outside via get_reward for efficiency, so we set it to -inf here + reward = torch.zeros_like(done) + + # Update current + td.update( + { + "current_length": current_length, + "arrivetime_record": arrivetime, + "current_node": selected, + "delivery_record": delivery_record, + "last_outer_node": last_outer_node, + "num_orders": num_orders, + "available": available, + "i": td["i"] + 1, + "done": done, + "reward": reward, + } + ) + # Close and open problem have the same action mask calculation + # NOTE: in open problem, depot may be added in actions after first but not counted towards reward as it is + # is actually a dummy action + td.set("action_mask", self.get_action_mask(td)) + return td + + def _check_conflicts(self, selected: torch.Tensor, num_agents: int): + """Note: may be slow. Better disable this""" + # Check locations are visited only once. Each agents has its own depot, + # so we just need to check if there are no duplicate values in the selected nodes + unique, counts = torch.unique(selected, return_counts=True, dim=-1) + if (counts > 1).any(): + raise ValueError(f"Duplicate values in selected nodes: {unique[counts > 1]}") + + def _get_reward(self, td: TensorDict, action: torch.Tensor) -> torch.Tensor: + """Return the reward for the current state (negative cost) + + Modes: + - minmax: the reward is the maximum length of all agents + - minsum: the reward is the sum of all agents' length + - lateness: the reward is the sum of all agents' length plus the lateness with a weight + - lateness_square: same as lateness but the lateness is squared + """ + if self.reward_mode == "minmax": + cost = torch.max(td["current_length"], dim=-1)[0] + elif self.reward_mode == "minsum": + cost = torch.sum(td["current_length"], dim=(-1)) + elif self.reward_mode in ["lateness_square", "lateness"]: + # SECTION: get the cost (route length) + cost = torch.sum(td["current_length"], dim=(-1)) + # SECTION: get the lateness (delivery time) + num_agents = td["current_node"].size(-1) + num_cities = td["locs"].shape[-2] - num_agents + num_pickup = num_agents + int(num_cities / 2) + lateness = td["arrivetime_record"][..., num_pickup:] + if self.reward_mode == "lateness_square": + lateness = lateness**2 + lateness = torch.sum(lateness, dim=-1) + # lateness weight - note that if this is 0, the reward is the same as the cost + # if this is 1, the reward is the same as the lateness + cost = ( + cost * (1 - td["lateness_weight"].squeeze()) + + lateness * td["lateness_weight"].squeeze() + ) + else: + raise NotImplementedError( + f"Invalid reward mode: {self.reward_mode}. Available modes: minmax, minsum, lateness_square, lateness" + ) + return -cost # minus for reward + + def get_distance(self, prev_loc, cur_loc): + # Use L1 norm to calculate the distance for Manhattan distance + if self.dist_norm == "L1": + return torch.abs(cur_loc - prev_loc).norm(p=1, dim=-1) + elif self.dist_norm == "L2": + return torch.abs(cur_loc - prev_loc).norm(p=2, dim=-1) + else: + raise ValueError(f"Invalid distance norm: {self.dist_norm}") + + # @profile + def get_action_mask(self, td: TensorDict) -> torch.Tensor: + device = td.device + + action_mask = torch.repeat_interleave( + td["available"][..., None, :], dim=-2, repeats=td["current_node"].shape[-1] + ) + num_agents = td["current_node"].size(-1) + num_cities = td["locs"].shape[-2] - num_agents + num_pickup = num_agents + int(num_cities / 2) - 1 + + # Status flag for that if an agent picked up something: 1-picked up something, 0-free status + # Shape: [B, num_agents] + pickup_flag = ( + torch.sum(td["delivery_record"][..., num_agents : num_pickup + 1], dim=-1) > 0 + ) + + # Dilivery node only available when the agent picked up the matched item + action_mask[..., num_pickup + 1 :] &= td["delivery_record"][ + ..., num_agents : num_pickup + 1 + ].bool() + + # Mask for agents went out and came back to depot + # 1-went back and back to the depot; 0-still outside or init conflit in the depot; + is_back_agent_mask = torch.logical_xor( + td["current_node"] >= num_agents, td["current_length"] + ) + is_back_agent_mask &= ~(td["current_node"] >= num_agents) + + # Mask for agents reached the max order + reach_max_order_flag = td["num_orders"] >= td["capacity"] + action_mask[..., num_agents : num_pickup + 1] &= ~reach_max_order_flag[..., None] + + # If back_agent_mask is True, set all nodes to be unavailable except the depot + action_mask &= ~is_back_agent_mask[..., None] + + # Depot is available for agents: 1. back and stay in the depot; 2. finished one pickup and delivery + action_mask[..., 0] = is_back_agent_mask | torch.logical_and( + td["current_node"] >= num_agents, td["current_length"] + ) + + # If an agent picked up something, it can not go back to the depot + action_mask[..., 0] &= ~pickup_flag + + # If all items are picked up, make the depot available to avoid the bug of existing the extream case: + # agents can not select any node + all_picked_up_flag = ( + torch.sum(td["available"][..., num_agents : num_pickup + 1], dim=-1) == 0 + ) + action_mask[..., 0] |= all_picked_up_flag[..., None] & ~pickup_flag + + # Check if all agents came back to the depot before finishing all nodes + all_back_flag = torch.sum(td["current_node"] >= num_agents, dim=-1) == 0 + has_finished_early = (all_back_flag != td["done"]) & all_back_flag + + # If all agents come back to the depot before finishing all nodes, make all unfinished nodes available again and make the depot unavailable + available_pickup = td["available"].clone() + available_pickup[..., num_pickup + 1 :] = 0 + action_mask |= ( + has_finished_early[..., None, None] & available_pickup[..., None, :] + ) + action_mask[..., 0] &= ~has_finished_early[..., None] + + # If done, set depot to available to pad the action sequence + action_mask[..., 0] |= td["done"][..., None] + + # Create an eye matrix to extract the num_agent'th value in the num_node dimension for each batch + eye_matrix = torch.eye(num_agents, device=device) + eye_matrix = eye_matrix[None, ...].repeat(td["locs"].size(0), 1, 1).bool() + eye_matrix &= action_mask[..., 0][..., None] + + # Update the original tensor using the mask + action_mask[..., :num_agents] = eye_matrix + + return action_mask + + def _make_spec(self, td_params: TensorDict = None): + # Looks like this is needed somehow + self.reward_spec = UnboundedContinuousTensorSpec(shape=(1,)) + self.done_spec = BoundedTensorSpec(shape=(1,), dtype=torch.bool, low=0, high=1) + pass + + @staticmethod + def render(*args, **kwargs): + return render(*args, **kwargs) diff --git a/parco/envs/omdcpdp/generator.py b/parco/envs/omdcpdp/generator.py new file mode 100644 index 0000000..521df95 --- /dev/null +++ b/parco/envs/omdcpdp/generator.py @@ -0,0 +1,91 @@ +import torch + +from rl4co.envs.common.utils import Generator +from rl4co.utils.pylogger import get_pylogger +from tensordict.tensordict import TensorDict + +log = get_pylogger(__name__) + + +class OMDCPDPGenerator(Generator): + def __init__( + self, + num_loc: int = 200, + num_agents: int = 40, + min_loc: float = 0.0, + max_loc: float = 1.0, + capacity_min: int = 3, + capacity_max: int = 3, + min_lateness_weight: float = 1.0, + max_lateness_weight: float = 1.0, + use_different_depot_locations: bool = True, + ): + self.num_loc = num_loc + self.num_agents = num_agents + self.min_loc = min_loc + self.max_loc = max_loc + self.capacity_min = capacity_min + self.capacity_max = capacity_max + self.min_lateness_weight = min_lateness_weight + self.max_lateness_weight = max_lateness_weight + self.use_different_depot_locations = use_different_depot_locations + + def _generate(self, batch_size) -> TensorDict: + batch_size = [batch_size] if isinstance(batch_size, int) else batch_size + num_orders = int(self.num_loc / 2) + + # Generate the pickup locations + pickup_locs = torch.FloatTensor(*batch_size, num_orders, 2).uniform_( + self.min_loc, self.max_loc + ) + + # Generate the delivery locations + delivery_locs = torch.FloatTensor(*batch_size, num_orders, 2).uniform_( + self.min_loc, self.max_loc + ) + + # Depots: if we use different depot locations, we have to generate them randomly. Otherwise, we just copy the first node + n_diff_depots = self.num_agents if self.use_different_depot_locations else 1 + depots = torch.FloatTensor(*batch_size, n_diff_depots, 2).uniform_( + self.min_loc, self.max_loc + ) + + # Initialize the num_agents: either fixed or random integer between min and max + num_agents = torch.ones(*batch_size, dtype=torch.int64) * n_diff_depots + + if self.capacity_min == self.capacity_max: + # homogeneous capacity + capacity = ( + torch.zeros( + *batch_size, + num_agents.max().item(), + dtype=torch.int64, + ) + + self.capacity_min + ) + else: + # heterogeneous capacity + capacity = torch.randint( + self.capacity_min, + self.capacity_max + 1, + (*batch_size, num_agents.max().item()), + ) + + cities = torch.cat([pickup_locs, delivery_locs], dim=-2) + + # Lateness weight - note that if this is 0, the reward is the same as the cost. + # If this is 1, the reward is the same as the lateness + lateness_weight = torch.FloatTensor(*batch_size, 1).uniform_( + self.min_lateness_weight, self.max_lateness_weight + ) + + return TensorDict( + { + "depots": depots, + "locs": cities, # NOTE: here locs does NOT include depot + "num_agents": num_agents, + "lateness_weight": lateness_weight, + "capacity": capacity, + }, + batch_size=batch_size, + ) diff --git a/parco/envs/omdcpdp/render.py b/parco/envs/omdcpdp/render.py new file mode 100644 index 0000000..8d188e0 --- /dev/null +++ b/parco/envs/omdcpdp/render.py @@ -0,0 +1,99 @@ +import torch + +from matplotlib.axes import Axes +from tensordict import TensorDict + + +def render( + td: TensorDict, + actions: torch.Tensor = None, + ax: Axes = None, + batch_idx: int = None, + plot_number: bool = False, + add_depot_to_actions: bool = True, + print_subtours: bool = False, + problem_mode: str = "open", +): + """Visualize the solution of the problem + Args: + actions [batch_size, num_agents * steps]: from i*steps to (i+1)*steps-1 + are the actions of agent i + """ + import matplotlib.pyplot as plt + + num_agents = int(td["num_agents"].max().item()) + num_cities = td["locs"].shape[-2] - num_agents + num_pickup = num_agents + int(num_cities / 2) + + def draw_line(src, dst, ax): + ax.plot([src[0], dst[0]], [src[1], dst[1]], ls="--", c="gray") + + td = td.detach().cpu() + + if actions is None: + actions = td.get("action", None) + + if td.batch_size != torch.Size([]): + batch_idx = 0 if batch_idx is None else batch_idx + td = td[0] + actions = actions[0] + + if ax is None: + # Create a plot of the nodes + _, ax = plt.subplots(1, 1, figsize=(4, 4)) + + ax.axis("equal") + + # Plot cities + loc = td["locs"] + + # Plot the pickup cities + ax.scatter( + loc[num_agents:num_pickup, 0], + loc[num_agents:num_pickup, 1], + c="black", + s=30, + marker="^", + ) + + # Plot the delivery cities + ax.scatter(loc[num_pickup:, 0], loc[num_pickup:, 1], c="black", s=30, marker="x") + + # Plot the depot + ax.scatter(loc[:num_agents, 0], loc[:num_agents, 1], c="red", s=50, marker="s") + + # Plot number + if plot_number: + # Annotate the pickup cities + for i, xy in enumerate(loc[num_agents:num_pickup]): + ax.annotate( + f"p{i}", xy=xy, textcoords="offset points", xytext=(0, 5), ha="center" + ) + # Annotate the delivery cities + for i, xy in enumerate(loc[num_pickup:]): + ax.annotate( + f"d{i}", xy=xy, textcoords="offset points", xytext=(0, 5), ha="center" + ) + + # Plot line connecting pickup and delivery + for i in range(num_agents, num_pickup): + draw_line(loc[i], loc[i + num_pickup - num_agents], ax) + + if actions is not None: # draw solution if available. + sub_tours = actions.reshape(num_agents, -1) + loc = td["locs"] + for v_i, sub_tour in enumerate(sub_tours): + if add_depot_to_actions: + d_ = torch.zeros(1, dtype=torch.int64) + v_i + sub_tour = torch.cat([d_, sub_tour]) + if problem_mode == "open": + # If the agent goes back to depot, do not plot the line + init = sub_tour[0] + sub_tour = sub_tour[sub_tour >= num_agents] + sub_tour = torch.cat([init.unsqueeze(0), sub_tour]) + if print_subtours: + print(f"Agent {v_i}: {sub_tour.numpy()}") + ax.plot(loc[sub_tour][:, 0], loc[sub_tour][:, 1], color=f"C{v_i}") + + _ = ax.set_xlim(-0.05, 1.05) + _ = ax.set_ylim(-0.05, 1.05) diff --git a/parco/models/__init__.py b/parco/models/__init__.py new file mode 100644 index 0000000..8cab341 --- /dev/null +++ b/parco/models/__init__.py @@ -0,0 +1,4 @@ +from .decoder import PARCODecoder +from .encoder import PARCOEncoder +from .policy import PARCOPolicy, PARCOMultiStagePolicy +from .rl import PARCORLModule diff --git a/parco/models/agent_handlers.py b/parco/models/agent_handlers.py new file mode 100644 index 0000000..94c0ea5 --- /dev/null +++ b/parco/models/agent_handlers.py @@ -0,0 +1,195 @@ +import abc + +from typing import Callable, List, Union + +import torch + +from rl4co.utils.ops import gather_by_index +from rl4co.utils.pylogger import get_pylogger + +log = get_pylogger(__name__) + + +class AgentHandler(abc.ABC): + """Base class for agent handlers. Handles conflicts between agents. + By default, one occurrence is always kept (i.e. one agent among agents + that selected the same action is selected). + + Args: + mask_all: If True, the all occurrences of the same value will be masked, i.e. no agent will select it. + exclude_values: If provided, the values in the actions that are in this list will not be masked. + return_none_mask: If True, the mask will be None. This may be useful for loss computation. + """ + + def __init__( + self, + mask_all: bool = False, + exclude_values: Union[torch.Tensor, int, List] = None, + return_none_mask: bool = False, + ): + super(AgentHandler, self).__init__() + self.mask_all = mask_all + self.exclude_values = exclude_values + self.return_none_mask = return_none_mask + + @abc.abstractmethod + def _preprocess_actions( + self, actions: torch.Tensor, td, probs: torch.Tensor, **kwargs + ) -> torch.Tensor: + """Preprocesses actions such that first action in order to appear with an index will be selected""" + raise NotImplementedError("Subclasses must implement this method.") + + def __call__( + self, + actions: torch.Tensor, + replacement_value: Union[torch.Tensor, int] = -1, + td=None, + exclude_values: Union[torch.Tensor, int, List] = None, + probs: torch.Tensor = None, + **kwargs, + ) -> torch.Tensor: + exclude_values = self.exclude_values if exclude_values is None else exclude_values + if isinstance(exclude_values, int): + exclude_values = [exclude_values] + if not isinstance(exclude_values, torch.Tensor) and exclude_values is not None: + exclude_values = torch.tensor(exclude_values, device=actions.device) + + # First reordering of actions based on the type of handler (highest probability, closest, etc.) + sorted_actions1, indices1 = self._preprocess_actions( + actions, td, probs=probs, **kwargs + ) + + # Second reordering of actions based on the index of selected nodes, for masking non-first occurrences + sorted_actions2, indices2 = sorted_actions1.sort(dim=1) + + # Create a mask for non-first occurrences on the sorted actions + mask_sorted = torch.zeros_like(actions, dtype=torch.bool) + mask_sorted[:, 1:] = sorted_actions2[:, 1:] == sorted_actions2[:, :-1] + + # Mask first occurrences on the sorted actions if needed + if self.mask_all: + mask_sorted[:, :-1] |= sorted_actions2[:, :-1] == sorted_actions2[:, 1:] + + # Recover the mask_sorted based on the second reordering of actions + mask_sorted = mask_sorted.gather(1, indices2.argsort(dim=1)) + + # Recover the mask_sorted based on the first reordering of actions + mask = mask_sorted.gather(1, indices1.argsort(dim=1)) + + # If exclude_values is provided, we set their mask to False so that they are not replaced + if self.exclude_values is not None: + self.exclude_values = self.exclude_values.to(actions.device) + mask = mask & ~torch.isin(actions, self.exclude_values) + + # Replace values in the original actions using the mask + if isinstance(replacement_value, int): + actions[mask] = replacement_value + else: + actions[mask] = replacement_value[mask] + + # Calculate num of conflicts (sum of true values in mask / total) + halting_ratio = mask.sum().float() / (mask.numel()) + return actions, mask if not self.return_none_mask else None, halting_ratio + + +class FirstPrecedenceAgentHandler(AgentHandler): + """First agent in dim 1 is selected in case of conflicts""" + + def _preprocess_actions(self, actions: torch.Tensor, *args, **kwargs) -> torch.Tensor: + indices = torch.arange(actions.size(1), device=actions.device).repeat( + actions.size(0), 1 + ) + return actions, indices + + +class RandomAgentHandler(AgentHandler): + """Random agent in dim 1 is selected in case of conflicts""" + + def _preprocess_actions(self, actions: torch.Tensor, *args, **kwargs) -> torch.Tensor: + indices_ = torch.randperm(actions.size(1), device=actions.device).repeat( + actions.size(0), 1 + ) + shuffled_actions = torch.gather(actions, 1, indices_) + return shuffled_actions, indices_ + + +class ClosestAgentHandler(AgentHandler): + """Closest agent to target node in dim 1 is selected in case of conflicts""" + + def _preprocess_actions( + self, actions: torch.Tensor, td, *args, **kwargs + ) -> torch.Tensor: + current_loc = gather_by_index(td["locs"], td["current_node"]) + target_loc = gather_by_index(td["locs"], actions) + distances = torch.norm(current_loc - target_loc, dim=-1) + _, indices = torch.sort(distances, dim=-1, descending=False, stable=True) + sorted_actions = gather_by_index(actions, indices) + return sorted_actions, indices + + +class HighestProbabilityAgentHandler(AgentHandler): + """Highest probability agent in dim 1 is selected in case of conflicts""" + + def _preprocess_actions(self, actions: torch.Tensor, td, probs) -> torch.Tensor: + # sort indices by probability + action_probs = gather_by_index(probs, actions, dim=-1) + _, indices = torch.sort(action_probs, dim=-1, descending=True, stable=True) + sorted_actions = gather_by_index(actions, indices) + return sorted_actions, indices + + +class SmallestPathToClosure(AgentHandler): + """Use agent that has the lowest current path""" + + def __init__(self, *args, count_depot=False, **kwargs): + super().__init__(*args, **kwargs) + self.count_depot = count_depot + + def _preprocess_actions(self, actions: torch.Tensor, td, probs) -> torch.Tensor: + # sort indices by probability + current_loc = gather_by_index(td["locs"], td["current_node"]) + target_loc = gather_by_index(td["locs"], actions) + distances_to_target = torch.norm(current_loc - target_loc, dim=-1) + if self.count_depot: + distance_target_depot = torch.norm( + target_loc - td["locs"][..., 0:1, :], dim=-1 + ) + else: + distance_target_depot = 0 + distance_target_depot = torch.norm( + target_loc - td["locs"][..., 0:1, :], dim=-1 + ) # just singled depot + current_traveled = td["current_length"] + total_distance = distances_to_target + current_traveled + distance_target_depot + _, indices = torch.sort(total_distance, dim=-1, descending=False, stable=True) + sorted_actions = gather_by_index(actions, indices) + return sorted_actions, indices + + +class LowestLateness(SmallestPathToClosure): + def _preprocess_actions(self, actions: torch.Tensor, td, probs) -> torch.Tensor: + # TODO + raise NotImplementedError("Not implemented yet.") + + +class NoHandler(AgentHandler): + """No handler is used, i.e. all agents can select the same action. The mask is always None.""" + + def __call__(self, actions: torch.Tensor, *args, **kwargs): + return actions, None + + +AGENT_HANDLER_REGISTRY = { + "first": FirstPrecedenceAgentHandler, + "random": RandomAgentHandler, + "closest": ClosestAgentHandler, + "highprob": HighestProbabilityAgentHandler, + "smallestpath": SmallestPathToClosure, + "none": NoHandler, +} + + +def get_agent_handler( + name: str, registry: dict = AGENT_HANDLER_REGISTRY, **config +) -> Callable: + return registry[name](**config) diff --git a/parco/models/augmentations.py b/parco/models/augmentations.py new file mode 100644 index 0000000..a1cd85f --- /dev/null +++ b/parco/models/augmentations.py @@ -0,0 +1,76 @@ +import torch + +from rl4co.data.transforms import ( + TensorDict, + batchify, + min_max_normalize, + symmetric_augmentation, +) + + +def graph_dilation(X, c, min_s=0.5, max_s=1.0): + s = (torch.rand([X.shape[0]], device=X.device)) * (max_s - min_s) + min_s + + # Expand dimensions of s and c for broadcasting with X + s = s[..., None, None] + c = c.expand_as(X) + + Y = s * (X - c) + c + return Y, s, c + + +def augment_graph(X, min_s=0.5, max_s=1.0, **kw): + batch_size, num_nodes, _ = X.shape + c = torch.rand(batch_size, 1, 2, device=X.device) + out, s, c = graph_dilation(X, c, min_s=min_s, max_s=max_s) + return out, s, c + + +class DilationAugmentation(object): + def __init__( + self, + env_name: str = None, + num_augment: int = 8, + use_symmetric_augment: bool = True, + min_s: float = 0.5, + max_s: float = 1.0, + normalize: bool = False, + first_aug_identity: bool = True, + **unused_kwargs, + ): + self.feats = ["locs"] + self.num_augment = num_augment + self.use_symmetric_augment = use_symmetric_augment + self.normalize = normalize + self.augmentation = augment_graph + if use_symmetric_augment: + self.aug_sym = symmetric_augmentation + self.min_s = min_s + self.max_s = max_s + self.first_aug_identity = first_aug_identity + + def __call__(self, td: TensorDict) -> TensorDict: + td_aug = batchify(td, self.num_augment) + + for feat in self.feats: + init_aug_feat = td_aug[feat][:, 0].clone() + + # Dilation augmentation + aug_feat, s, c = self.augmentation( + td_aug[feat], min_s=self.min_s, max_s=self.max_s + ) + + # Symmetric augmentation + if self.use_symmetric_augment: + aug_feat = self.aug_sym(aug_feat, self.num_augment) + + # Set feat + td_aug[feat] = aug_feat + if self.normalize: + td_aug[feat] = min_max_normalize(td_aug[feat]) + + if self.first_aug_identity: + # first augmentation is identity + aug_feat[:, 0] = init_aug_feat + + return td_aug, s, c diff --git a/parco/models/decoder.py b/parco/models/decoder.py new file mode 100644 index 0000000..8a8fc3d --- /dev/null +++ b/parco/models/decoder.py @@ -0,0 +1,201 @@ +from typing import Tuple +import torch +import torch.nn as nn + +from rl4co.envs import RL4COEnvBase +from rl4co.models.zoo.am.decoder import AttentionModelDecoder, PrecomputedCache +from rl4co.utils.ops import unbatchify +from rl4co.utils.pylogger import get_pylogger +from tensordict import TensorDict +from torch import Tensor + +from .env_embeddings import env_context_embedding, env_dynamic_embedding + +log = get_pylogger(__name__) + + +class PARCODecoder(AttentionModelDecoder): + def __init__( + self, + embed_dim: int = 128, + num_heads: int = 8, + env_name: str = "hcvrp", + context_embedding: nn.Module = None, + context_embedding_kwargs: dict = {}, + dynamic_embedding: nn.Module = None, + dynamic_embedding_kwargs: dict = {}, + use_graph_context: bool = False, + **kwargs, + ): + context_embedding_kwargs["embed_dim"] = embed_dim # replace + if context_embedding is None: + context_embedding = env_context_embedding( + env_name, context_embedding_kwargs) + + if dynamic_embedding is None: + dynamic_embedding = env_dynamic_embedding( + env_name, dynamic_embedding_kwargs) + + if use_graph_context: + raise ValueError("PARCO does not use graph context") + + super(PARCODecoder, self).__init__( + embed_dim=embed_dim, + num_heads=num_heads, + env_name=env_name, + context_embedding=context_embedding, + dynamic_embedding=dynamic_embedding, + use_graph_context=use_graph_context, + **kwargs, + ) + + def forward( + self, + td: TensorDict, + cached, + num_starts: int = 0, + do_unbatchify: bool = False, + ) -> Tuple[Tensor, Tensor]: + """Compute the logits of the next actions given the current state + + Args: + cache: Precomputed embeddings + td: TensorDict with the current environment state + num_starts: Number of starts for the multi-start decoding + """ + + # i.e. during sampling, operate only once during all steps + if num_starts > 1 and do_unbatchify: + td = unbatchify(td, num_starts) + td = td.contiguous().view(-1) + # agent embedding (glimpse_q): [B*S, m, N] B: batch size, S: sampling size, m: num_agents, N: embed_dim + glimpse_q = self._compute_q(cached, td) + glimpse_k, glimpse_v, logit_k = self._compute_kvl(cached, td) + + # Masking: 1 means available, 0 means not available + mask = td["action_mask"] + + # After pass communication layer reshape glimpse_q [B*S, m, N] -> [B, S*m, N] for efficient pointer attiention + if num_starts > 1: + batch_size = glimpse_k.shape[0] + glimpse_q = glimpse_q.reshape(batch_size, -1, self.embed_dim) + mask = mask.reshape(batch_size, glimpse_q.shape[1], -1) + + # Compute logits + logits = self.pointer(glimpse_q, glimpse_k, glimpse_v, logit_k, mask) + + # For passing to the next step commnuication layer, reshape logits and mask to [B*S, m, N] if num_starts > 1 + if num_starts > 1: + logits = logits.reshape( + batch_size * num_starts, -1, logits.shape[-1]) + mask = mask.reshape(batch_size * num_starts, -1, mask.shape[-1]) + glimpse_q = glimpse_q.reshape( + batch_size * num_starts, -1, glimpse_q.shape[-1] + ) + + return logits, mask + + def pre_decoder_hook( + self, td, env, embeddings, num_starts: int = 0 + ) -> Tuple[TensorDict, RL4COEnvBase, PrecomputedCache]: + """Precompute the embeddings cache before the decoder is called""" + cached = self._precompute_cache(embeddings, num_starts=num_starts) + + # when we do multi-sampling, only node embeddings are repeated + if num_starts > 1: + cached.node_embeddings = cached.node_embeddings.repeat_interleave( + num_starts, dim=0 + ) + + return td, env, cached + + +class MatNetDecoder(PARCODecoder): + def __init__( + self, + stage_idx: int, + stage_cnt: int, + embed_dim: int = 256, + num_heads: int = 16, + scale_factor: int = 10, + env_name: str = "ffsp", + context_embedding: nn.Module = None, + context_embedding_kwargs: dict = {}, + dynamic_embedding: nn.Module = None, + dynamic_embedding_kwargs: dict = {}, + **kwargs + ): + + context_embedding_kwargs.update({ + "stage_idx": stage_idx, + "stage_cnt": stage_cnt, + "embed_dim": embed_dim, + "scale_factor": scale_factor, + }) + + dynamic_embedding_kwargs.update({ + "embed_dim": embed_dim + }) + + super(MatNetDecoder, self).__init__( + embed_dim=embed_dim, + num_heads=num_heads, + env_name=env_name, + context_embedding=context_embedding, + context_embedding_kwargs=context_embedding_kwargs, + dynamic_embedding=dynamic_embedding, + dynamic_embedding_kwargs=dynamic_embedding_kwargs, + use_graph_context=False, + **kwargs + ) + + self.stage_idx = stage_idx + self.project_agent_embeddings = nn.Linear(embed_dim, embed_dim, bias=False) + self.no_job_emb = nn.Parameter(torch.rand(1, 1, embed_dim), requires_grad=True) + + def _precompute_cache(self, embeddings: Tuple[Tensor, Tensor], num_starts: int = 0): + job_emb, ma_emb = embeddings + + queries = self.project_agent_embeddings(ma_emb) + + ( + glimpse_key_fixed, + glimpse_val_fixed, + logit_key, + ) = self.project_node_embeddings(job_emb).chunk(3, dim=-1) + + # Organize in a dataclass for easy access + return PrecomputedCache( + node_embeddings=queries, + graph_context=0, + glimpse_key=glimpse_key_fixed, + glimpse_val=glimpse_val_fixed, + logit_key=logit_key, + ) + + def _compute_kvl(self, cached: PrecomputedCache, td: TensorDict): + bs = td.batch_size + glimpse_k, glimpse_v, logit_k = super()._compute_kvl(cached, td) + encoded_no_job = self.no_job_emb.expand(*bs, 1, -1) + # shape: (batch, pomo, jobs+1, embedding) + logit_k_w_dummy = torch.cat((logit_k, encoded_no_job), dim=1) + return glimpse_k, glimpse_v, logit_k_w_dummy + + def pre_decoder_hook( + self, td, env, embeddings, num_starts: int = 0 + ) -> Tuple[TensorDict, RL4COEnvBase, PrecomputedCache]: + """Precompute the embeddings cache before the decoder is called""" + cached = self._precompute_cache(embeddings, num_starts=num_starts) + + has_dyn_emb_multi_start = self.is_dynamic_embedding and num_starts > 1 + + # Handle efficient multi-start decoding + if has_dyn_emb_multi_start: + # if num_starts > 0 and we have some dynamic embeddings, we need to reshape them to [B*S, ...] + # since keys and values are not shared across starts (i.e. the episodes modify these embeddings at each step) + cached = cached.batchify(num_starts=num_starts) + + elif num_starts > 1: + td = unbatchify(td, num_starts) + + return td, env, cached \ No newline at end of file diff --git a/parco/models/decoding_strategies.py b/parco/models/decoding_strategies.py new file mode 100644 index 0000000..829256d --- /dev/null +++ b/parco/models/decoding_strategies.py @@ -0,0 +1,365 @@ +import abc + +from typing import Tuple + +import torch +import torch.nn.functional as F +from einops import rearrange + +from rl4co.envs import RL4COEnvBase +from rl4co.utils.decoding import process_logits +from rl4co.utils.ops import batchify, gather_by_index, unbatchify, unbatchify_and_gather +from rl4co.utils.pylogger import get_pylogger +from tensordict.tensordict import TensorDict + +log = get_pylogger(__name__) + + +def parco_get_decoding_strategy(decoding_strategy, **config): + strategy_registry = { + "greedy": Greedy, + "sampling": Sampling, + "evaluate": Evaluate, + } + + if decoding_strategy not in strategy_registry: + log.warning( + f"Unknown decode type '{decoding_strategy}'. Available decode types: {strategy_registry.keys()}. Defaulting to Sampling." + ) + + if "multistart" in decoding_strategy: + raise ValueError("Multistart is not supported for multi-agent decoding") + + return strategy_registry.get(decoding_strategy, Sampling)(**config) + + +class PARCODecodingStrategy(metaclass=abc.ABCMeta): + name = "base" + + def __init__( + self, + num_agents: int, + agent_handler=None, # Agent handler + use_init_logp: bool = True, # Return initial logp for actions even with conflicts + mask_handled: bool = False, # Mask out handled actions (make logprobs 0) + replacement_value_key: str = "current_node", # When stopping arises (conflict or POS token), replace the value of this key + temperature: float = 1.0, + top_p: float = 0.0, + top_k: int = 0, + tanh_clipping: float = 10.0, + multistart: bool = False, + multisample: bool = False, + num_samples: int = 1, + select_best: bool = False, + store_all_logp: bool = False, + ) -> None: + # PARCO-related + if mask_handled and agent_handler is None: + raise ValueError( + "mask_handled is only supported when agent_handler is not None for now" + ) + + if store_all_logp and mask_handled: + raise ValueError("store_all_logp is not supported when mask_handled is True") + + if mask_handled and use_init_logp: + raise ValueError( + "We should not mask out the initial action logp, rather the final action logp" + ) + + self.use_init_logp = use_init_logp + self.mask_handled = mask_handled + self.store_all_logp = store_all_logp + self.num_agents = num_agents + self.agent_handler = agent_handler + self.replacement_value_key = replacement_value_key + + self.temperature = temperature + self.top_p = top_p + self.top_k = top_k + self.tanh_clipping = tanh_clipping + if multistart: + raise ValueError("Multistart is not supported for multi-agent decoding") + self.multistart = multistart + self.multisample = multisample + self.num_samples = num_samples + if self.num_samples > 1: + self.multisample = True + self.select_best = select_best + + # initialize buffers + self.actions = [] + self.logprobs = [] + self.handling_masks = [] + self.halting_ratios = [] + self.iter_count = 0 + + @abc.abstractmethod + def _step( + self, + logprobs: torch.Tensor, + mask: torch.Tensor, + td: TensorDict, + action: torch.Tensor = None, + **kwargs, + ) -> Tuple[torch.Tensor, torch.Tensor, TensorDict]: + raise NotImplementedError("Must be implemented by subclass") + + def pre_decoder_hook( + self, td: TensorDict, env: RL4COEnvBase, action: torch.Tensor = None + ): + """Pre decoding hook. This method is called before the main decoding operation.""" + + if self.num_samples >= 1: + # Expand td to batch_size * num_samples + td = batchify(td, self.num_samples) + + return td, env, self.num_samples # TODO: check + + def post_decoder_hook( + self, td: TensorDict, env: RL4COEnvBase + ) -> Tuple[torch.Tensor, torch.Tensor, TensorDict, RL4COEnvBase]: + """ " + Size depends on whether we store all log p or not. By default, we don't + Returns: + logprobs: [B, m, L] + actions: [B, m, L] + """ + assert ( + len(self.logprobs) > 0 + ), "No logprobs were collected because all environments were done. Check your initial state" + # [B, m, L] (or is it?) + logprobs = torch.stack(self.logprobs, -1) + actions = torch.stack(self.actions, -1) + + if len(self.handling_masks) > 0: + if self.handling_masks[0] is not None: + torch.stack(self.handling_masks, 2) + else: + pass + else: + pass + + halting_ratios = ( + torch.stack(self.halting_ratios, 0) if len(self.halting_ratios) > 0 else 0 + ) + + if self.num_samples > 0 and self.select_best: + logprobs, actions, td, env = self._select_best(logprobs, actions, td, env) + + return logprobs, actions, td, env, halting_ratios + + def step( + self, + logits: torch.Tensor, + mask: torch.Tensor, + td: TensorDict = None, + **kwargs, + ) -> TensorDict: + self.iter_count += 1 + + logprobs = process_logits( + logits, + mask, + temperature=self.temperature, + top_p=self.top_p, + top_k=self.top_k, + tanh_clipping=self.tanh_clipping, + ) + + logprobs, actions, td = self._step(logprobs, mask, td, **kwargs) + actions_init = actions.clone() + + # Solve conflicts via agent handler + replacement_value = td[self.replacement_value_key] # replace with previous node + + actions, handling_mask, halting_ratio = self.agent_handler( + actions, replacement_value, td, probs=logprobs.clone() + ) + self.handling_masks.append(handling_mask) + self.halting_ratios.append(halting_ratio) + + # for others + if not self.store_all_logp: + actions_gather = actions_init if self.use_init_logp else actions + # logprobs: [B, m, N], actions_cur: [B, m] + # transform logprobs to [B, m] + + logprobs = gather_by_index(logprobs, actions_gather, dim=-1) + + # We do this after gathering the logprobs + if self.mask_handled: + logprobs.masked_fill_(handling_mask, 0) + + td.set("action", actions) + self.actions.append(actions) + self.logprobs.append(logprobs) + return td + + @staticmethod + def greedy(logprobs, mask=None): + """Select the action with the highest probability.""" + selected = logprobs.argmax(dim=-1) # [B, m, N] -> [B, m] + if mask is not None: # [B, m, N] + assert ( + not (~mask).gather(-1, selected.unsqueeze(-1)).data.any() + ), "infeasible action selected" + return selected + + @staticmethod + def sampling(logprobs, mask=None): + """Sample an action with a multinomial distribution given by the log probabilities.""" + + distribution = torch.distributions.Categorical(logits=logprobs) + selected = distribution.sample() # samples [B, m, N] -> [B, m] + + if mask is not None: + # checking for bad values sampling; but is this needed? + while (~mask).gather(-1, selected.unsqueeze(-1)).data.any(): + log.info("Sampled bad values, resampling!") + # selected = probs.multinomial(1).squeeze(1) + selected = distribution.sample() + assert ( + not (~mask).gather(-1, selected.unsqueeze(-1)).data.any() + ), "infeasible action selected" + return selected + + def _select_best(self, logprobs, actions, td: TensorDict, env: RL4COEnvBase): + # TODO: check + rewards = env.get_reward(td, actions) + _, max_idxs = unbatchify(rewards, self.num_samples).max(dim=-1) + + actions = unbatchify_and_gather(actions, max_idxs, self.num_samples) + logprobs = unbatchify_and_gather(logprobs, max_idxs, self.num_samples) + td = unbatchify_and_gather(td, max_idxs, self.num_samples) + + return logprobs, actions, td, env + + +class Greedy(PARCODecodingStrategy): + name = "greedy" + + def _step( + self, logprobs: torch.Tensor, mask: torch.Tensor, td: TensorDict, **kwargs + ) -> Tuple[torch.Tensor, torch.Tensor, TensorDict]: + """Select the action with the highest log probability""" + selected = self.greedy(logprobs, mask) + return logprobs, selected, td + + +class Sampling(PARCODecodingStrategy): + name = "sampling" + + def _step( + self, logprobs: torch.Tensor, mask: torch.Tensor, td: TensorDict, **kwargs + ) -> Tuple[torch.Tensor, torch.Tensor, TensorDict]: + """Sample an action with a multinomial distribution given by the log probabilities.""" + selected = self.sampling(logprobs, mask) + return logprobs, selected, td + + +class Evaluate(PARCODecodingStrategy): + name = "evaluate" + + def _step( + self, + logprobs: torch.Tensor, + mask: torch.Tensor, + td: TensorDict, + action: torch.Tensor, + **kwargs, + ) -> Tuple[torch.Tensor, torch.Tensor, TensorDict]: + """The action is provided externally, so we just return the action""" + selected = action + return logprobs, selected, td + +class PARCO4FFSPDecoding: + + def __init__( + self, + stage_idx, + num_ma, + num_job, + use_pos_token: bool = False + ) -> None: + + self.stage_idx = stage_idx + self.num_ma = num_ma + self.num_job = num_job + self.use_pos_token = use_pos_token + + def step( + self, + logits: torch.Tensor, + mask: torch.Tensor, + td: TensorDict = None, + decode_type: str = "sampling" + ) -> TensorDict: + + batch_size = td.batch_size + device = td.device + + jobs_selected, stage_mas_selected, mas_selected, actions_probs = [], [], [], [] + idle_machines = torch.arange(0, self.num_ma, device=device)[None,:].expand(*batch_size, -1) + + while not mask[...,:-1].all(): + # get the probabilities of all actions given the current mask + logits_masked = logits.masked_fill(mask, -torch.inf) + # shape: (batch * pomo, num_agents * job_cnt+1) + logits_reshaped = rearrange(logits_masked, "b m j -> b (j m)") + probs = F.softmax(logits_reshaped, dim=-1) + # perform decoding + if "sampling" in decode_type: + # shape: (batch * pomo) + selected_action = probs.multinomial(1).squeeze(1) + action_prob = probs.gather(1, selected_action.unsqueeze(1)).squeeze(1) + else: + # shape: (batch * pomo) + selected_action = probs.argmax(dim=-1) + action_prob = torch.zeros(size=batch_size, device=device) + # translate the action + # shape: (batch * pomo) + job_selected = selected_action // self.num_ma + selected_stage_machine = selected_action % self.num_ma + selected_machine = selected_stage_machine + self.num_ma * self.stage_idx + # determine which machines still have to select an action + idle_machines = ( + idle_machines[idle_machines!=selected_stage_machine[:, None]] + .view(*batch_size, -1) + ) + # add action to the buffer + jobs_selected.append(job_selected) + mas_selected.append(selected_machine) + stage_mas_selected.append(selected_stage_machine) + actions_probs.append(action_prob) + # mask job that has been selected in the current step so it cannot be selected by other agents + mask = mask.scatter(-1, job_selected.view(*batch_size, 1, 1).expand(-1, self.num_ma, 1), True) + if self.use_pos_token: + # allow machines that are still idle to wait (for jobs to become available for example) + mask[..., -1] = mask[..., -1].scatter(-1, idle_machines.view(*batch_size, -1), False) + else: + mask[..., -1] = mask[..., -1].scatter(-1, idle_machines.view(*batch_size, -1), ~(mask[..., :-1].all(-1))) + # lastly, mask all actions for the selected agent + mask = mask.scatter(-2, selected_stage_machine.view(*batch_size, 1, 1).expand(-1, 1, self.num_job+1), True) + + if len(jobs_selected) > 0: + jobs_selected = torch.stack(jobs_selected, dim=-1).view(*batch_size, -1) + mas_selected = torch.stack(mas_selected, dim=-1).view(*batch_size, -1) + stage_mas_selected = torch.stack(stage_mas_selected, dim=-1).view(*batch_size, -1) + actions_probs = torch.stack(actions_probs, dim=-1).view(*batch_size, -1) + + actions = TensorDict( + { + "jobs": jobs_selected, + "mas": mas_selected + }, + batch_size=jobs_selected.shape + ) + + else: + actions = None + actions_probs = None + + td.set("action", actions) + td.set("probs", actions_probs) + return td \ No newline at end of file diff --git a/parco/models/encoder.py b/parco/models/encoder.py new file mode 100644 index 0000000..5685b5b --- /dev/null +++ b/parco/models/encoder.py @@ -0,0 +1,131 @@ +from typing import Tuple, Union + +import torch.nn as nn + +from tensordict import TensorDict +from torch import Tensor + +from parco.models.env_embeddings import env_init_embedding +from parco.models.nn.transformer import Normalization, TransformerBlock +from parco.models.nn.matnet import MatNetLayer, HAMEncoderLayer + +class PARCOEncoder(nn.Module): + def __init__( + self, + env_name: str = "hcvrp", + num_heads: int = 8, + embed_dim: int = 128, + num_layers: int = 3, + normalization: str = "instance", + use_final_norm: bool = False, + init_embedding: nn.Module = None, + init_embedding_kwargs: dict = {}, + norm_after: bool = False, + **transformer_kwargs, + ): + super(PARCOEncoder, self).__init__() + + self.env_name = env_name + init_embedding_kwargs["embed_dim"] = embed_dim + self.init_embedding = ( + init_embedding + if init_embedding is not None + else env_init_embedding(self.env_name, init_embedding_kwargs) + ) + + self.layers = nn.Sequential( + *( + TransformerBlock( + embed_dim=embed_dim, + num_heads=num_heads, + normalization=normalization, + norm_after=norm_after, + **transformer_kwargs, + ) + for _ in range(num_layers) + ) + ) + + self.norm = Normalization(embed_dim, normalization) if use_final_norm else None + + def forward( + self, td: TensorDict, mask: Union[Tensor, None] = None + ) -> Tuple[Tensor, Tensor]: + # Transfer to embedding space + init_h = self.init_embedding(td) # [B, N, H] + + # Process embedding + h = init_h + for layer in self.layers: + h = layer(h, mask) + + # https://github.com/meta-llama/llama/blob/8fac8befd776bc03242fe7bc2236cdb41b6c609c/llama/model.py#L493 + if self.norm is not None: + h = self.norm(h) + + # Return latent representation and initial embedding + # [B, N, H] + return h, init_h + + +class MatNetEncoder(nn.Module): + def __init__( + self, + stage_idx: int, + env_name: str = "ffsp", + num_heads: int = 16, + embed_dim: int = 256, + feedforward_hidden: int = 512, + ms_hidden_dim: int = 32, + num_layers: int = 3, + normalization: str = "instance", + init_embedding: nn.Module = None, + init_embedding_kwargs: dict = {}, + scale_factor: float = 1., + parallel_gated_kwargs: dict = None, + use_ham: bool = True, + **transformer_kwargs, + ): + super(MatNetEncoder, self).__init__() + + self.stage_idx = stage_idx + self.env_name = env_name + init_embedding_kwargs["embed_dim"] = embed_dim + self.init_embedding = ( + init_embedding + if init_embedding is not None + else env_init_embedding(self.env_name, init_embedding_kwargs) + ) + if use_ham: + LayerCls = HAMEncoderLayer + else: + LayerCls = MatNetLayer + + self.layers = nn.ModuleList( + [ + LayerCls( + embed_dim=embed_dim, + head_num=num_heads, + ms_hidden_dim=ms_hidden_dim, + feedforward_hidden=feedforward_hidden, + normalization=normalization, + parallel_gated_kwargs=parallel_gated_kwargs, + **transformer_kwargs + ) + for _ in range(num_layers) + ] + ) + self.scale_factor = scale_factor + + def forward(self, td): + proc_times = td["cost_matrix"] + # cost_mat.shape: (batch, row_cnt, col_cnt) + row_emb, col_emb = self.init_embedding(proc_times) + proc_times = proc_times / self.scale_factor + for layer in self.layers: + row_emb, col_emb = layer( + row_emb, + col_emb, + proc_times + ) + return row_emb, col_emb \ No newline at end of file diff --git a/parco/models/env_embeddings/__init__.py b/parco/models/env_embeddings/__init__.py new file mode 100644 index 0000000..2d85d64 --- /dev/null +++ b/parco/models/env_embeddings/__init__.py @@ -0,0 +1,63 @@ +import torch.nn as nn + +from rl4co.models.nn.env_embeddings.dynamic import StaticEmbedding + +from .hcvrp import HCVRPContextEmbedding, HCVRPInitEmbedding +from .omdcpdp import OMDCPDPContextEmbedding, OMDCPDPInitEmbedding +from .ffsp import FFSPInitEmbeddings, FFSPDynamicEmbedding, FFSPContextEmbedding + +def env_embedding_register( + env_name: str, config: dict, registry_default: dict, registry_custom: dict = None +) -> nn.Module: + # Merge dictionaries if registry is not None + embedding_registry = ( + {**registry_default, **registry_custom} + if registry_custom is not None + else registry_default + ) + if env_name not in embedding_registry: + raise ValueError( + f"Unknown environment name '{env_name}'. Available context embeddings: {embedding_registry.keys()}" + ) + return embedding_registry[env_name](**config) + + +def env_init_embedding(env_name: str, config: dict, registry: dict = None) -> nn.Module: + """Register init embedding of the environment""" + + emb_registry = { + "omdcpdp": OMDCPDPInitEmbedding, + "hcvrp": HCVRPInitEmbedding, + "ffsp": FFSPInitEmbeddings, + } + return env_embedding_register(env_name, config, emb_registry, registry) + + +def env_context_embedding( + env_name: str, config: dict, registry: dict = None +) -> nn.Module: + """Register context of the environment""" + emb_registry = { + "omdcpdp": OMDCPDPContextEmbedding, + "hcvrp": HCVRPContextEmbedding, + "ffsp": FFSPContextEmbedding, + } + return env_embedding_register(env_name, config, emb_registry, registry) + + +def env_dynamic_embedding( + env_name: str, config: dict, registry: dict = None +) -> nn.Module: + """Register dynamic embedding of the environment. + The problem in our case does not change, but this can be easily extended + for stochastic environments. + """ + emb_registry = { + "omdcpdp": StaticEmbedding, + "hcvrp": StaticEmbedding, + "ffsp": FFSPDynamicEmbedding, + } + # if not in key, just return static embedding + if env_name not in emb_registry.keys(): + return StaticEmbedding(**config) + return env_embedding_register(env_name, config, emb_registry, registry) diff --git a/parco/models/env_embeddings/communication.py b/parco/models/env_embeddings/communication.py new file mode 100644 index 0000000..e4eeac1 --- /dev/null +++ b/parco/models/env_embeddings/communication.py @@ -0,0 +1,94 @@ +import torch +import torch.nn as nn + +from rl4co.utils.ops import gather_by_index + +from parco.models.nn.transformer import ( + Normalization, + TransformerBlock as CommunicationLayer, +) + + +class BaseMultiAgentContextEmbedding(nn.Module): + """Base class for multi-agent context embedding + + Args: + embed_dim: int, size of the input and output embeddings + agent_feat_dim: int, size of the agent-wise state features + global_feat_dim: int, size of the global state features + linear_bias: bool, whether to use bias in linear layers + use_communication: bool, whether to use communication layers + num_heads: int, number of attention heads + num_communication_layers: int, number of communication layers + **communication_kwargs: dict, additional arguments for the communication layers + """ + + def __init__( + self, + embed_dim, + agent_feat_dim=3, + global_feat_dim=2, + linear_bias=False, + use_communication=True, + use_final_norm=False, + num_communication_layers=1, + **communication_kwargs, # note: see TransformerBlock + ): + super(BaseMultiAgentContextEmbedding, self).__init__() + self.embed_dim = embed_dim + + # Feature projection + self.proj_agent_feats = nn.Linear(agent_feat_dim, embed_dim, bias=linear_bias) + self.proj_global_feats = nn.Linear(global_feat_dim, embed_dim, bias=linear_bias) + self.project_context = nn.Linear(embed_dim * 4, embed_dim, bias=linear_bias) + + if use_communication: + self.communication_layers = nn.Sequential( + *( + CommunicationLayer( + embed_dim=embed_dim, + **communication_kwargs, + ) + for _ in range(num_communication_layers) + ) + ) + else: + self.communication_layers = nn.Identity() + + self.norm = ( + Normalization(embed_dim, communication_kwargs.get("normalization", "rms")) + if use_final_norm + else None + ) + + def _agent_state_embedding(self, embeddings, td, num_agents, num_cities): + """Embedding for agent-wise state features""" + raise NotImplementedError("Implement in subclass") + + def _global_state_embedding(self, embeddings, td, num_agents, num_cities): + """Embedding for global state features""" + raise NotImplementedError("Implement in subclass") + + def forward(self, embeddings, td): + # Collect embeddings + num_agents = td["action_mask"].shape[-2] + num_cities = td["locs"].shape[-2] - num_agents + cur_node_embedding = gather_by_index( + embeddings, td["current_node"] + ) # [B, M, hdim] + depot_embedding = gather_by_index(embeddings, td["depot_node"]) # [B, M, hdim] + agent_state_embed = self._agent_state_embedding( + embeddings, td, num_agents=num_agents, num_cities=num_cities + ) # [B, M, hdim] + global_embed = self._global_state_embedding( + embeddings, td, num_agents=num_agents, num_cities=num_cities + ) # [B, M, hdim] + context_embed = torch.cat( + [cur_node_embedding, depot_embedding, agent_state_embed, global_embed], dim=-1 + ) + # [B, M, hdim, 4] -> [B, M, hdim] + context_embed = self.project_context(context_embed) + h_comm = self.communication_layers(context_embed) + if self.norm is not None: + h_comm = self.norm(h_comm) + return h_comm diff --git a/parco/models/env_embeddings/ffsp.py b/parco/models/env_embeddings/ffsp.py new file mode 100644 index 0000000..a173f87 --- /dev/null +++ b/parco/models/env_embeddings/ffsp.py @@ -0,0 +1,98 @@ +import torch +import torch.nn as nn + +from parco.models.nn.transformer import TransformerBlock as CommunicationLayer + +class FFSPInitEmbeddings(nn.Module): + def __init__(self, one_hot_seed_cnt: int, embed_dim: int = 256) -> None: + super().__init__() + self.one_hot_seed_cnt = one_hot_seed_cnt + self.embed_dim = embed_dim + + def forward(self, problems: torch.Tensor): + # problems.shape: (batch, job_cnt, machine_cnt) + batch_size = problems.size(0) + job_cnt = problems.size(1) + machine_cnt = problems.size(2) + device = problems.device + row_emb = torch.zeros(size=(batch_size, job_cnt, self.embed_dim), device=device) + + # shape: (batch, job_cnt, embedding) + col_emb = torch.zeros(size=(batch_size, machine_cnt, self.embed_dim), device=device) + # shape: (batch, machine_cnt, embedding) + + seed_cnt = max(machine_cnt, self.one_hot_seed_cnt) + rand = torch.rand(batch_size, seed_cnt, device=device) + batch_rand_perm = rand.argsort(dim=1) + rand_idx = batch_rand_perm[:, :machine_cnt] + + b_idx = torch.arange(batch_size, device=device)[:, None].expand(batch_size, machine_cnt) + m_idx = torch.arange(machine_cnt, device=device)[None, :].expand(batch_size, machine_cnt) + col_emb[b_idx, m_idx, rand_idx] = 1 + # shape: (batch, machine_cnt, embedding) + return row_emb, col_emb + + +class FFSPContextEmbedding(nn.Module): + def __init__( + self, + stage_idx: int = None, + stage_cnt: int = None, + embed_dim: int = 256, + scale_factor: int = 10, + use_comm_layer: bool = True, + **communication_layer_kwargs + ) -> None: + + super().__init__() + self.stage_idx = stage_idx + self.stage_cnt = stage_cnt + self.dyn_context = nn.Linear(2, embed_dim) + self.scale_factor = scale_factor + self.use_comm_layer = use_comm_layer + # optional layers + if self.use_comm_layer: + self.communication_layer = CommunicationLayer( + embed_dim=embed_dim, + **communication_layer_kwargs + ) + + def forward(self, ma_emb_proj, td): + # (b, ma) + t_ma_idle = td["t_ma_idle"].chunk(self.stage_cnt, dim=-1)[self.stage_idx] + t_ma_idle = t_ma_idle.to(torch.float32) / self.scale_factor + # shape: (batch, job) + job_in_stage = td["job_location"][:, :-1] == self.stage_idx + # shape: (batch, pomo) + num_in_stage = (job_in_stage.sum(-1) / job_in_stage.size(-1)) + # shape: (batch, pomo, ma, embedding) + ma_wait_proj = self.dyn_context( + torch.stack((t_ma_idle, num_in_stage.unsqueeze(-1).expand_as(t_ma_idle)), dim=-1) + ) + context = ma_emb_proj + ma_wait_proj + if self.use_comm_layer: + context = self.communication_layer(context) + + return context + +class FFSPDynamicEmbedding(nn.Module): + def __init__( + self, + embed_dim: int = 256, + scale_factor: int = 10, + ): + super(FFSPDynamicEmbedding, self).__init__() + self.dyn_kv = nn.Linear(2, 3 * embed_dim) + self.scale_factor = scale_factor + + + def forward(self, td): + job_dyn = torch.stack( + (td["job_location"][:, :-1], td["t_job_ready"][:, :-1] / self.scale_factor), + dim=-1 + ).to(torch.float32) + # shape: (batch, pomo, jobs, 3*embedding) + dyn_job_proj = self.dyn_kv(job_dyn) + # shape: 3 * (batch, pomo, jobs, embedding) + dyn_k, dyn_v, dyn_l = dyn_job_proj.chunk(3, dim=-1) + return dyn_k, dyn_v, dyn_l diff --git a/parco/models/env_embeddings/hcvrp.py b/parco/models/env_embeddings/hcvrp.py new file mode 100644 index 0000000..0c88e4e --- /dev/null +++ b/parco/models/env_embeddings/hcvrp.py @@ -0,0 +1,148 @@ +import torch +import torch.nn as nn + +from rl4co.utils.ops import gather_by_index + +from parco.models.nn.positional_encoder import PositionalEncoder + +from .communication import BaseMultiAgentContextEmbedding + + +class HCVRPInitEmbedding(nn.Module): + """TODO: description + Note that in HCVRP capacities are not the same for all agents and + they need to be rescaled. + """ + + def __init__( + self, + embed_dim: int = 128, + linear_bias: bool = False, + demand_scaler: float = 40.0, + speed_scaler: float = 1.0, + use_polar_feats: bool = True, + ): + super(HCVRPInitEmbedding, self).__init__() + # depot feats: [x0, y0] + self.init_embed_depot = nn.Linear(2, embed_dim, linear_bias) + self.pos_encoder = PositionalEncoder(embed_dim) + self.pos_embedding_proj = nn.Linear(embed_dim, embed_dim, linear_bias) + self.alpha = nn.Parameter(torch.Tensor([1])) + # agent feats: [x0, y0, capacity, speed] + self.init_embed_agents = nn.Linear(4, embed_dim, linear_bias) + # combine depot and agent embeddings + self.init_embed_depot_agents = nn.Linear(2 * embed_dim, embed_dim, linear_bias) + # client feats: [x, y, demand] + client_feats_dim = 5 if use_polar_feats else 3 + self.init_embed_clients = nn.Linear(client_feats_dim, embed_dim, linear_bias) + + self.demand_scaler = demand_scaler + self.speed_scaler = speed_scaler + self.use_polar_feats = use_polar_feats + + def forward(self, td): + num_agents = td["action_mask"].shape[-2] # [B, m, m+N] + depot_locs = td["locs"][..., :num_agents, :] + agents_locs = td["locs"][..., :num_agents, :] + clients_locs = td["locs"][..., num_agents:, :] + + # Depots embedding with positional encoding + depots_embedding = self.init_embed_depot(depot_locs) + pos_embedding = self.pos_encoder(depots_embedding, add=False) + pos_embedding = self.alpha * self.pos_embedding_proj(pos_embedding) + depot_embedding = depots_embedding + pos_embedding + + # Agents embedding + agents_feats = torch.cat( + [ + agents_locs, + td["capacity"][..., None] / self.demand_scaler, + td["speed"][..., None] / self.speed_scaler, + ], + dim=-1, + ) + agents_embedding = self.init_embed_agents(agents_feats) + + # Combine depot and agents embeddings + depot_agents_feats = torch.cat([depot_embedding, agents_embedding], dim=-1) + depot_agents_embedding = self.init_embed_depot_agents(depot_agents_feats) + + # Clients embedding + demands = td["demand"][ + ..., 0, num_agents: + ] # [B, N] , note that demands is repeated but the same in the beginning + clients_feats = torch.cat( + [clients_locs, demands[..., None] / self.demand_scaler], dim=-1 + ) + + if self.use_polar_feats: + # Convert to polar coordinates + depot = depot_locs[..., 0:1, :] + client_locs_centered = clients_locs - depot # centering + dist_to_depot = torch.norm(client_locs_centered, p=2, dim=-1, keepdim=True) + angle_to_depot = torch.atan2( + client_locs_centered[..., 1:], client_locs_centered[..., :1] + ) + clients_feats = torch.cat( + [clients_feats, dist_to_depot, angle_to_depot], dim=-1 + ) + + clients_embedding = self.init_embed_clients(clients_feats) + + return torch.cat( + [depot_agents_embedding, clients_embedding], -2 + ) # [B, m+N, hdim] + + +class HCVRPContextEmbedding(BaseMultiAgentContextEmbedding): + + """TODO""" + + def __init__( + self, + embed_dim, + agent_feat_dim=2, + global_feat_dim=1, + demand_scaler=40.0, + speed_scaler=1.0, + use_time_to_depot=True, + **kwargs, + ): + if use_time_to_depot: + agent_feat_dim += 1 + super(HCVRPContextEmbedding, self).__init__( + embed_dim, agent_feat_dim, global_feat_dim, **kwargs + ) + self.demand_scaler = demand_scaler + self.speed_scaler = speed_scaler + self.use_time_to_depot = use_time_to_depot + + def _agent_state_embedding(self, embeddings, td, num_agents, num_cities): + context_feats = torch.stack( + [ + td["current_length"] + / (td["agents_speed"] / self.speed_scaler), # current time + (td["agents_capacity"] - td["used_capacity"]) + / self.demand_scaler, # remaining capacity + ], + dim=-1, + ) + if self.use_time_to_depot: + depot = td["locs"][..., 0:1, :] + cur_loc = gather_by_index(td["locs"], td["current_node"]) + dist_to_depot = torch.norm(cur_loc - depot, p=2, dim=-1, keepdim=True) + time_to_depot = dist_to_depot / ( + td["agents_speed"][..., None] / self.speed_scaler + ) + context_feats = torch.cat([context_feats, time_to_depot], dim=-1) + return self.proj_agent_feats(context_feats) + + def _global_state_embedding(self, embeddings, td, num_agents, num_cities): + global_feats = torch.cat( + [ + td["visited"][..., num_agents:].sum(-1)[..., None] + / num_cities, # number of visited cities / total + ], + dim=-1, + ) + return self.proj_global_feats(global_feats)[..., None, :].repeat(1, num_agents, 1) diff --git a/parco/models/env_embeddings/omdcpdp.py b/parco/models/env_embeddings/omdcpdp.py new file mode 100644 index 0000000..7a1c142 --- /dev/null +++ b/parco/models/env_embeddings/omdcpdp.py @@ -0,0 +1,98 @@ +import torch +import torch.nn as nn + +from .communication import BaseMultiAgentContextEmbedding + + +class OMDCPDPInitEmbedding(nn.Module): + """Encoder for the initial state of the OMDCPDP environment + Encode the initial state of the environment into a fixed-size vector + Features: + - vehicle: initial position, capacity + - pickup: location, corresponding delivery location + - delivery: location, corresponding pickup location + Note that we do not encode the distance from depot (i.e. initial position) to the pickup/delivery nodes since + the problem is open. + """ + + def __init__(self, embed_dim: int): + super(OMDCPDPInitEmbedding, self).__init__() + # extra_feat: for vehicle: capacity, for pickup: early time, for delivery: ordered time + node_dim = 2 + self.init_embed_vehicle = nn.Linear( + node_dim + 1, embed_dim + ) # vehicle has initial position and capacity + self.init_embed_pick = nn.Linear( + node_dim * 2, embed_dim + ) # concatenate pickup and delivery + self.init_embed_delivery = nn.Linear( + node_dim * 2, embed_dim + ) # concatenate delivery and pickup + + def forward(self, td): + # [B, M, 2] , where M = num_agents + num_pickup + num_delivery (num_pickup = num_delivery) + # num_agents = int(td["num_agents"].max().item()) + num_agents = td["current_node"].size(-1) + num_cities = td["locs"].shape[-2] - num_agents + num_pickup = num_agents + int( + num_cities / 2 + ) # this is the _index_ of the first delivery node + capacities = td[ + "capacity" + ] # in case there are different capacities (heteregenous) + locs = td["locs"] + depot_locs, pickup_locs, delivery_locs = ( + locs[..., :num_agents, :], + locs[..., num_agents:num_pickup, :], + locs[..., num_pickup:, :], + ) + + vehicle_feats = torch.cat([depot_locs, capacities[..., None]], dim=-1) + vehicle_embed = self.init_embed_vehicle(vehicle_feats) + pickup_embed = self.init_embed_pick( + torch.cat( + [pickup_locs, delivery_locs], dim=-1 + ) # merge feats of pickup and delivery + ) + delivery_embed = self.init_embed_delivery( + torch.cat( + [delivery_locs, pickup_locs], dim=-1 + ) # merge feats of delivery and pickup + ) + return torch.cat( + [vehicle_embed, pickup_embed, delivery_embed], dim=-2 + ) # [B, N, hdim] + + +class OMDCPDPContextEmbedding(BaseMultiAgentContextEmbedding): + """Context embedding for OMDCPDP + Encode the following features: + - Agent-wise state features: current length, number of orders + - Global state features: number of visited cities + Note that pickup-delivery pairs and more are embedded in the initial node embeddings + """ + + def __init__(self, embed_dim, agent_feat_dim=2, global_feat_dim=1, **kwargs): + super(OMDCPDPContextEmbedding, self).__init__( + embed_dim, agent_feat_dim, global_feat_dim, **kwargs + ) + + def _agent_state_embedding(self, embeddings, td, num_agents, num_cities): + context_feats = torch.cat( + [ + td["current_length"][..., None], # cost + td["num_orders"][..., None].float(), # capacity + ], + dim=-1, + ) + return self.proj_agent_feats(context_feats) + + def _global_state_embedding(self, embeddings, td, num_agents, num_cities): + global_feats = torch.cat( + [ + td["available"][..., num_agents:].sum(-1)[..., None] + / num_cities, # number of visited cities / total + ], + dim=-1, + ) + return self.proj_global_feats(global_feats)[..., None, :].repeat(1, num_agents, 1) diff --git a/parco/models/nn/ham_encoder.py b/parco/models/nn/ham_encoder.py new file mode 100644 index 0000000..cc60dc6 --- /dev/null +++ b/parco/models/nn/ham_encoder.py @@ -0,0 +1,590 @@ +import math + +import numpy as np +import torch + +from rl4co.models.nn.graph.attnnet import Normalization, SkipConnection +from torch import nn + + +class HeterogeneousMHA(nn.Module): + def __init__( + self, + n_heads, + input_dim, + embed_dim=None, + val_dim=None, + key_dim=None, + num_agents=None, # to set as attribute + ): + super(HeterogeneousMHA, self).__init__() + + if val_dim is None: + assert embed_dim is not None, "Provide either embed_dim or val_dim" + val_dim = embed_dim // n_heads + if key_dim is None: + key_dim = val_dim + self.num_agents = num_agents + + self.n_heads = n_heads + self.input_dim = input_dim + self.embed_dim = embed_dim + self.val_dim = val_dim + self.key_dim = key_dim + + self.norm_factor = 1 / math.sqrt(key_dim) # See Attention is all you need + + self.W_query = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim)) + self.W_key = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim)) + self.W_val = nn.Parameter(torch.Tensor(n_heads, input_dim, val_dim)) + + # pickup + self.W1_query = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim)) + self.W2_query = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim)) + self.W3_query = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim)) + + # delivery + self.W4_query = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim)) + self.W5_query = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim)) + self.W6_query = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim)) + + if embed_dim is not None: + self.W_out = nn.Parameter(torch.Tensor(n_heads, key_dim, embed_dim)) + + self.init_parameters() + + def init_parameters(self): + for param in self.parameters(): + stdv = 1.0 / math.sqrt(param.size(-1)) + param.data.uniform_(-stdv, stdv) + + @property + def set_agent_num(self, agent_num): + self.num_agents = agent_num + + def forward(self, q, h=None, mask=None): + """ + + :param q: queries (batch_size, n_query, input_dim) + :param h: data (batch_size, graph_size, input_dim) + :param mask: mask (batch_size, n_query, graph_size) or viewable as that (i.e. can be 2 dim if n_query == 1) + Mask should contain 1 if attention is not possible (i.e. mask is negative adjacency) + :return: + """ + if h is None: + h = q # compute self-attention + + assert self.num_agents is not None, "self.num_agents is not set" + + # h should be (batch_size, graph_size, input_dim) + batch_size, graph_size, input_dim = h.size() + n_query = q.size(1) + assert q.size(0) == batch_size + assert q.size(2) == input_dim + assert input_dim == self.input_dim, "Wrong embedding dimension of input" + + hflat = h.contiguous().view(-1, input_dim) # [batch_size * graph_size, embed_dim] + qflat = q.contiguous().view(-1, input_dim) # [batch_size * n_query, embed_dim] + + # last dimension can be different for keys and values + shp = (self.n_heads, batch_size, graph_size, -1) + shp_q = (self.n_heads, batch_size, n_query, -1) + + # pickup -> its delivery attention + # print(self.num_agents) + # print(graph_size) + # n_pick = (graph_size - self.num_agents - 1) // 2 + n_pick = (graph_size - self.num_agents) // 2 # !!! + shp_delivery = (self.n_heads, batch_size, n_pick, -1) + shp_q_pick = (self.n_heads, batch_size, n_pick, -1) + + # print("n_pick", n_pick) + # print("shp_delivery", shp_delivery) + # print("shp_q_pick", shp_q_pick) + + # pickup -> all pickups attention + shp_allpick = (self.n_heads, batch_size, n_pick, -1) + shp_q_allpick = (self.n_heads, batch_size, n_pick, -1) + + # pickup -> all pickups attention + shp_alldelivery = (self.n_heads, batch_size, n_pick, -1) + shp_q_alldelivery = (self.n_heads, batch_size, n_pick, -1) + + # Calculate queries, (n_heads, n_query, graph_size, key/val_size) + Q = torch.matmul(qflat, self.W_query).view(shp_q) + # Calculate keys and values (n_heads, batch_size, graph_size, key/val_size) + K = torch.matmul(hflat, self.W_key).view(shp) + V = torch.matmul(hflat, self.W_val).view(shp) + + # NOTE: we make the agent number etc compatible with our implementation + # pickup -> its delivery + pick_flat = ( + h[:, self.num_agents : n_pick + self.num_agents + 0, :] + .contiguous() + .view(-1, input_dim) + ) # [batch_size * n_pick, embed_dim] + delivery_flat = ( + h[:, n_pick + self.num_agents + 0 :, :].contiguous().view(-1, input_dim) + ) # [batch_size * n_pick, embed_dim] + + # pickup -> its delivery attention + Q_pick = torch.matmul(pick_flat, self.W1_query).view( + shp_q_pick + ) # (self.n_heads, batch_size, n_pick, key_size) + K_delivery = torch.matmul(delivery_flat, self.W_key).view( + shp_delivery + ) # (self.n_heads, batch_size, n_pick, -1) + V_delivery = torch.matmul(delivery_flat, self.W_val).view( + shp_delivery + ) # (n_heads, batch_size, n_pick, key/val_size) + + # pickup -> all pickups attention + Q_pick_allpick = torch.matmul(pick_flat, self.W2_query).view( + shp_q_allpick + ) # (self.n_heads, batch_size, n_pick, -1) + K_allpick = torch.matmul(pick_flat, self.W_key).view( + shp_allpick + ) # [self.n_heads, batch_size, n_pick, key_size] + V_allpick = torch.matmul(pick_flat, self.W_val).view( + shp_allpick + ) # [self.n_heads, batch_size, n_pick, key_size] + + # pickup -> all delivery + Q_pick_alldelivery = torch.matmul(pick_flat, self.W3_query).view( + shp_q_alldelivery + ) # (self.n_heads, batch_size, n_pick, key_size) + K_alldelivery = torch.matmul(delivery_flat, self.W_key).view( + shp_alldelivery + ) # (self.n_heads, batch_size, n_pick, -1) + V_alldelivery = torch.matmul(delivery_flat, self.W_val).view( + shp_alldelivery + ) # (n_heads, batch_size, n_pick, key/val_size) + + # pickup -> its delivery + V_additional_delivery = torch.cat( + [ # [n_heads, batch_size, graph_size, key_size] + torch.zeros( + self.n_heads, + batch_size, + self.num_agents + 0, + self.input_dim // self.n_heads, + dtype=V.dtype, + device=V.device, + ), + V_delivery, # [n_heads, batch_size, n_pick, key/val_size] + torch.zeros( + self.n_heads, + batch_size, + n_pick, + self.input_dim // self.n_heads, + dtype=V.dtype, + device=V.device, + ), + ], + 2, + ) + + # delivery -> its pickup attention + Q_delivery = torch.matmul(delivery_flat, self.W4_query).view( + shp_delivery + ) # (self.n_heads, batch_size, n_pick, key_size) + K_pick = torch.matmul(pick_flat, self.W_key).view( + shp_q_pick + ) # (self.n_heads, batch_size, n_pick, -1) + V_pick = torch.matmul(pick_flat, self.W_val).view( + shp_q_pick + ) # (n_heads, batch_size, n_pick, key/val_size) + + # delivery -> all delivery attention + Q_delivery_alldelivery = torch.matmul(delivery_flat, self.W5_query).view( + shp_alldelivery + ) # (self.n_heads, batch_size, n_pick, -1) + K_alldelivery2 = torch.matmul(delivery_flat, self.W_key).view( + shp_alldelivery + ) # [self.n_heads, batch_size, n_pick, key_size] + V_alldelivery2 = torch.matmul(delivery_flat, self.W_val).view( + shp_alldelivery + ) # [self.n_heads, batch_size, n_pick, key_size] + + # delivery -> all pickup + Q_delivery_allpickup = torch.matmul(delivery_flat, self.W6_query).view( + shp_alldelivery + ) # (self.n_heads, batch_size, n_pick, key_size) + K_allpickup2 = torch.matmul(pick_flat, self.W_key).view( + shp_q_alldelivery + ) # (self.n_heads, batch_size, n_pick, -1) + V_allpickup2 = torch.matmul(pick_flat, self.W_val).view( + shp_q_alldelivery + ) # (n_heads, batch_size, n_pick, key/val_size) + + # delivery -> its pick up + # V_additional_pick = torch.cat([ # [n_heads, batch_size, graph_size, key_size] + # torch.zeros(self.n_heads, batch_size, 1, self.input_dim // self.n_heads, dtype=V.dtype, device=V.device), + # V_delivery2, # [n_heads, batch_size, n_pick, key/val_size] + # torch.zeros(self.n_heads, batch_size, n_pick, self.input_dim // self.n_heads, dtype=V.dtype, device=V.device) + # ], 2) + V_additional_pick = torch.cat( + [ # [n_heads, batch_size, graph_size, key_size] + torch.zeros( + self.n_heads, + batch_size, + self.num_agents + 0, + self.input_dim // self.n_heads, + dtype=V.dtype, + device=V.device, + ), + torch.zeros( + self.n_heads, + batch_size, + n_pick, + self.input_dim // self.n_heads, + dtype=V.dtype, + device=V.device, + ), + V_pick, # [n_heads, batch_size, n_pick, key/val_size] + ], + 2, + ) + + # Calculate compatibility (n_heads, batch_size, n_query, graph_size) + compatibility = self.norm_factor * torch.matmul(Q, K.transpose(2, 3)) + + ##Pick up + # ??pair???attention?? + compatibility_pick_delivery = self.norm_factor * torch.sum( + Q_pick * K_delivery, -1 + ) # element_wise, [n_heads, batch_size, n_pick] + # [n_heads, batch_size, n_pick, n_pick] + compatibility_pick_allpick = self.norm_factor * torch.matmul( + Q_pick_allpick, K_allpick.transpose(2, 3) + ) # [n_heads, batch_size, n_pick, n_pick] + + compatibility_pick_alldelivery = self.norm_factor * torch.matmul( + Q_pick_alldelivery, K_alldelivery.transpose(2, 3) + ) # [n_heads, batch_size, n_pick, n_pick] + + ##Delivery + compatibility_delivery_pick = self.norm_factor * torch.sum( + Q_delivery * K_pick, -1 + ) # element_wise, [n_heads, batch_size, n_pick] + + compatibility_delivery_alldelivery = self.norm_factor * torch.matmul( + Q_delivery_alldelivery, K_alldelivery2.transpose(2, 3) + ) # [n_heads, batch_size, n_pick, n_pick] + + compatibility_delivery_allpick = self.norm_factor * torch.matmul( + Q_delivery_allpickup, K_allpickup2.transpose(2, 3) + ) # [n_heads, batch_size, n_pick, n_pick] + + ##Pick up-> + # compatibility_additional?pickup????delivery????attention(size 1),1:n_pick+1??attention,depot?delivery?? + compatibility_additional_delivery = torch.cat( + [ # [n_heads, batch_size, graph_size, 1] + -np.inf + * torch.ones( + self.n_heads, + batch_size, + self.num_agents + 0, + dtype=compatibility.dtype, + device=compatibility.device, + ), + compatibility_pick_delivery, # [n_heads, batch_size, n_pick] + -np.inf + * torch.ones( + self.n_heads, + batch_size, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + ], + -1, + ).view(self.n_heads, batch_size, graph_size, 1) + + compatibility_additional_allpick = torch.cat( + [ # [n_heads, batch_size, graph_size, n_pick] + -np.inf + * torch.ones( + self.n_heads, + batch_size, + self.num_agents + 0, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + compatibility_pick_allpick, # [n_heads, batch_size, n_pick, n_pick] + -np.inf + * torch.ones( + self.n_heads, + batch_size, + n_pick, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + ], + 2, + ).view(self.n_heads, batch_size, graph_size, n_pick) + + compatibility_additional_alldelivery = torch.cat( + [ # [n_heads, batch_size, graph_size, n_pick] + -np.inf + * torch.ones( + self.n_heads, + batch_size, + self.num_agents + 0, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + compatibility_pick_alldelivery, # [n_heads, batch_size, n_pick, n_pick] + -np.inf + * torch.ones( + self.n_heads, + batch_size, + n_pick, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + ], + 2, + ).view(self.n_heads, batch_size, graph_size, n_pick) + # [n_heads, batch_size, n_query, graph_size+1+n_pick+n_pick] + + ##Delivery-> + compatibility_additional_pick = torch.cat( + [ # [n_heads, batch_size, graph_size, 1] + -np.inf + * torch.ones( + self.n_heads, + batch_size, + self.num_agents + 0, + dtype=compatibility.dtype, + device=compatibility.device, + ), + -np.inf + * torch.ones( + self.n_heads, + batch_size, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + compatibility_delivery_pick, # [n_heads, batch_size, n_pick] + ], + -1, + ).view(self.n_heads, batch_size, graph_size, 1) + + compatibility_additional_alldelivery2 = torch.cat( + [ # [n_heads, batch_size, graph_size, n_pick] + -np.inf + * torch.ones( + self.n_heads, + batch_size, + self.num_agents + 0, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + -np.inf + * torch.ones( + self.n_heads, + batch_size, + n_pick, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + compatibility_delivery_alldelivery, # [n_heads, batch_size, n_pick, n_pick] + ], + 2, + ).view(self.n_heads, batch_size, graph_size, n_pick) + + compatibility_additional_allpick2 = torch.cat( + [ # [n_heads, batch_size, graph_size, n_pick] + -np.inf + * torch.ones( + self.n_heads, + batch_size, + self.num_agents + 0, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + -np.inf + * torch.ones( + self.n_heads, + batch_size, + n_pick, + n_pick, + dtype=compatibility.dtype, + device=compatibility.device, + ), + compatibility_delivery_allpick, # [n_heads, batch_size, n_pick, n_pick] + ], + 2, + ).view(self.n_heads, batch_size, graph_size, n_pick) + + compatibility = torch.cat( + [ + compatibility, + compatibility_additional_delivery, + compatibility_additional_allpick, + compatibility_additional_alldelivery, + compatibility_additional_pick, + compatibility_additional_alldelivery2, + compatibility_additional_allpick2, + ], + dim=-1, + ) + + # Optionally apply mask to prevent attention + if mask is not None: + mask = mask.view(1, batch_size, n_query, graph_size).expand_as(compatibility) + compatibility[mask] = -np.inf + + attn = torch.softmax( + compatibility, dim=-1 + ) # [n_heads, batch_size, n_query, graph_size+1+n_pick*2] (graph_size include depot) + + # If there are nodes with no neighbours then softmax returns nan so we fix them to 0 + if mask is not None: + attnc = attn.clone() + attnc[mask] = 0 + attn = attnc + # heads: [n_heads, batrch_size, n_query, val_size], attn????pick?deliver?attn + heads = torch.matmul( + attn[:, :, :, :graph_size], V + ) # V: (self.n_heads, batch_size, graph_size, val_size) + + # heads??pick -> its delivery + heads = ( + heads + + attn[:, :, :, graph_size].view(self.n_heads, batch_size, graph_size, 1) + * V_additional_delivery + ) # V_addi:[n_heads, batch_size, graph_size, key_size] + + # heads??pick -> otherpick, V_allpick: # [n_heads, batch_size, n_pick, key_size] + # heads: [n_heads, batch_size, graph_size, key_size] + heads = heads + torch.matmul( + attn[:, :, :, graph_size + 1 : graph_size + 1 + n_pick].view( + self.n_heads, batch_size, graph_size, n_pick + ), + V_allpick, + ) + + # V_alldelivery: # (n_heads, batch_size, n_pick, key/val_size) + heads = heads + torch.matmul( + attn[:, :, :, graph_size + 1 + n_pick : graph_size + 1 + 2 * n_pick].view( + self.n_heads, batch_size, graph_size, n_pick + ), + V_alldelivery, + ) + + # delivery + heads = ( + heads + + attn[:, :, :, graph_size + 1 + 2 * n_pick].view( + self.n_heads, batch_size, graph_size, 1 + ) + * V_additional_pick + ) + + heads = heads + torch.matmul( + attn[ + :, :, :, graph_size + 1 + 2 * n_pick + 1 : graph_size + 1 + 3 * n_pick + 1 + ].view(self.n_heads, batch_size, graph_size, n_pick), + V_alldelivery2, + ) + + heads = heads + torch.matmul( + attn[:, :, :, graph_size + 1 + 3 * n_pick + 1 :].view( + self.n_heads, batch_size, graph_size, n_pick + ), + V_allpickup2, + ) + + out = torch.mm( + heads.permute(1, 2, 0, 3).contiguous().view(-1, self.n_heads * self.val_dim), + self.W_out.view(-1, self.embed_dim), + ).view(batch_size, n_query, self.embed_dim) + + return out + + def set_num_agents(self, num_agents): + self.num_agents = num_agents + + +class HeterogeneuousMHALayer(nn.Sequential): + def __init__( + self, + num_heads=8, + embed_dim=128, + feed_forward_hidden=512, + normalization="batch", + ): + super(HeterogeneuousMHALayer, self).__init__( + SkipConnection(HeterogeneousMHA(num_heads, embed_dim, embed_dim)), + Normalization(embed_dim, normalization), + SkipConnection( + nn.Sequential( + nn.Linear(embed_dim, feed_forward_hidden), + nn.ReLU(), + nn.Linear(feed_forward_hidden, embed_dim), + ) + if feed_forward_hidden > 0 + else nn.Linear(embed_dim, embed_dim) + ), + Normalization(embed_dim, normalization), + ) + + def set_num_agents(self, num_agents): + # for all HeterogeneousMHA inside, set num_agents + for layer in self: + if isinstance(layer, SkipConnection): + if isinstance(layer.module, HeterogeneousMHA): + layer.module.set_num_agents(num_agents) + + +class GraphHeterogeneousAttentionEncoder(nn.Module): + def __init__( + self, + init_embedding: nn.Module, + num_heads=8, + embed_dim=128, + num_encoder_layers=3, + env_name=None, + normalization="batch", + feed_forward_hidden=512, + sdpa_fn=None, + ): + super(GraphHeterogeneousAttentionEncoder, self).__init__() + + self.init_embedding = init_embedding + + self.layers = nn.Sequential( + *( + HeterogeneuousMHALayer( + num_heads, + embed_dim, + feed_forward_hidden, + normalization, + ) + for _ in range(num_encoder_layers) + ) + ) + + def forward(self, x, mask=None): + assert mask is None, "Mask not yet supported!" + # initial Embedding from features + init_embeds = self.init_embedding(x) # (batch_size, graph_size, embed_dim) + # layers (batch_size, graph_size, embed_dim) + embeds = self.layers(init_embeds) + return embeds, init_embeds + + def set_num_agents(self, num_agents): + # for all HeterogeneousMHA inside, set num_agents + for layer in self.layers: + if isinstance(layer, HeterogeneuousMHALayer): + layer.set_num_agents(num_agents) diff --git a/parco/models/nn/matnet.py b/parco/models/nn/matnet.py new file mode 100644 index 0000000..b98cda3 --- /dev/null +++ b/parco/models/nn/matnet.py @@ -0,0 +1,421 @@ + +import torch +import torch.nn as nn +import torch.nn.functional as F +from einops import rearrange +import math +from typing import Optional + +from parco.models.nn.transformer import ParallelGatedMLP, Normalization +from rl4co.models.nn.attention import MultiHeadAttention + +class FeedForward(nn.Module): + def __init__( + self, + embed_dim: int = 256, + feedforward_hidden: int = 512, + ): + super().__init__() + self.W1 = nn.Linear(embed_dim, feedforward_hidden) + self.W2 = nn.Linear(feedforward_hidden, embed_dim) + + def forward(self, input1): + # input.shape: (batch, problem, embedding) + + return self.W2(F.relu(self.W1(input1))) + + +class MixedScoreMultiHeadAttention(nn.Module): + def __init__( + self, + embed_dim: int = 256, + head_num: int = 16, + ms_hidden_dim: int = 32, + ): + super().__init__() + + self.head_num = head_num + qkv_dim = embed_dim // head_num + self.qkv_dim = qkv_dim + + mix1_init = (1/2)**(1/2) + mix2_init = (1/16)**(1/2) + + self.Wq = nn.Linear(embed_dim, head_num * qkv_dim, bias=False) + self.Wk = nn.Linear(embed_dim, head_num * qkv_dim, bias=False) + self.Wv = nn.Linear(embed_dim, head_num * qkv_dim, bias=False) + + mix1_weight = torch.torch.distributions.Uniform(low=-mix1_init, high=mix1_init).sample((head_num, 2, ms_hidden_dim)) + mix1_bias = torch.torch.distributions.Uniform(low=-mix1_init, high=mix1_init).sample((head_num, ms_hidden_dim)) + self.mix1_weight = nn.Parameter(mix1_weight) + # shape: (head, 2, ms_hidden) + self.mix1_bias = nn.Parameter(mix1_bias) + # shape: (head, ms_hidden) + + mix2_weight = torch.torch.distributions.Uniform(low=-mix2_init, high=mix2_init).sample((head_num, ms_hidden_dim, 1)) + mix2_bias = torch.torch.distributions.Uniform(low=-mix2_init, high=mix2_init).sample((head_num, 1)) + self.mix2_weight = nn.Parameter(mix2_weight) + # shape: (head, ms_hidden, 1) + self.mix2_bias = nn.Parameter(mix2_bias) + # shape: (head, 1) + + def forward(self, row_emb, col_emb, cost_mat): + # q shape: (batch, head_num, row_cnt, qkv_dim) + # k,v shape: (batch, head_num, col_cnt, qkv_dim) + # cost_mat.shape: (batch, row_cnt, col_cnt) + head_num = self.head_num + qkv_dim = self.qkv_dim + + q = reshape_by_heads(self.Wq(row_emb), head_num=head_num) + # q shape: (batch, head_num, row_cnt, qkv_dim) + k = reshape_by_heads(self.Wk(col_emb), head_num=head_num) + v = reshape_by_heads(self.Wv(col_emb), head_num=head_num) + + batch_size = q.size(0) + row_cnt = q.size(2) + col_cnt = k.size(2) + + # shape: (batch, head_num, row_cnt, col_cnt) + dot_product = torch.matmul(q, k.transpose(2, 3)) + + # shape: (batch, head_num, row_cnt, col_cnt) + dot_product_score = dot_product / math.sqrt(qkv_dim) + + # shape: (batch, head_num, row_cnt, col_cnt) + cost_mat_score = cost_mat[:, None, :, :].expand(batch_size, head_num, row_cnt, col_cnt) + + # shape: (batch, head_num, row_cnt, col_cnt, 2) + two_scores = torch.stack((dot_product_score, cost_mat_score), dim=4) + + # shape: (batch, row_cnt, head_num, col_cnt, 2) + two_scores_transposed = two_scores.transpose(1,2) + + # shape: (batch, row_cnt, head_num, col_cnt, ms_hidden_dim) + ms1 = torch.matmul(two_scores_transposed, self.mix1_weight) + + # shape: (batch, row_cnt, head_num, col_cnt, ms_hidden_dim) + ms1 = ms1 + self.mix1_bias[None, None, :, None, :] + + ms1_activated = F.relu(ms1) + + # shape: (batch, row_cnt, head_num, col_cnt, 1) + ms2 = torch.matmul(ms1_activated, self.mix2_weight) + + # shape: (batch, row_cnt, head_num, col_cnt, 1) + ms2 = ms2 + self.mix2_bias[None, None, :, None, :] + + # shape: (batch, head_num, row_cnt, col_cnt, 1) + mixed_scores = ms2.transpose(1,2) + + # shape: (batch, head_num, row_cnt, col_cnt) + mixed_scores = mixed_scores.squeeze(4) + + # shape: (batch, head_num, row_cnt, col_cnt) + weights = nn.Softmax(dim=3)(mixed_scores) + + # shape: (batch, head_num, row_cnt, qkv_dim) + out = torch.matmul(weights, v) + + # shape: (batch, row_cnt, head_num, qkv_dim) + out_transposed = out.transpose(1, 2) + + # shape: (batch, row_cnt, head_num*qkv_dim) + out_concat = out_transposed.reshape(batch_size, row_cnt, head_num * qkv_dim) + + return out_concat + + +class TransformerFFN(nn.Module): + def __init__( + self, + embed_dim: int = 256, + feedforward_hidden: int = 512, + normalization: Optional[str] = "instance", + parallel_gated_kwargs: Optional[dict] = None, + ): + + super().__init__() + + if parallel_gated_kwargs is not None: + ffn = ParallelGatedMLP(**parallel_gated_kwargs) + else: + ffn = FeedForward(embed_dim=embed_dim, feedforward_hidden=feedforward_hidden) + + self.ops = nn.ModuleDict( + { + "norm1": Normalization(embed_dim=embed_dim, normalization=normalization), + "ffn": ffn, + "norm2": Normalization(embed_dim=embed_dim, normalization=normalization), + } + ) + + def forward(self, x, x_old): + + x = self.ops["norm1"](x_old + x) + x = self.ops["norm2"](x + self.ops["ffn"](x)) + + return x + + + +class MatNetBlock(nn.Module): + def __init__( + self, + embed_dim: int = 256, + head_num: int = 16, + ms_hidden_dim: int = 32, + feedforward_hidden: int = 512, + normalization: Optional[str] = "instance", + parallel_gated_kwargs: Optional[dict] = None, + ): + + super().__init__() + + self.mixed_score_MHA = MixedScoreMultiHeadAttention( + embed_dim=embed_dim, + head_num=head_num, + ms_hidden_dim=ms_hidden_dim + ) + + self.multi_head_combine = nn.Linear(embed_dim, embed_dim) + + self.feed_forward = TransformerFFN( + embed_dim=embed_dim, + feedforward_hidden=feedforward_hidden, + normalization=normalization, + parallel_gated_kwargs=parallel_gated_kwargs + ) + + def forward(self, row_emb, col_emb, cost_mat): + # NOTE: row and col can be exchanged, if cost_mat.transpose(1,2) is used + # input1.shape: (batch, row_cnt, embedding) + # input2.shape: (batch, col_cnt, embedding) + # cost_mat.shape: (batch, row_cnt, col_cnt) + + out_concat = self.mixed_score_MHA(row_emb, col_emb, cost_mat) + # shape: (batch, row_cnt, head_num*qkv_dim) + + multi_head_out = self.multi_head_combine(out_concat) + # shape: (batch, row_cnt, embedding) + ffn_out = self.feed_forward(multi_head_out, row_emb) + + return ffn_out + # shape: (batch, row_cnt, embedding) + + +class MatNetLayer(nn.Module): + def __init__( + self, + embed_dim: int = 256, + head_num: int = 16, + ms_hidden_dim: int = 32, + feedforward_hidden: int = 512, + normalization: Optional[str] = "instance", + parallel_gated_kwargs: Optional[dict] = None, + **kwargs + ): + super().__init__() + self.row_encoding_block = MatNetBlock( + embed_dim=embed_dim, + head_num=head_num, + ms_hidden_dim=ms_hidden_dim, + feedforward_hidden=feedforward_hidden, + normalization=normalization, + parallel_gated_kwargs=parallel_gated_kwargs + ) + self.col_encoding_block = MatNetBlock( + embed_dim=embed_dim, + head_num=head_num, + ms_hidden_dim=ms_hidden_dim, + feedforward_hidden=feedforward_hidden, + normalization=normalization, + parallel_gated_kwargs=parallel_gated_kwargs + ) + + def forward(self, row_emb, col_emb, cost_mat): + # row_emb.shape: (batch, row_cnt, embedding) + # col_emb.shape: (batch, col_cnt, embedding) + # cost_mat.shape: (batch, row_cnt, col_cnt) + row_emb_out = self.row_encoding_block(row_emb, col_emb, cost_mat) + col_emb_out = self.col_encoding_block(col_emb, row_emb, cost_mat.transpose(1, 2)) + + return row_emb_out, col_emb_out + + +class MixedScoreFF(nn.Module): + def __init__(self, num_heads, ms_hidden_dim) -> None: + super().__init__() + + self.lin1 = nn.Linear(2 * num_heads, num_heads * ms_hidden_dim, bias=False) + self.lin2 = nn.Linear(num_heads * ms_hidden_dim, 2 * num_heads, bias=False) + + def forward(self, dot_product_score, cost_mat_score): + # dot_product_score shape: (batch, head_num, row_cnt, col_cnt) + # cost_mat_score shape: (batch, head_num, row_cnt, col_cnt) + # shape: (batch, head_num, row_cnt, col_cnt, 2) + two_scores = torch.stack((dot_product_score, cost_mat_score), dim=-1) + two_scores = rearrange(two_scores, "b h r c s -> b r c (h s)") + # shape: (batch, row_cnt, col_cnt, 2 * num_heads) + ms = self.lin2(F.relu(self.lin1(two_scores))) + # shape: (batch, row_cnt, head_num, col_cnt) + mixed_scores = rearrange(ms, "b r c (h two) -> b h r c two", two=2) + ms1, ms2 = mixed_scores.chunk(2, dim=-1) + + return ms1.squeeze(-1), ms2.squeeze(-1) + + +class EfficientMixedScoreMultiHeadAttention(nn.Module): + def __init__( + self, + embed_dim: int = 256, + num_heads: int = 16, + ms_hidden_dim: int = 32, + ): + super().__init__() + + self.num_heads = num_heads + qkv_dim = embed_dim // num_heads + self.scale_dots = True + + self.qkv_dim = qkv_dim + self.norm_factor = 1 / math.sqrt(qkv_dim) + + self.Wqv1 = nn.Linear(embed_dim, 2 * embed_dim, bias=False) + self.Wkv2 = nn.Linear(embed_dim, 2 * embed_dim, bias=False) + + # self.init_parameters() + self.mixed_scores_layer = MixedScoreFF(num_heads, ms_hidden_dim) + + self.out_proj1 = nn.Linear(embed_dim, embed_dim, bias=False) + self.out_proj2 = nn.Linear(embed_dim, embed_dim, bias=False) + + + def forward(self, x1, x2, attn_mask = None, cost_mat = None): + batch_size = x1.size(0) + row_cnt = x1.size(-2) + col_cnt = x2.size(-2) + + # Project query, key, value + q, v1 = rearrange( + self.Wqv1(x1), "b s (two h d) -> two b h s d", two=2, h=self.num_heads + ).unbind(dim=0) + + # Project query, key, value + k, v2 = rearrange( + self.Wqv1(x2), "b s (two h d) -> two b h s d", two=2, h=self.num_heads + ).unbind(dim=0) + + # shape: (batch, num_heads, row_cnt, col_cnt) + dot = self.norm_factor * torch.matmul(q, k.transpose(-2, -1)) + + if cost_mat is not None: + # shape: (batch, num_heads, row_cnt, col_cnt) + cost_mat_score = cost_mat[:, None, :, :].expand_as(dot) + ms1, ms2 = self.mixed_scores_layer(dot, cost_mat_score) + + if attn_mask is not None: + attn_mask = attn_mask.view(batch_size, 1, row_cnt, col_cnt).expand_as(dot) + dot.masked_fill_(~attn_mask, float("-inf")) + + h1 = self.out_proj1( + apply_weights_and_combine(ms1, v2, scale=self.scale_dots) + ) + h2 = self.out_proj2( + apply_weights_and_combine(ms2.transpose(-2, -1), v1, scale=self.scale_dots) + ) + + return h1, h2 + + +class HAMEncoderLayer(nn.Module): + def __init__( + self, + embed_dim: int = 256, + num_heads: int = 16, + ms_hidden_dim: int = 32, + feedforward_hidden: int = 512, + normalization: Optional[str] = "instance", + parallel_gated_kwargs: Optional[dict] = None, + **kwargs + ): + super().__init__() + + self.op_attn = MultiHeadAttention( + embed_dim=embed_dim, + num_heads=num_heads, + # bias=False, + ) + self.ma_attn = MultiHeadAttention( + embed_dim=embed_dim, + num_heads=num_heads, + bias=False, + ) + + self.cross_attn = EfficientMixedScoreMultiHeadAttention( + embed_dim=embed_dim, + num_heads=num_heads, + ms_hidden_dim=ms_hidden_dim + ) + + self.op_ffn = TransformerFFN( + embed_dim=embed_dim, + feedforward_hidden=feedforward_hidden, + normalization=normalization, + parallel_gated_kwargs=parallel_gated_kwargs + ) + self.ma_ffn = TransformerFFN( + embed_dim=embed_dim, + feedforward_hidden=feedforward_hidden, + normalization=normalization, + parallel_gated_kwargs=parallel_gated_kwargs + ) + + self.op_norm = Normalization(embed_dim=embed_dim, normalization=normalization) + self.ma_norm = Normalization(embed_dim=embed_dim, normalization=normalization) + + + def forward( + self, + op_in, + ma_in, + cost_mat, + op_mask=None, + ma_mask=None, + cross_mask=None + ): + + op_cross_out, ma_cross_out = self.cross_attn(op_in, ma_in, attn_mask=cross_mask, cost_mat=cost_mat) + op_cross_out = self.op_norm(op_cross_out + op_in) + ma_cross_out = self.ma_norm(ma_cross_out + ma_in) + + # (bs, num_jobs, ops_per_job, d) + op_self_out = self.op_attn(op_cross_out, attn_mask=op_mask) + # (bs, num_ma, d) + ma_self_out = self.ma_attn(ma_cross_out, attn_mask=ma_mask) + + op_out = self.op_ffn(op_cross_out, op_self_out) + ma_out = self.ma_ffn(ma_cross_out, ma_self_out) + + return op_out, ma_out + + + +####################################### +def reshape_by_heads(qkv, head_num): + return rearrange(qkv, "... g (h s) -> ... h g s", h=head_num) + +def apply_weights_and_combine(logits, v, tanh_clipping=10, scale=True): + if scale: + # scale to avoid numerical underflow + logits = logits / logits.std() + if tanh_clipping > 0: + # tanh clipping to avoid explosions + logits = torch.tanh(logits) * tanh_clipping + # shape: (batch, num_heads, row_cnt, col_cnt) + weights = nn.Softmax(dim=-1)(logits) + weights = weights.nan_to_num(0) + # shape: (batch, num_heads, row_cnt, qkv_dim) + out = torch.matmul(weights, v) + # shape: (batch, row_cnt, num_heads, qkv_dim) + out = rearrange(out, "b h s d -> b s (h d)") + return out \ No newline at end of file diff --git a/parco/models/nn/positional_encoder.py b/parco/models/nn/positional_encoder.py new file mode 100644 index 0000000..19dad99 --- /dev/null +++ b/parco/models/nn/positional_encoder.py @@ -0,0 +1,26 @@ +import math + +import torch + + +class PositionalEncoder(torch.nn.Module): + """ " + Positional encoder for transformer models. + This module is used to add positional encodings to the input of the model: + x = x + pe[:, :x.shape[1]] + """ + + def __init__(self, d_model, max_len=5000): + super(PositionalEncoder, self).__init__() + pe = torch.zeros(max_len, d_model) + position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) + div_term = torch.exp( + torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model) + ) + pe[:, 0::2] = torch.sin(position * div_term) + pe[:, 1::2] = torch.cos(position * div_term) + pe = pe.unsqueeze(0) + self.register_buffer("pe", pe) + + def forward(self, x, add=False): + return x + self.pe[:, : x.shape[1]] if add else self.pe[:, : x.shape[1]] diff --git a/parco/models/nn/transformer.py b/parco/models/nn/transformer.py new file mode 100644 index 0000000..30b3471 --- /dev/null +++ b/parco/models/nn/transformer.py @@ -0,0 +1,177 @@ +from typing import Callable, Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from rl4co.models.nn.attention import MultiHeadAttention +from rl4co.models.nn.mlp import MLP +from rl4co.models.nn.moe import MoE +from rl4co.utils.pylogger import get_pylogger +from torch import Tensor + +log = get_pylogger(__name__) + + +class RMSNorm(nn.Module): + """From https://github.com/meta-llama/llama-models""" + + def __init__(self, dim: int, eps: float = 1e-5, **kwargs): + super().__init__() + self.eps = eps + self.weight = nn.Parameter(torch.ones(dim)) + + def _norm(self, x): + return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) + + def forward(self, x): + output = self._norm(x.float()).type_as(x) + return output * self.weight + + +class Normalization(nn.Module): + def __init__(self, embed_dim, normalization="batch"): + super(Normalization, self).__init__() + if normalization != "layer": + normalizer_class = { + "batch": nn.BatchNorm1d, + "instance": nn.InstanceNorm1d, + "rms": RMSNorm, + }.get(normalization, None) + self.normalizer = ( + normalizer_class(embed_dim, affine=True) + if normalizer_class is not None + else None + ) + else: + self.normalizer = "layer" + if self.normalizer is None: + log.error( + "Normalization type {} not found. Skipping normalization.".format( + normalization + ) + ) + + def forward(self, x): + if isinstance(self.normalizer, nn.BatchNorm1d): + return self.normalizer(x.view(-1, x.size(-1))).view(*x.size()) + elif isinstance(self.normalizer, nn.InstanceNorm1d): + return self.normalizer(x.permute(0, 2, 1)).permute(0, 2, 1) + elif self.normalizer == "layer": + return (x - x.mean((1, 2)).view(-1, 1, 1)) / torch.sqrt( + x.var((1, 2)).view(-1, 1, 1) + 1e-05 + ) + elif isinstance(self.normalizer, RMSNorm): + return self.normalizer(x) + else: + assert self.normalizer is None, "Unknown normalizer type {}".format( + self.normalizer + ) + return x + + +class ParallelGatedMLP(nn.Module): + """From https://github.com/togethercomputer/stripedhyena""" + + def __init__( + self, + hidden_size: int = 128, + inner_size_multiple_of: int = 256, + mlp_activation: str = "silu", + model_parallel_size: int = 1, + ): + super().__init__() + + multiple_of = inner_size_multiple_of + self.act_type = mlp_activation + if self.act_type == "gelu": + self.act = F.gelu + elif self.act_type == "silu": + self.act = F.silu + else: + raise NotImplementedError + + self.multiple_of = multiple_of * model_parallel_size + + inner_size = int(2 * hidden_size * 4 / 3) + inner_size = self.multiple_of * ( + (inner_size + self.multiple_of - 1) // self.multiple_of + ) + + self.l1 = nn.Linear( + in_features=hidden_size, + out_features=inner_size, + bias=False, + ) + self.l2 = nn.Linear( + in_features=hidden_size, + out_features=inner_size, + bias=False, + ) + self.l3 = nn.Linear( + in_features=inner_size, + out_features=hidden_size, + bias=False, + ) + + def forward(self, z): + z1, z2 = self.l1(z), self.l2(z) + return self.l3(self.act(z1) * z2) + + +class TransformerBlock(nn.Module): + def __init__( + self, + embed_dim: int = 128, + num_heads: int = 8, + feedforward_hidden: Optional[int] = None, # if None, use 4 * embed_dim + normalization: Optional[str] = "instance", + norm_after: bool = False, # if True, perform same as Kool et al. + bias: bool = True, + sdpa_fn: Optional[Callable] = None, + moe_kwargs: Optional[dict] = None, + parallel_gated_kwargs: Optional[dict] = None, + ): + super(TransformerBlock, self).__init__() + feedforward_hidden = ( + 4 * embed_dim if feedforward_hidden is None else feedforward_hidden + ) + num_neurons = [feedforward_hidden] if feedforward_hidden > 0 else [] + if moe_kwargs is not None: + ffn = MoE(embed_dim, embed_dim, num_neurons=num_neurons, **moe_kwargs) + elif parallel_gated_kwargs is not None: + ffn = ParallelGatedMLP(embed_dim, **parallel_gated_kwargs) + else: + ffn = MLP( + input_dim=embed_dim, + output_dim=embed_dim, + num_neurons=num_neurons, + hidden_act="ReLU", + ) + + self.norm_attn = ( + Normalization(embed_dim, normalization) + if normalization is not None + else lambda x: x + ) + self.attention = MultiHeadAttention( + embed_dim, num_heads, bias=bias, sdpa_fn=sdpa_fn + ) + self.norm_ffn = ( + Normalization(embed_dim, normalization) + if normalization is not None + else lambda x: x + ) + self.ffn = ffn + self.norm_after = norm_after + + def forward(self, x: Tensor, mask: Optional[Tensor] = None) -> Tensor: + if not self.norm_after: + # normal transformer structure + h = x + self.attention(self.norm_attn(x), mask) + h = h + self.ffn(self.norm_ffn(h)) + else: + # from Kool et al. (2019) + h = self.norm_attn(x + self.attention(x, mask)) + h = self.norm_ffn(h + self.ffn(h)) + return h diff --git a/parco/models/policy.py b/parco/models/policy.py new file mode 100644 index 0000000..e66643a --- /dev/null +++ b/parco/models/policy.py @@ -0,0 +1,469 @@ +from typing import List + +import torch +import torch.nn as nn +import torch.nn.functional as F +from einops import rearrange +from tensordict import TensorDict +from rl4co.utils.pylogger import get_pylogger +from rl4co.utils.ops import batchify + +from .agent_handlers import get_agent_handler +from .decoder import PARCODecoder, MatNetDecoder +from .decoding_strategies import PARCODecodingStrategy, parco_get_decoding_strategy, PARCO4FFSPDecoding +from .encoder import PARCOEncoder, MatNetEncoder +from .utils import get_log_likelihood + +log = get_pylogger(__name__) + + +DEFAULTS_CONTEXT_KWARGS = { + "use_communication": True, + "num_communication_layers": 1, + "normalization": "instance", + "norm_after": False, + "use_final_norm": False, +} + + +class PARCOPolicy(nn.Module): + """Policy for PARCO model""" + + def __init__( + self, + encoder=None, + decoder=None, + embed_dim: int = 128, + num_encoder_layers: int = 3, + num_heads: int = 8, + init_embedding: nn.Module = None, + init_embedding_kwargs: dict = {}, + context_embedding: nn.Module = None, + context_embedding_kwargs: dict = {}, + normalization: str = "instance", + use_final_norm: bool = False, # If True, normalize like in Llama + norm_after: bool = False, + env_name: str = "hcvrp", + train_decode_type: str = "sampling", + val_decode_type: str = "greedy", + test_decode_type: str = "greedy", + agent_handler="highprob", # Agent handler + agent_handler_kwargs: dict = {}, # Agent handler kwargs + use_init_logp: bool = True, # Return initial logp for actions even with conflicts + mask_handled: bool = False, # Mask out handled actions (make logprobs 0) + replacement_value_key: str = "current_node", # When stopping arises (conflict or POS token), replace the value of this key + parallel_gated_kwargs: dict = None, # ParallelGatedMLP kwargs + ): + super(PARCOPolicy, self).__init__() + + if agent_handler is not None: + if isinstance(agent_handler, str): + agent_handler = get_agent_handler(agent_handler, **agent_handler_kwargs) + self.agent_handler = agent_handler + + # If key is not provided, use default context kwargs + context_embedding_kwargs = { + **DEFAULTS_CONTEXT_KWARGS, + **context_embedding_kwargs, + } + + self.env_name = env_name + + # Encoder and decoder + if encoder is None: + log.info("Initializing default PARCOEncoder") + self.encoder = PARCOEncoder( + env_name=self.env_name, + num_heads=num_heads, + embed_dim=embed_dim, + num_layers=num_encoder_layers, + normalization=normalization, + init_embedding=init_embedding, + init_embedding_kwargs=init_embedding_kwargs, + use_final_norm=use_final_norm, + norm_after=norm_after, + parallel_gated_kwargs=parallel_gated_kwargs, + ) + else: + log.warning("Using custom encoder") + self.encoder = encoder + + if decoder is None: + log.info("Initializing default PARCODecoder") + self.decoder = PARCODecoder( + embed_dim=embed_dim, + num_heads=num_heads, + context_embedding=context_embedding, + context_embedding_kwargs=context_embedding_kwargs, + env_name=self.env_name, + ) + else: + log.warning("Using custom decoder") + self.decoder = decoder + self.train_decode_type = train_decode_type + self.val_decode_type = val_decode_type + self.test_decode_type = test_decode_type + + # Multi-agent handling + self.replacement_value_key = replacement_value_key + self.mask_handled = mask_handled + self.use_init_logp = use_init_logp + + def forward( + self, + td: TensorDict, + env, + phase: str = "train", + calc_reward: bool = True, + return_actions: bool = True, + return_sum_log_likelihood: bool = True, + actions=None, + max_steps=1_000_000, + return_init_embeds: bool = True, + **decoding_kwargs, + ) -> dict: + # Encoder: get encoder output and initial embeddings from initial state + hidden, init_embeds = self.encoder(td) + + # Get decode type depending on phase and whether actions are passed for evaluation + decode_type = decoding_kwargs.pop("decode_type", None) + if actions is not None: + decode_type = "evaluate" + elif decode_type is None: + decode_type = getattr(self, f"{phase}_decode_type") + + # When decode_type is sampling, we need to know the number of samples + num_samples = decoding_kwargs.pop("num_samples", 1) + if "sampling" not in decode_type: + num_samples = 1 + + # [B, m, N] + num_agents = td["action_mask"].shape[-2] + + # Setup decoding strategy + # we pop arguments that are not part of the decoding strategy + decode_strategy: PARCODecodingStrategy = parco_get_decoding_strategy( + decode_type, + num_agents=num_agents, + agent_handler=self.agent_handler, + use_init_logp=self.use_init_logp, + mask_handled=self.mask_handled, + replacement_value_key=self.replacement_value_key, + num_samples=num_samples, + **decoding_kwargs, + ) + + # Pre-decoding hook: used for the initial step(s) of the decoding strategy + td, env, num_samples = decode_strategy.pre_decoder_hook(td, env) + num_samples * num_agents + + # Additionally call a decoder hook if needed before main decoding + td, env, hidden = self.decoder.pre_decoder_hook(td, env, hidden, num_samples) + # We use unbatchify if num_samples > 1 + if num_samples > 1: + do_unbatchify = True + else: + do_unbatchify = False + # Main decoding: loop until all sequences are done + step = 0 + while not td["done"].all(): + # We only need to proceed once when decoder forwarding. + if step > 1: + do_unbatchify = False + + logits, mask = self.decoder(td, hidden, num_samples, do_unbatchify) + td = decode_strategy.step( + logits, + mask, + td, + action=actions[..., step] if actions is not None else None, + ) + td = env.step(td)["next"] # do not save the state + step += 1 + if step > max_steps: + log.error( + f"Exceeded maximum number of steps ({max_steps}) during decoding" + ) + break + + # Post-decoding hook: used for the final step(s) of the decoding strategy + ( + logprobs, + actions, + td, + env, + halting_ratio, + ) = decode_strategy.post_decoder_hook(td, env) + + # Output dictionary construction + if calc_reward: + td.set("reward", env.get_reward(td, actions)) + + outdict = { + "reward": td["reward"], + "log_likelihood": get_log_likelihood( + logprobs, actions, td.get("mask", None), return_sum_log_likelihood + ), + "halting_ratio": halting_ratio, + } + + if return_actions: + outdict["actions"] = actions + + if return_init_embeds: # for SymNCO + outdict["init_embeds"] = init_embeds + + outdict["steps"] = step # Number of steps taken during decoding + + return outdict + + + + +from parco.envs import FFSPEnv + +class PARCOMultiStagePolicy(nn.Module): + """Apply a OneStageModel for each stage""" + def __init__( + self, + num_stages: int, + embed_dim: int = 256, + num_encoder_layers: int = 3, + num_heads: int = 16, + feedforward_hidden: int = 512, + ms_hidden_dim: int = 32, + init_embedding: nn.Module = None, + init_embedding_kwargs: dict = {}, + context_embedding: nn.Module = None, + context_embedding_kwargs: dict = {}, + dynamic_embedding: nn.Module = None, + dynamic_embedding_kwargs: dict = {}, + normalization: str = "instance", + scale_factor: float = 100, + use_decoder_mha_mask: bool = False, + use_ham_encoder: bool = True, + pointer_check_nan: bool = True, + env_name: str = "ffsp", + use_pos_token: bool = True, + train_decode_type: str = "sampling", + val_decode_type: str = "greedy", + test_decode_type: str = "greedy", + agent_handler=None, # Agent handler + agent_handler_kwargs: dict = {}, # Agent handler kwargs + use_init_logp: bool = True, # Return initial logp for actions even with conflicts + mask_handled: bool = False, # Mask out handled actions (make logprobs 0) + replacement_value_key: str = "current_node", # When stopping arises (conflict or POS token), replace the value of this key + parallel_gated_kwargs: dict = None, # ParallelGatedMLP kwargs + **transformer_kwargs + ): + super().__init__() + + self.stage_cnt = num_stages + self.stage_models = nn.ModuleList( + [ + OneStageModel( + stage_idx, + num_stages, + embed_dim=embed_dim, + num_encoder_layers=num_encoder_layers, + num_heads=num_heads, + feedforward_hidden=feedforward_hidden, + ms_hidden_dim=ms_hidden_dim, + init_embedding=init_embedding, + init_embedding_kwargs=init_embedding_kwargs, + context_embedding=context_embedding, + context_embedding_kwargs=context_embedding_kwargs, + dynamic_embedding=dynamic_embedding, + dynamic_embedding_kwargs=dynamic_embedding_kwargs, + normalization=normalization, + scale_factor=scale_factor, + env_name=env_name, + use_pos_token=use_pos_token, + use_decoder_mha_mask=use_decoder_mha_mask, + use_ham_encoder=use_ham_encoder, + pointer_check_nan=pointer_check_nan, + parallel_gated_kwargs=parallel_gated_kwargs, + ) for stage_idx in range(self.stage_cnt) + ] + ) + + self.train_decode_type = train_decode_type + self.val_decode_type = val_decode_type + self.test_decode_type = test_decode_type + + + def pre_forward(self, td: TensorDict, env: FFSPEnv, num_starts: int): + # exclude the dummy node and split into stage tables + run_time_list = td["job_duration"][:, :-1].chunk(env.num_stage, dim=-1) + for stage_idx in range(self.stage_cnt): + td["cost_matrix"] = run_time_list[stage_idx] + model: OneStageModel = self.stage_models[stage_idx] + model.pre_forward(td, env, num_starts) + + if num_starts > 1: + # repeat num_start times + td = batchify(td, num_starts) + + # update machine idx and action mask + td = env.pre_step(td) + + return td + + def forward( + self, + td: TensorDict, + env: FFSPEnv, + phase="train", + num_starts=1, + return_actions: bool = False, + **decoder_kwargs, + ): + + # Get decode type depending on phase + decode_type = getattr(self, f"{phase}_decode_type") + device = td.device + + td = self.pre_forward(td, env, num_starts) + + # NOTE: this must come after pre_forward due to batchify op + # collect some data statistics + bs, total_mas, num_jobs_plus_one = td["full_action_mask"].shape + num_jobs = num_jobs_plus_one - 1 + num_ma = total_mas // self.stage_cnt + + logp_list = torch.zeros(size=(bs, 0), device=device) + action_list = [] + + while not td["done"].all(): + + actions = torch.full(size=(bs, total_mas), fill_value=num_jobs, device=device) + prob_stack = [] + action_stack = [] + for stage_idx in range(self.stage_cnt): + model = self.stage_models[stage_idx] + action_mask_list = td["full_action_mask"].chunk(self.stage_cnt, dim=1) + td["action_mask"] = action_mask_list[stage_idx] + td = model(td, decode_type) + + if td["action"] is not None: + prob_stack.append(td["probs"]) + action_stack.append(td["action"]) + + td["action"] = torch.cat(action_stack, dim=-1) + logp = torch.cat(prob_stack, dim=-1).log() + + td = env.step(td)["next"] + + logp_list = torch.cat((logp_list, logp), dim=1) + action_list.append(actions) + + out = { + "reward": td["reward"], + "log_likelihood": logp_list.sum(1), + } + + if return_actions: + out["actions"] = torch.stack(action_list, 1) + + return out + + +class OneStageModel(nn.Module): + def __init__( + self, + stage_idx: int, + num_stages: int, + embed_dim: int = 256, + num_encoder_layers: int = 3, + num_heads: int = 16, + feedforward_hidden: int = 512, + ms_hidden_dim: int = 32, + init_embedding: nn.Module = None, + init_embedding_kwargs: dict = {}, + context_embedding: nn.Module = None, + context_embedding_kwargs: dict = {}, + dynamic_embedding: nn.Module = None, + dynamic_embedding_kwargs: dict = {}, + normalization: str = "instance", + scale_factor: float = 100, + env_name: str = "ffsp", + use_pos_token: bool = True, + use_decoder_mha_mask: bool = False, + use_ham_encoder: bool = True, + pointer_check_nan: bool = True, + agent_handler=None, # Agent handler + agent_handler_kwargs: dict = {}, # Agent handler kwargs + use_init_logp: bool = True, # Return initial logp for actions even with conflicts + mask_handled: bool = False, # Mask out handled actions (make logprobs 0) + replacement_value_key: str = "current_node", # When stopping arises (conflict or POS token), replace the value of this key + parallel_gated_kwargs: dict = None, # ParallelGatedMLP kwargs + **transformer_kwargs + ): + super().__init__() + self.stage_idx = stage_idx + self.num_stages = num_stages + + + self.encoder = MatNetEncoder( + stage_idx, + embed_dim=embed_dim, + num_heads=num_heads, + num_layers=num_encoder_layers, + feedforward_hidden=feedforward_hidden, + ms_hidden_dim=ms_hidden_dim, + normalization=normalization, + init_embedding=init_embedding, + init_embedding_kwargs=init_embedding_kwargs, + scale_factor=scale_factor, + parallel_gated_kwargs=parallel_gated_kwargs, + use_ham=use_ham_encoder, + **transformer_kwargs + ) + + self.decoder = MatNetDecoder( + stage_idx, + num_stages, + embed_dim=embed_dim, + num_heads=num_heads, + scale_factor=scale_factor, + env_name=env_name, + context_embedding=context_embedding, + context_embedding_kwargs=context_embedding_kwargs, + dynamic_embedding=dynamic_embedding, + dynamic_embedding_kwargs=dynamic_embedding_kwargs, + mask_inner=use_decoder_mha_mask, + check_nan=pointer_check_nan + ) + + self.use_pos_token = use_pos_token + + + def pre_forward(self, td, env, num_starts): + embeddings = self.encoder(td) + # encoded_row.shape: (batch, job_cnt, embedding) + # encoded_col.shape: (batch, machine_cnt, embedding) + td, env, cached = self.decoder.pre_decoder_hook(td, env, embeddings, num_starts=num_starts) + self.cache = cached + + self.num_job = embeddings[0].size(1) + self.num_ma = embeddings[1].size(1) + + self.decoding_strat = PARCO4FFSPDecoding( + self.stage_idx, + num_ma=self.num_ma, + num_job=self.num_job, + use_pos_token=self.use_pos_token + ) + + def forward(self, td: TensorDict, decode_type, num_starts: int = 0): + # shape: (batch, num_agents, job_cnt+1) + mask = ~td["action_mask"].clone() + # adjust action mask for pointer attention in RL4CO PointerMHA module + attention_mask = td["action_mask"][...,:-1] + td["action_mask"] = attention_mask + # shape: (batch, num_agents, job_cnt+1) + logits, _ = self.decoder(td, self.cache, num_starts=num_starts) + + td = self.decoding_strat.step(logits, mask, td, decode_type=decode_type) + + return td \ No newline at end of file diff --git a/parco/models/rl.py b/parco/models/rl.py new file mode 100644 index 0000000..9b39a7b --- /dev/null +++ b/parco/models/rl.py @@ -0,0 +1,156 @@ +from random import randint +from typing import Any + +import torch +import torch.nn as nn + +from rl4co.data.transforms import StateAugmentation +from rl4co.envs.common.base import RL4COEnvBase +from rl4co.models.zoo.symnco import SymNCO +from rl4co.models.zoo.symnco.losses import invariance_loss, solution_symmetricity_loss +from rl4co.utils.ops import unbatchify +from rl4co.utils.pylogger import get_pylogger +from torchrl.modules.models import MLP + +from .utils import resample_batch + +log = get_pylogger(__name__) + + +class PARCORLModule(SymNCO): + """RL LightningModule for PARCO based on RL4COLitModule""" + + def __init__( + self, + env: RL4COEnvBase, + policy: nn.Module, + baseline: str = "symnco", + baseline_kwargs={}, + num_augment: int = 4, + alpha: float = 0.2, + beta: float = 1, + projection_head: nn.Module = None, + use_projection_head: bool = True, + train_min_agents: int = 5, + train_max_agents: int = 15, + train_min_size: int = 50, + train_max_size: int = 100, + val_test_num_agents: int = 10, + allow_multi_dataloaders: bool = True, + **kwargs, + ): + # Pass no baseline to superclass since there are multiple custom baselines + super().__init__(env, policy, **kwargs) + + self.num_augment = num_augment + self.augment = StateAugmentation(num_augment=self.num_augment) + self.alpha = alpha # weight for invariance loss + self.beta = beta # weight for solution symmetricity loss + self.use_projection_head = use_projection_head + + if self.use_projection_head: + if projection_head is None: + embed_dim = self.policy.decoder.embed_dim + projection_head = ( + MLP(embed_dim, embed_dim, 1, embed_dim, nn.ReLU) + if projection_head is None + else projection_head + ) + self.projection_head = projection_head + + # Multiagent training + self.train_min_agents = train_min_agents + self.train_max_agents = train_max_agents + self.train_min_size = train_min_size + self.train_max_size = train_max_size + self.val_test_num_agents = val_test_num_agents + self.allow_multi_dataloaders = allow_multi_dataloaders + + # Force env to have as num_agents and num_locs as the maximum number of agents and locations + self.env.generator.num_loc = self.train_max_size + self.env.generator.num_agents = self.train_max_agents + + def shared_step( + self, batch: Any, batch_idx: int, phase: str, dataloader_idx: int = None + ): + # NOTE: deprecated + num_agents = None # done inside the sampling + # Sample number of agents during training step + if phase == "train": + # Idea: we always have batches of the same size from the dataloader. + # however, here we sample a subset of agents and locations from the batch. + # For instance: if we have always 10 depots and 100 cities, we sample a random number of depots and cities + # from the batch. This way, we can train on different number of agents and locations. + num_agents = randint(self.train_min_agents, self.train_max_agents) + num_locs = randint(self.train_min_size, self.train_max_size) + batch = resample_batch(batch, num_agents, num_locs) + else: + if self.allow_multi_dataloaders: + # Get number of agents to test on based on dataloader name + if dataloader_idx is not None and self.dataloader_names is not None: + # e.g. n50_m7 take only number after "m" until _ + num_agents = int( + self.dataloader_names[dataloader_idx].split("_")[-1][1:] + ) + else: + num_agents = self.val_test_num_agents + + # NOTE: trick: we subsample number of agents by setting num_agents + # in such case, use the same number of agents for all batches + batch["num_agents"] = torch.full( + (batch.shape[0],), num_agents, device=batch.device + ) + + # Reset env based on the number of agents + td = self.env.reset(batch) + + n_aug, n_start = self.num_augment, self.num_starts + assert n_start <= 1, "PARCO does not support multi-start" + + # Symmetric augmentation + if n_aug > 1: + td = self.augment(td) + + # Evaluate policy + out = self.policy( + td, + self.env, + phase=phase, + return_init_embeds=True, + ) + + # Unbatchify reward to [batch_size, n_start, n_aug]. + reward = unbatchify(out["reward"], (n_start, n_aug)) + + # Main training loss + if phase == "train": + # note that we do not collect the max_rewards during training + # [batch_size, n_start, n_aug] + ll = unbatchify(out["log_likelihood"], (n_start, n_aug)) + + # Get proj_embeddings if projection head is used + proj_embeds = self.projection_head(out["init_embeds"]) + loss_inv = invariance_loss(proj_embeds, n_aug) if n_aug > 1 else 0 + + # No problem symmetricity loss since no multi-start + loss_ps = 0 + + # IMPORTANT: need to change the dimension on which to calculate the loss because of casting + loss_ss = ( + solution_symmetricity_loss(reward[..., None], ll, dim=1) + if n_aug > 1 + else 0 + ) + loss = loss_ps + self.beta * loss_ss + self.alpha * loss_inv + + out.update( + { + "loss": loss, + "loss_ss": loss_ss, + "loss_ps": loss_ps, + "loss_inv": loss_inv, + } + ) + + metrics = self.log_metrics(out, phase, dataloader_idx=dataloader_idx) + return {"loss": out.get("loss", None), **metrics} diff --git a/parco/models/utils.py b/parco/models/utils.py new file mode 100644 index 0000000..4f11473 --- /dev/null +++ b/parco/models/utils.py @@ -0,0 +1,76 @@ +import torch + +from rl4co.utils.ops import gather_by_index + + +def replace_key_td(td, key, replacement): + # TODO: check if best way in TensorDict? + td.pop(key) + td[key] = replacement + return td + + +def resample_batch(td, num_agents, num_locs): + # Remove depots until num_agents + td.set_("num_agents", torch.full((*td.batch_size,), num_agents, device=td.device)) + if "depots" in td.keys(): + # note that if we have "depot" instead, this will automatically + # be repeated inside the environment + td = replace_key_td(td, "depots", td["depots"][..., :num_agents, :]) + + if "pickup_et" in td.keys(): + # Ensure num_locs is even for omdcpdp + num_locs = num_locs - 1 if num_locs % 2 == 0 else num_locs + # also, set the "num_agents" key to the new number of agents + td.set_("num_agents", torch.full((*td.batch_size,), num_agents, device=td.device)) + + td = replace_key_td(td, "locs", td["locs"][..., :num_locs, :]) + + # For early time windows + if "pickup_et" in td.keys(): + td = replace_key_td(td, "pickup_et", td["pickup_et"][..., : num_locs // 2]) + if "delivery_et" in td.keys(): + td = replace_key_td(td, "delivery_et", td["delivery_et"][..., : num_locs // 2]) + + # Capacities + if "capacity" in td.keys(): + td = replace_key_td(td, "capacity", td["capacity"][..., :num_agents]) + + if "speed" in td.keys(): + td = replace_key_td(td, "speed", td["speed"][..., :num_agents]) + + if "demand" in td.keys(): + td = replace_key_td(td, "demand", td["demand"][..., :num_locs]) + + return td + + +def get_log_likelihood(log_p, actions=None, mask=None, return_sum: bool = False): + """Get log likelihood of selected actions + + Args: + log_p: [batch, n_agents, (decode_len), n_nodes] + actions: [batch, n_agents, (decode_len)] + mask: [batch, n_agents, (decode_len)] + """ + + # NOTE: we do not use this since it is more inefficient, we do it in the decoder + if actions is not None: + if log_p.dim() > 3: + log_p = gather_by_index(log_p, actions, dim=-1) + + # Optional: mask out actions irrelevant to objective so they do not get reinforced + if mask is not None: + log_p[mask] = 0 + + assert ( + log_p > -1000 + ).data.all(), "Logprobs should not be -inf, check sampling procedure!" + + # Calculate log_likelihood + # TODO: check the return sum argument. + # TODO: Also, should we sum over agents too? + if return_sum: + return log_p.sum(-1) # [batch, num_agents] + else: + return log_p # [batch, num_agents, (decode_len)] diff --git a/parco/tasks/eval.py b/parco/tasks/eval.py new file mode 100644 index 0000000..37c34b5 --- /dev/null +++ b/parco/tasks/eval.py @@ -0,0 +1,362 @@ +import time + +import torch + +from rl4co.data.dataset import TensorDictDataset +from rl4co.data.transforms import StateAugmentation +from rl4co.utils.ops import batchify, gather_by_index, unbatchify +from torch.utils.data import DataLoader +from tqdm.auto import tqdm + +from parco.models.agent_handlers import RandomAgentHandler +from parco.models.augmentations import DilationAugmentation + + +def get_dataloader(td, batch_size=4): + """Get a dataloader from a TensorDictDataset""" + # Set up the dataloader + dataloader = DataLoader( + TensorDictDataset(td.clone()), + batch_size=batch_size, + shuffle=False, + num_workers=0, + collate_fn=TensorDictDataset.collate_fn, + ) + return dataloader + + +def check_unused_kwargs(class_, kwargs): + # if len(kwargs) > 0 and not (len(kwargs) == 1 and "progress" in kwargs): + # print(f"Warning: {class_.__class__.__name__} does not use kwargs {kwargs}") + pass + + +class EvalBase: + """Base class for evaluation + + Args: + env: Environment + progress: Whether to show progress bar + **kwargs: Additional arguments (to be implemented in subclasses) + """ + + name = "base" + + def __init__( + self, env, progress=True, verbose=True, reset_env=True, batch_size=4, **kwargs + ): + check_unused_kwargs(self, kwargs) + self.env = env + self.progress = progress + self.verbose = verbose + self.reset_env = reset_env + self.batch_size = batch_size + + def __call__(self, policy, td, **kwargs): + """Evaluate the policy on the given data with **kwargs parameter + self._inner is implemented in subclasses and returns actions and rewards + """ + + if torch.cuda.is_available(): + # Collect timings for evaluation (more accurate than timeit) + start_event = torch.cuda.Event(enable_timing=True) + end_event = torch.cuda.Event(enable_timing=True) + start_event.record() + else: + start_time = time.time() + + dataloader = get_dataloader(td, batch_size=100) + + with torch.inference_mode(): + rewards_list = [] + actions_list = [] + + for batch in tqdm( + dataloader, disable=not self.progress, desc=f"Running {self.name}" + ): + td = batch.to(next(policy.parameters()).device) + if self.reset_env: + td = self.env.reset(td) + actions, rewards = self._inner(policy, td, self.env, **kwargs) + rewards_list.extend(rewards) + actions_list.extend(actions) + + # Padding: pad actions to the same length with zeros + max_length = max(action.size(-1) for action in actions_list) + actions = torch.stack( + [ + torch.nn.functional.pad(action, (0, max_length - action.size(-1))) + for action in actions_list + ], + 0, + ) + # actions = pad_actions(actions_list) + rewards = torch.stack(rewards_list, 0) + + if torch.cuda.is_available(): + end_event.record() + torch.cuda.synchronize() + inference_time = start_event.elapsed_time(end_event) + else: + inference_time = time.time() - start_time + + if self.verbose: + tqdm.write(f"Mean reward for {self.name}: {rewards.mean():.4f}") + tqdm.write(f"Time: {inference_time/1000:.4f}s") + + # Empty cache + torch.cuda.empty_cache() + + return { + "actions": actions.cpu(), + "reward": rewards.cpu(), + "inference_time": inference_time, + "avg_reward": rewards.cpu().mean(), + } + + def _inner(self, policy, td, env=None, **kwargs): + """Inner function to be implemented in subclasses. + This function returns actions and rewards for the given policy + """ + raise NotImplementedError("Implement in subclass") + + def _get_reward(self, td, actions): + """Note: actions already count for the depots""" + next_td = td.clone() # .to("cpu") + with torch.inference_mode(): + # take actions from the last dimension + for i in range(actions.shape[-1]): + cur_a = actions[:, :, i] + next_td.set("action", cur_a) + next_td = self.env.step(next_td)["next"] + + reward = self.env.get_reward(next_td.clone(), actions) + return reward + + +class GreedyEval(EvalBase): + """Evaluates the policy using greedy decoding and single trajectory""" + + name = "greedy" + + def __init__(self, env, **kwargs): + check_unused_kwargs(self, kwargs) + super().__init__(env, **kwargs) + + def _inner(self, policy, td, env, **kwargs): + out = policy( + td.clone(), # note: we need to + env, + decode_type="greedy", + return_actions=True, + ) + + return out["actions"], self._get_reward(td, out["actions"]) + + +class SamplingEval(EvalBase): + """Evaluates the policy via N samples from the policy + + Args: + samples (int): Number of samples to take + softmax_temp (float): Temperature for softmax sampling. The higher the temperature, the more random the sampling + """ + + name = "sampling" + + def __init__(self, env, samples, softmax_temp=None, **kwargs): + check_unused_kwargs(self, kwargs) + super().__init__(env, kwargs.get("progress", True), kwargs.get("verbose", True)) + + self.samples = samples + self.softmax_temp = softmax_temp + + def _inner(self, policy, td, env, **kwargs): + td_init = td.clone() + td = batchify(td, self.samples) + out = policy( + td.clone(), + env, + decode_type="sampling", + return_actions=True, + softmax_temp=self.softmax_temp, + ) + + # Move into batches and compute rewards + rewards = self._get_reward(batchify(td_init, self.samples), out["actions"]) + rewards = unbatchify(rewards, self.samples) + actions = unbatchify(out["actions"], self.samples) + + # Get best reward and corresponding action + rewards, max_idxs = rewards.max(dim=1) + actions = gather_by_index(actions, max_idxs, dim=1) + return actions, rewards + + +class AugmentationEval(EvalBase): + """Evaluates the policy via N state augmentations + `force_dihedral_8` forces the use of 8 augmentations (rotations and flips) as in POMO + https://en.wikipedia.org/wiki/Examples_of_groups#dihedral_group_of_order_8 + + Args: + num_augment (int): Number of state augmentations + force_dihedral_8 (bool): Whether to force the use of 8 augmentations + """ + + name = "augmentation" + + def __init__(self, env, num_augment=8, force_dihedral_8=False, **kwargs): + check_unused_kwargs(self, kwargs) + super().__init__(env, kwargs.get("progress", True), kwargs.get("verbose", True)) + self.augmentation = StateAugmentation( + num_augment=num_augment, + augment_fn="dihedral_8" if force_dihedral_8 else "symmetric", + ) # augment with tsp cuz its the same + + def _inner(self, policy, td, env, num_augment=None): + if num_augment is None: + num_augment = self.augmentation.num_augment + td_init = td.clone() + td = self.augmentation(td) + out = policy(td.clone(), env, decode_type="greedy", return_actions=True) + + # Move into batches and compute rewards + rewards = self._get_reward(batchify(td_init, num_augment), out["actions"]) + rewards = unbatchify(rewards, num_augment) + actions = unbatchify(out["actions"], num_augment) + + # Get best reward and corresponding action + rewards, max_idxs = rewards.max(dim=1) + actions = gather_by_index(actions, max_idxs, dim=1) + return actions, rewards + + @property + def num_augment(self): + return self.augmentation.num_augment + + +class DilationEval(EvalBase): + """Evaluates the policy with Dilation + + Args: + num_augment (int): Number of state augmentations + """ + + name = "augmentation" + + def __init__(self, env, num_augment=8, min_s=0.5, max_s=1.0, **kwargs): + check_unused_kwargs(self, kwargs) + super().__init__(env, kwargs.get("progress", True), kwargs.get("verbose", True)) + self.augmentation = DilationAugmentation( + env.name, num_augment=num_augment, min_s=min_s, max_s=max_s + ) + + def _inner(self, policy, td, env, num_augment=None): + if num_augment is None: + num_augment = self.augmentation.num_augment + td_init = td.clone() + td = self.augmentation(td)[0] + out = policy(td.clone(), env, decode_type="greedy", return_actions=True) + + # Move into batches and compute rewards + # NOTE: need to use initial td, since it is not augmented with different scales + rewards = self._get_reward(batchify(td_init, num_augment), out["actions"]) + rewards = unbatchify(rewards, num_augment) + actions = unbatchify(out["actions"], num_augment) + + # Get best reward and corresponding action + rewards, max_idxs = rewards.max(dim=1) + actions = gather_by_index(actions, max_idxs, dim=1) + return actions, rewards # self._get_reward(td_init, actions) + + @property + def num_augment(self): + return self.augmentation.num_augment + + +class DilationSymEval(EvalBase): + """Evaluates the policy with Dilation and Symmetric Augmentation + + Args: + num_augment (int): Number of state augmentations + """ + + name = "augmentation" + + def __init__( + self, env, num_augment_dil=8, num_augment_sym=8, min_s=0.5, max_s=1.0, **kwargs + ): + check_unused_kwargs(self, kwargs) + super().__init__(env, kwargs.get("progress", True), kwargs.get("verbose", True)) + self.augmentation_dil = DilationAugmentation( + env.name, num_augment=num_augment_dil, min_s=min_s, max_s=max_s + ) + self.augmentation_sym = StateAugmentation( + env.name, num_augment=num_augment_sym, use_dihedral_8=False + ) + + def _inner(self, policy, td, env, num_augment=None): + if num_augment is None: + num_augment = ( + self.augmentation_dil.num_augment * self.augmentation_sym.num_augment + ) + td_init = td.clone() + td = self.augmentation_dil(td)[0] + td = self.augmentation_sym(td) + + out = policy(td.clone(), env, decode_type="greedy", return_actions=True) + + # Move into batches and compute rewards + # NOTE: need to use initial td, since it is not augmented with different scales + rewards = self._get_reward(batchify(td_init, num_augment), out["actions"]) + rewards = unbatchify(rewards, num_augment) + actions = unbatchify(out["actions"], num_augment) + + # Get best reward and corresponding action + rewards, max_idxs = rewards.max(dim=1) + actions = gather_by_index(actions, max_idxs, dim=1) + return actions, rewards # self._get_reward(td_init, actions) + + @property + def num_augment(self): + return self.augmentation.num_augment + + +class GreedyRandomAgentSampling(EvalBase): + """Evaluates the policy via N samples from the policy with random agent conflict handler + + Args: + samples (int): Number of samples to take + """ + + name = "greedy_random_agent_sampling" + + def __init__(self, env, samples, **kwargs): + check_unused_kwargs(self, kwargs) + super().__init__(env, kwargs.get("progress", True), kwargs.get("verbose", True)) + + self.samples = samples + + def _inner(self, policy, td, env, **kwargs): + td_init = td.clone() + try: + policy.decoder.agent_handler = RandomAgentHandler() + except Exception: + raise Exception("RandomAgentHandler not implemented for this policy") + td = batchify(td, self.samples) + out = policy( + td.clone(), + env, + decode_type="greedy", + return_actions=True, + ) + + # Move into batches and compute rewards + rewards = self._get_reward(batchify(td_init, self.samples), out["actions"]) + rewards = unbatchify(rewards, self.samples) + actions = unbatchify(out["actions"], self.samples) + + # Get best reward and corresponding action + rewards, max_idxs = rewards.max(dim=1) + actions = gather_by_index(actions, max_idxs, dim=1) + return actions, rewards diff --git a/parco/tasks/ffsp_old/FFSP_PARCO/FFSPEnv.py b/parco/tasks/ffsp_old/FFSP_PARCO/FFSPEnv.py new file mode 100644 index 0000000..1b7fd98 --- /dev/null +++ b/parco/tasks/ffsp_old/FFSP_PARCO/FFSPEnv.py @@ -0,0 +1,352 @@ + +from dataclasses import dataclass +import torch +from einops import reduce, rearrange +from FFSProblemDef import get_random_problems + +# For Gantt Chart +from matplotlib.colors import ListedColormap +import matplotlib.pyplot as plt +import matplotlib.patches as patches + + +@dataclass +class Reset_State: + problems_list: list + + +@dataclass +class MachineState: + stg_cnt: int + wait_step: torch.Tensor + + def __getitem__(self, idx: int): + assert isinstance(idx, int) + return self.wait_step.chunk(self.stg_cnt, dim=-1)[idx] + +@dataclass +class JobState: + curr_stage: torch.Tensor + wait_step: torch.Tensor + + +@dataclass +class Step_State: + BATCH_IDX: torch.Tensor + POMO_IDX: torch.Tensor + # shape: (batch, pomo) + stg_cnt: int + mask: torch.Tensor = None + # shape: (batch, pomo, ma_tot, job+1) + + finished: torch.Tensor = None + # shape: (batch, pomo) + + machine_state: MachineState = None + job_state: JobState = None + + def get_stage_mask(self, idx: int): + assert isinstance(idx, int) + return self.mask.chunk(self.stg_cnt, dim=-2)[idx] + + +class FFSPEnv: + def __init__(self, **env_params): + # Const @INIT + #################################### + self.stage_cnt = len(env_params['machine_cnt_list']) + self.machine_cnt_list = env_params['machine_cnt_list'] + self.total_machine_cnt = sum(self.machine_cnt_list) + self.job_cnt = env_params['job_cnt'] + self.process_time_params = env_params['process_time_params'] + self.pomo_size = env_params['pomo_size'] + + # Const @Load_Problem + #################################### + self.batch_size = None + self.BATCH_IDX = None + self.POMO_IDX = None + # IDX.shape: (batch, pomo) + self.problems_list = None + # len(problems_list) = stage_cnt + # problems_list[current_stage].shape: (batch, job, machine_cnt_list[current_stage]) + self.job_durations = None + # shape: (batch, job+1, total_machine) + # last job means NO_JOB ==> duration = 0 + self.skip_ratio = [] + # Dynamic + #################################### + + self.schedule = None + # shape: (batch, pomo, machine, job+1) + # records start time of each job at each machine + self.t_ma_idle = None + # shape: (batch, pomo, machine) + # How many time steps each machine needs to run, before it become available for a new job + self.job_location = None + # shape: (batch, pomo, job+1) + # index of stage each job can be processed at. if stage_cnt, it means the job is finished (when job_wait_step=0) + self.job_wait_step = None + self.t_job_ready = None + # shape: (batch, pomo, job+1) + # how many time steps job needs to wait, before it is completed and ready to start at job_location + self.finished = None # is scheduling done? + # shape: (batch, pomo) + self.stage_table = torch.tensor([ + ma for ma, rep in zip(list(range(self.stage_cnt)), self.machine_cnt_list) for _ in range(rep) + ]) + # self.stage_table = torch.tensor([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=torch.long) + + def load_problems(self, batch_size): + self.batch_size = batch_size + self.BATCH_IDX = torch.arange(self.batch_size)[:, None].expand(self.batch_size, self.pomo_size) + self.POMO_IDX = torch.arange(self.pomo_size)[None, :].expand(self.batch_size, self.pomo_size) + + problems_INT_list = get_random_problems( + batch_size, + self.machine_cnt_list, + self.job_cnt, + self.process_time_params + ) + + problems_list = [] + for stage_num in range(self.stage_cnt): + stage_problems_INT = problems_INT_list[stage_num] + stage_problems = stage_problems_INT.clone().type(torch.float) + problems_list.append(stage_problems) + self.problems_list = problems_list + + self.job_durations = torch.empty(size=(self.batch_size, self.job_cnt+1, self.total_machine_cnt), + dtype=torch.long) + # shape: (batch, job+1, total_machine) + self.job_durations[:, :self.job_cnt, :] = torch.cat(problems_INT_list, dim=2) + self.job_durations[:, self.job_cnt, :] = 0 + + def load_problems_manual(self, problems_INT_list): + # problems_INT_list[current_stage].shape: (batch, job, machine_cnt_list[current_stage]) + + self.batch_size = problems_INT_list[0].size(0) + self.BATCH_IDX = torch.arange(self.batch_size)[:, None].expand(self.batch_size, self.pomo_size) + self.POMO_IDX = torch.arange(self.pomo_size)[None, :].expand(self.batch_size, self.pomo_size) + + problems_list = [] + for stage_num in range(self.stage_cnt): + stage_problems_INT = problems_INT_list[stage_num] + stage_problems = stage_problems_INT.clone().type(torch.float) + problems_list.append(stage_problems) + self.problems_list = problems_list + + self.job_durations = torch.empty(size=(self.batch_size, self.job_cnt+1, self.total_machine_cnt), + dtype=torch.long) + # shape: (batch, job+1, total_machine) + self.job_durations[:, :self.job_cnt, :] = torch.cat(problems_INT_list, dim=2) + self.job_durations[:, self.job_cnt, :] = 0 + + def reset(self): + + self.schedule = torch.full(size=(self.batch_size, self.pomo_size, self.total_machine_cnt, self.job_cnt+1), + dtype=torch.long, fill_value=-999999) + # shape: (batch, pomo, machine, job+1) + + self.t_ma_idle = torch.zeros(size=(self.batch_size, self.pomo_size, self.total_machine_cnt), + dtype=torch.long) + # shape: (batch, pomo, machine) + self.job_location = torch.zeros(size=(self.batch_size, self.pomo_size, self.job_cnt+1), dtype=torch.long) + # shape: (batch, pomo, job+1) + self.job_wait_step = torch.zeros(size=(self.batch_size, self.pomo_size, self.job_cnt+1), dtype=torch.long) + self.t_job_ready = torch.zeros(size=(self.batch_size, self.pomo_size, self.job_cnt+1), dtype=torch.long) + # shape: (batch, pomo, job+1) + self.finished = torch.full(size=(self.batch_size, self.pomo_size), dtype=torch.bool, fill_value=False) + # shape: (batch, pomo) + + self.step_state = Step_State(self.BATCH_IDX, self.POMO_IDX, self.stage_cnt) + + reward = None + done = None + + return Reset_State(self.problems_list), reward, done + + def pre_step(self): + self._update_step_state() + reward = None + done = False + return self.step_state, reward, done + + def step(self, job_indices, machine_indices): + job_indices = job_indices.split(1, dim=-1) + machine_indices = machine_indices.split(1, dim=-1) + + # job_idx.shape: (batch, pomo) + for job_idx, machine_idx in zip(job_indices, machine_indices): + + job_idx = torch.flatten(job_idx.squeeze(-1)) + machine_idx = torch.flatten(machine_idx.squeeze(-1)) + skip = job_idx == self.job_cnt + + self.skip_ratio.append(float(skip[~self.finished.reshape(-1)].sum() / skip[~self.finished.reshape(-1)].numel())) + + b_idx = torch.flatten(self.BATCH_IDX)[~skip] + p_idx = torch.flatten(self.POMO_IDX)[~skip] + + job_idx = job_idx[~skip] + machine_idx = machine_idx[~skip] + + t_job = self.t_job_ready[b_idx, p_idx, job_idx] + t_ma = self.t_ma_idle[b_idx, p_idx, machine_idx] + t = torch.maximum(t_job, t_ma) + + self.schedule[b_idx, p_idx, machine_idx, job_idx] = t + + job_length = self.job_durations[b_idx, job_idx, machine_idx] + # shape: (batch, pomo) + + self.t_ma_idle[b_idx, p_idx, machine_idx] = t + job_length + self.t_job_ready[b_idx, p_idx, job_idx] = t + job_length + # shape: (batch, pomo, machine) + self.job_location[b_idx, p_idx, job_idx] += 1 + # shape: (batch, pomo, job+1) + self.job_wait_step[b_idx, p_idx, job_idx] = job_length + # shape: (batch, pomo, job+1) + self.finished = (self.job_location[:, :, :self.job_cnt] >= self.stage_cnt).all(dim=2) + # shape: (batch, pomo) + + #################################### + done = self.finished.all() + + if done: + pass # do nothing. do not update step_state, because it won't be used anyway + else: + # self._move_to_next_time() + self._update_step_state() + + if done: + reward = -self._get_makespan() # Note the MINUS Sign ==> We want to MAXIMIZE reward + # shape: (batch, pomo) + else: + reward = None + + return self.step_state, reward, done + + def _update_step_state(self): + + mask = torch.full( + size=(self.batch_size, self.pomo_size, self.total_machine_cnt, self.job_cnt), + fill_value=False, + dtype=torch.bool + ) + + job_loc = self.job_location[:, :, :self.job_cnt] + # shape: (batch, pomo, job) + job_finished = (job_loc >= self.stage_cnt).unsqueeze(-2).expand_as(mask) + # shape: (batch, pomo, 1, job) + + stage_table_expanded = self.stage_table[None, None, :, None].expand_as(mask) + job_not_in_machines_stage = job_loc[:, :, None] != stage_table_expanded + + mask.add_(job_finished) + mask.add_(job_not_in_machines_stage) + + mask = rearrange(mask, "b p (s m) j -> b p s m j", s=self.stage_cnt) + # add mask for wait, which is allowed if machine cannot process any job + mask = torch.cat( + (mask, ~reduce(mask, "... j -> ... 1", "all")), + dim=-1 + ) + mask = rearrange(mask, "b p s m j -> b p (s m) j") + + job_state = JobState(job_loc, self.t_job_ready[:, :, :self.job_cnt]) + machine_state = MachineState(self.stage_cnt, self.t_ma_idle) + + self.step_state = Step_State( + self.BATCH_IDX, + self.POMO_IDX, + self.stage_cnt, + mask=mask, + finished=self.finished, + job_state=job_state, + machine_state=machine_state + ) + + + def _get_makespan(self): + + job_durations_perm = self.job_durations.permute(0, 2, 1) + # shape: (batch, machine, job+1) + end_schedule = self.schedule + job_durations_perm[:, None, :, :] + # shape: (batch, pomo, machine, job+1) + + end_time_max, _ = end_schedule[:, :, :, :self.job_cnt].max(dim=3) + # shape: (batch, pomo, machine) + end_time_max, _ = end_time_max.max(dim=2) + # shape: (batch, pomo) + + return end_time_max + + def draw_Gantt_Chart(self, batch_i, pomo_i): + + job_durations = self.job_durations[batch_i, :, :] + # shape: (job, machine) + schedule = self.schedule[batch_i, pomo_i, :, :] + # shape: (machine, job) + + total_machine_cnt = self.total_machine_cnt + makespan = self._get_makespan()[batch_i, pomo_i].item() + + # Create figure and axes + fig,ax = plt.subplots(figsize=(makespan/3, 5)) + cmap = self._get_cmap(self.job_cnt) + + plt.xlim(0, makespan) + plt.ylim(0, total_machine_cnt) + ax.invert_yaxis() + + plt.plot([0, makespan], [4, 4], 'black') + plt.plot([0, makespan], [8, 8], 'black') + + for machine_idx in range(total_machine_cnt): + + duration = job_durations[:, machine_idx] + # shape: (job) + machine_schedule = schedule[machine_idx, :] + # shape: (job) + + for job_idx in range(self.job_cnt): + + job_length = duration[job_idx].item() + job_start_time = machine_schedule[job_idx].item() + if job_start_time >= 0: + # Create a Rectangle patch + rect = patches.Rectangle((job_start_time,machine_idx),job_length,1, facecolor=cmap(job_idx), alpha=0.8) + ax.add_patch(rect) + + ax.grid() + ax.set_axisbelow(True) + plt.show() + + def _get_cmap(self, color_cnt): + + colors_list = ['red', 'orange', 'yellow', 'green', 'blue', + 'purple', 'aqua', 'aquamarine', 'black', + 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chocolate', + 'coral', 'cornflowerblue', 'darkblue', 'darkgoldenrod', 'darkgreen', + 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', + 'darkorchid', 'darkred', 'darkslateblue', 'darkslategrey', 'darkturquoise', + 'darkviolet', 'deeppink', 'deepskyblue', 'dimgrey', 'dodgerblue', + 'forestgreen', 'gold', 'goldenrod', 'gray', 'greenyellow', + 'hotpink', 'indianred', 'khaki', 'lawngreen', 'magenta', + 'maroon', 'mediumaquamarine', 'mediumblue', 'mediumorchid', + 'mediumpurple', + 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', + 'navy', 'olive', 'olivedrab', 'orangered', + 'orchid', + 'palegreen', 'paleturquoise', 'palevioletred', 'pink', 'plum', 'powderblue', + 'rebeccapurple', + 'rosybrown', 'royalblue', 'saddlebrown', 'sandybrown', 'sienna', + 'silver', 'skyblue', 'slateblue', + 'springgreen', + 'steelblue', 'tan', 'teal', 'thistle', + 'tomato', 'turquoise', 'violet', 'yellowgreen'] + + cmap = ListedColormap(colors_list, N=color_cnt) + + return cmap diff --git a/parco/tasks/ffsp_old/FFSP_PARCO/FFSPModel.py b/parco/tasks/ffsp_old/FFSP_PARCO/FFSPModel.py new file mode 100644 index 0000000..dfe5177 --- /dev/null +++ b/parco/tasks/ffsp_old/FFSP_PARCO/FFSPModel.py @@ -0,0 +1,335 @@ + +import torch +import torch.nn as nn +import torch.nn.functional as F +import math +from einops import rearrange +from FFSPModel_SUB import ( + MatNetBlock, + InitEmbeddings, + CommunicationLayer, + reshape_by_heads +) +from FFSPEnv import Reset_State, Step_State +from HAMLayer import EncoderLayer as HamEncoderLayer + + +class FFSPModel(nn.Module): + """Apply a OneStageModel for each stage""" + def __init__(self, **model_params): + super().__init__() + self.model_params = model_params + + self.stage_cnt = len(self.model_params['machine_cnt_list']) + self.stage_models = nn.ModuleList([OneStageModel(stage_idx, **model_params) for stage_idx in range(self.stage_cnt)]) + + def pre_forward(self, reset_state: Reset_State): + for stage_idx in range(self.stage_cnt): + problems = reset_state.problems_list[stage_idx] + model = self.stage_models[stage_idx] + model.pre_forward(problems) + + def soft_reset(self): + # Nothing to reset + pass + + def forward(self, state: Step_State): + + jobs_stack = [] + ma_stack = [] + prob_stack = [] + + for stage_idx in range(self.stage_cnt): + model = self.stage_models[stage_idx] + jobs, mas, probs = model(state) + + if jobs is not None: + jobs_stack.append(jobs) + ma_stack.append(mas) + prob_stack.append(probs) + + jobs_stack = torch.cat(jobs_stack, dim=-1) + ma_stack = torch.cat(ma_stack, dim=-1) + prob_stack = torch.cat(prob_stack, dim=-1) + return jobs_stack, ma_stack, prob_stack + + +class OneStageModel(nn.Module): + def __init__(self, stage_idx, **model_params): + super().__init__() + self.stage_idx = stage_idx + self.model_params = model_params + + self.encoder = FFSP_Encoder(stage_idx=stage_idx, **model_params) + self.decoder = FFSP_Decoder(stage_idx=stage_idx, **model_params) + + self.encoded_col = None + # shape: (batch, machine_cnt, embedding) + self.encoded_row = None + # shape: (batch, job_cnt, embedding) + self.num_ma = None + + self.use_pos_token = model_params["use_pos_token"] + + def pre_forward(self, problems): + self.encoded_row, self.encoded_col = self.encoder(problems) + # encoded_row.shape: (batch, job_cnt, embedding) + # encoded_col.shape: (batch, machine_cnt, embedding) + self.decoder.set_qkv(self.encoded_row, self.encoded_col) + + self.num_job = self.encoded_row.size(1) + self.num_ma = self.encoded_col.size(1) + + def forward(self, state: Step_State): + + batch_size = state.BATCH_IDX.size(0) + pomo_size = state.BATCH_IDX.size(1) + # shape: (batch, pomo, num_agents, job_cnt+1) + logits = self.decoder(state) + # shape: (batch, pomo, num_agents, job_cnt+1) + mask = state.get_stage_mask(self.stage_idx).clone() + + jobs_selected, mas_selected, actions_probs = [], [], [] + # shape: (batch * pomo, num_agents) + idle_machines = torch.arange(0, self.num_ma)[None,:].expand(batch_size*pomo_size, -1) + + temp = 1.0 + while not mask[...,:-1].all(): + # get the probabilities of all actions given the current mask + logits_masked = logits.masked_fill(mask, -torch.inf) + # shape: (batch * pomo, num_agents * job_cnt+1) + logits_reshaped = rearrange(logits_masked, "b p m j -> (b p) (j m)") / temp + probs = F.softmax(logits_reshaped, dim=-1) + # perform decoding + if self.training or self.model_params['eval_type'] == 'softmax': + # shape: (batch * pomo) + selected_action = probs.multinomial(1).squeeze(1) + action_prob = probs.gather(1, selected_action.unsqueeze(1)).squeeze(1) + else: + # shape: (batch * pomo) + selected_action = probs.argmax(dim=-1) + action_prob = torch.zeros(size=(batch_size*pomo_size,)) + # translate the action + # shape: (batch * pomo) + job_selected = selected_action // self.num_ma + selected_stage_machine = selected_action % self.num_ma + selected_machine = selected_stage_machine + self.num_ma * self.stage_idx + # determine which machines still have to select an action + idle_machines = ( + idle_machines[idle_machines!=selected_stage_machine[:, None]] + .view(batch_size*pomo_size, -1) + ) + # add action to the buffer + jobs_selected.append(job_selected) + mas_selected.append(selected_machine) + actions_probs.append(action_prob) + # mask job that has been selected in the current step so it cannot be selected by other agents + mask = mask.scatter(-1, job_selected.view(batch_size, pomo_size, 1, 1).expand(-1, -1, self.num_ma, 1), True) + if self.use_pos_token: + # allow machines that are still idle to wait (for jobs to become available for example) + mask[..., -1] = mask[..., -1].scatter(-1, idle_machines.view(batch_size, pomo_size, -1), False) + else: + mask[..., -1] = mask[..., -1].scatter(-1, idle_machines.view(batch_size, pomo_size, -1), ~(mask[..., :-1].all(-1))) + # lastly, mask all actions for the selected agent + mask = mask.scatter(-2, selected_stage_machine.view(batch_size, pomo_size, 1, 1).expand(-1, -1, 1, self.num_job+1), True) + + if len(jobs_selected) > 0: + jobs_selected = torch.stack(jobs_selected, dim=-1).view(batch_size, pomo_size, -1) + mas_selected = torch.stack(mas_selected, dim=-1).view(batch_size, pomo_size, -1) + actions_probs = torch.stack(actions_probs, dim=-1).view(batch_size, pomo_size, -1) + + return jobs_selected, mas_selected, actions_probs + + else: + return None, None, None + + + +######################################## +# ENCODER +######################################## +class FFSP_Encoder(nn.Module): + def __init__(self, stage_idx, **model_params): + super().__init__() + self.stage_idx = stage_idx + encoder_layer_num = model_params['encoder_layer_num'] + self.init_embed = InitEmbeddings(model_params) + if model_params['use_ham']: + self.layers = nn.ModuleList([HamEncoderLayer(**model_params) for _ in range(encoder_layer_num)]) + else: + self.layers = nn.ModuleList([EncoderLayer(**model_params) for _ in range(encoder_layer_num)]) + self.scale_factor = model_params["scale_factor"] + + def forward(self, cost_mat): + # cost_mat.shape: (batch, row_cnt, col_cnt) + row_emb, col_emb = self.init_embed(cost_mat) + cost_mat = cost_mat / self.scale_factor + for layer in self.layers: + row_emb, col_emb = layer( + row_emb, + col_emb, + cost_mat + ) + return row_emb, col_emb + + +class EncoderLayer(nn.Module): + def __init__(self, **model_params): + super().__init__() + self.row_encoding_block = MatNetBlock(**model_params) + self.col_encoding_block = MatNetBlock(**model_params) + + def forward(self, row_emb, col_emb, cost_mat): + # row_emb.shape: (batch, row_cnt, embedding) + # col_emb.shape: (batch, col_cnt, embedding) + # cost_mat.shape: (batch, row_cnt, col_cnt) + row_emb_out = self.row_encoding_block(row_emb, col_emb, cost_mat) + col_emb_out = self.col_encoding_block(col_emb, row_emb, cost_mat.transpose(1, 2)) + + return row_emb_out, col_emb_out + + +######################################## +# Decoder +######################################## + +class FFSP_Decoder(nn.Module): + def __init__(self, stage_idx, **model_params): + super().__init__() + self.stage_idx = stage_idx + self.model_params = model_params + embedding_dim = self.model_params['embedding_dim'] + head_num = self.model_params['head_num'] + qkv_dim = self.model_params['qkv_dim'] + self.scale_factor = model_params["scale_factor"] + self.use_graph_proj = model_params["use_graph_proj"] + self.use_comm_layer = model_params["use_comm_layer"] + self.use_decoder_mha_mask = model_params["use_decoder_mha_mask"] + self.sqrt_embedding_dim = math.sqrt(embedding_dim) + self.sqrt_qkv_dim = math.sqrt(qkv_dim) + # dummy embedding + self.encoded_NO_JOB = nn.Parameter(torch.rand(1, 1, 1, embedding_dim)) + # qkv + self.Wq = nn.Linear(embedding_dim, head_num * qkv_dim, bias=False) + self.Wk = nn.Linear(embedding_dim, head_num * qkv_dim, bias=False) + self.Wv = nn.Linear(embedding_dim, head_num * qkv_dim, bias=False) + self.Wl = nn.Linear(embedding_dim, head_num * qkv_dim, bias=False) + self.multi_head_combine = nn.Linear(head_num * qkv_dim, embedding_dim) + # dyn embeddings + self.dyn_context = nn.Linear(2, embedding_dim) + self.dyn_kv = nn.Linear(2, 3 * embedding_dim) + # optional layers + if self.use_comm_layer: + self.communication_layer = CommunicationLayer(model_params) + if self.use_graph_proj: + self.graph_projection = nn.Linear(embedding_dim, embedding_dim, bias=False) + + + def set_qkv(self, encoded_jobs, encoded_machine): + # shape: (batch, job, embedding) + self.encoded_jobs = encoded_jobs + # shape: (batch, ma, embedding) + self.q = self.Wq(encoded_machine) + # shape: (batch, job, embedding) + self.k = self.Wk(encoded_jobs) + # shape: (batch, job, embedding) + self.v = self.Wv(encoded_jobs) + # shape: (batch, job, embedding) + self.single_head_key = self.Wl(encoded_jobs) + + def forward(self, state: Step_State): + head_num = self.model_params['head_num'] + + # dynamic embeddings + # shape: (batch, pomo, ma) + ma_wait = state.machine_state[self.stage_idx].to(torch.float32) / self.scale_factor + # shape: (batch, pomo, job) + job_in_stage = (state.job_state.curr_stage == self.stage_idx) + # shape: (batch, pomo) + num_in_stage = (job_in_stage.sum(-1) / job_in_stage.size(-1)) + # shape: (batch, pomo, ma, embedding) + ma_wait_proj = self.dyn_context( + torch.stack((ma_wait, num_in_stage.unsqueeze(-1).expand_as(ma_wait)), dim=-1) + ) + # shape: (batch, pomo, ma, embedding) + q = self.q.unsqueeze(1) + ma_wait_proj + # shape: (batch, pomo, ma, embedding) + if self.use_comm_layer: + q = self.communication_layer(q) + + if self.use_graph_proj: + # shape: (batch, pomo, embedding) + graph_emb = ( + self.encoded_jobs + .unsqueeze(1) + .masked_fill(~job_in_stage.unsqueeze(-1), 0) + .sum(-2) + ) / (num_in_stage.unsqueeze(-1) + 1e-9) + # shape: (batch, pomo, embedding) + graph_emb_proj = self.graph_projection(graph_emb) + # shape: (batch, pomo, ma, embedding) + q = q + graph_emb_proj.unsqueeze(-2) + + # shape: (batch, pomo, head_num, ma, qkv_dim) + q = reshape_by_heads(q, head_num=head_num) + # shape: (batch, pomo, jobs, 2) + job_dyn = torch.stack( + (state.job_state.curr_stage, state.job_state.wait_step / self.scale_factor), + dim=-1 + ).to(torch.float32) + # shape: (batch, pomo, jobs, 3*embedding) + dyn_job_proj = self.dyn_kv(job_dyn) + # shape: 3 * (batch, pomo, jobs, embedding) + dyn_k, dyn_v, dyn_l = dyn_job_proj.chunk(3, dim=-1) + # shape: 2 * (batch, pomo, head_num, jobs, qkv_dim); (batch, pomo, jobs, embedding) + k, v, l = ( + reshape_by_heads(self.k.unsqueeze(1) + dyn_k, head_num=head_num), + reshape_by_heads(self.v.unsqueeze(1) + dyn_v, head_num=head_num), + self.single_head_key.unsqueeze(1) + dyn_l + ) + + bs, pomo = l.shape[:2] + encoded_no_job = self.encoded_NO_JOB.expand(bs, pomo, 1, -1) + # shape: (batch, pomo, jobs+1, embedding) + l_plus_one = torch.cat((l, encoded_no_job), dim=2) + # MHA + dec_mha_mask = state.get_stage_mask(self.stage_idx)[..., :-1] if self.use_decoder_mha_mask else None + # shape: (batch, pomo, num_agents, head_num*qkv_dim) + out_concat = self._multi_head_attention_for_decoder( + q, k, v, rank3_mask=dec_mha_mask + ) + + # shape: (batch, pomo, num_agents, embedding) + mh_atten_out = self.multi_head_combine(out_concat) + + # Single-Head Attention, for probability calculation + ####################################################### + # shape: (batch, pomo, num_agents, job_cnt+1) + score = torch.matmul(mh_atten_out, l_plus_one.transpose(-1, -2)) + logit_clipping = self.model_params['logit_clipping'] + score_scaled = score / self.sqrt_embedding_dim + score_clipped = logit_clipping * torch.tanh(score_scaled) + return score_clipped + + + def _multi_head_attention_for_decoder(self, q, k, v, rank3_mask=None): + # q shape: (batch, pomo, head_num, ma, qkv_dim) + # k,v shape: (batch, pomo, head_num, job_cnt, qkv_dim) + # rank3_ninf_mask.shape: (batch, pomo, ma, job_cnt) + head_num = self.model_params['head_num'] + + # shape: (batch, pomo, head_num, ma, job_cnt) + score = torch.matmul(q, k.transpose(-2, -1)) + score_scaled = score / self.sqrt_qkv_dim + + if rank3_mask is not None: + mask = rank3_mask[:, :, None, :].expand_as(score_scaled) + score_scaled[mask] = -torch.inf + + # shape: (batch, pomo, head_num, ma, job_cnt) + weights = nn.Softmax(dim=-1)(score_scaled) + + # shape: (batch, pomo, head_num, ma, qkv_dim) + out = torch.matmul(weights, v) + # shape: (batch, pomo, ma, embedding) + return rearrange(out, "b p h n d -> b p n (h d)", h=head_num) \ No newline at end of file diff --git a/parco/tasks/ffsp_old/FFSP_PARCO/FFSPModel_SUB.py b/parco/tasks/ffsp_old/FFSP_PARCO/FFSPModel_SUB.py new file mode 100644 index 0000000..fe8579e --- /dev/null +++ b/parco/tasks/ffsp_old/FFSP_PARCO/FFSPModel_SUB.py @@ -0,0 +1,333 @@ + +import torch +import torch.nn as nn +import torch.nn.functional as F +from einops import rearrange +import math +from typing import Optional + + +class Normalization(nn.Module): + def __init__(self, **model_params): + super(Normalization, self).__init__() + embedding_dim = model_params['embedding_dim'] + normalization = model_params['normalization'] + + normalizer_class = { + "batch": nn.BatchNorm1d, + "instance": nn.InstanceNorm1d, + "layer": nn.LayerNorm, + }.get(normalization, None) + + if normalizer_class == nn.LayerNorm: + self.normalizer = normalizer_class(embedding_dim, elementwise_affine=True) + else: + self.normalizer = normalizer_class(embedding_dim, affine=True) + + + def forward(self, x): + if isinstance(self.normalizer, nn.BatchNorm1d): + return self.normalizer(x.view(-1, x.size(-1))).view(*x.size()) + elif isinstance(self.normalizer, nn.InstanceNorm1d): + return self.normalizer(x.permute(0, 2, 1)).permute(0, 2, 1) + elif isinstance(self.normalizer, nn.LayerNorm): + return self.normalizer(x.view(-1, x.size(-1))).view(*x.size()) + else: + assert self.normalizer is None, "Unknown normalizer type" + return x + + +class FeedForward(nn.Module): + def __init__(self, **model_params): + super().__init__() + embedding_dim = model_params['embedding_dim'] + ff_hidden_dim = model_params['ff_hidden_dim'] + + self.W1 = nn.Linear(embedding_dim, ff_hidden_dim) + self.W2 = nn.Linear(ff_hidden_dim, embedding_dim) + + def forward(self, input1): + # input.shape: (batch, problem, embedding) + + return self.W2(F.relu(self.W1(input1))) + + +class MultiHeadAttention(nn.Module): + + def __init__(self, model_params) -> None: + + super().__init__() + embed_dim = model_params['embedding_dim'] + self.num_heads = model_params['head_num'] + self.Wqkv = nn.Linear(embed_dim, 3 * embed_dim, bias=False) + self.out_proj = nn.Linear(embed_dim, embed_dim, bias=True) + + def forward(self, x, attn_mask=None): + """x: (batch, seqlen, hidden_dim) (where hidden_dim = num heads * head dim) + attn_mask: bool tensor of shape (batch, seqlen) + """ + + # Project query, key, value + q, k, v = rearrange( + self.Wqkv(x), "b s (three h d) -> three b h s d", three=3, h=self.num_heads + ).unbind(dim=0) + + if attn_mask is not None: + attn_mask = ( + attn_mask.unsqueeze(1) + if attn_mask.ndim == 3 + else attn_mask.unsqueeze(1).unsqueeze(2) + ) + + # Scaled dot product attention + out = F.scaled_dot_product_attention( + q, + k, + v, + attn_mask=attn_mask, + dropout_p=0.0, + ) + h = self.out_proj(rearrange(out, "b h s d -> b s (h d)")) + return h + + +class MixedScore_MultiHeadAttention(nn.Module): + def __init__(self, **model_params): + super().__init__() + self.model_params = model_params + embedding_dim = self.model_params['embedding_dim'] + head_num = self.model_params['head_num'] + qkv_dim = self.model_params['qkv_dim'] + + ms_hidden_dim = model_params['ms_hidden_dim'] + mix1_init = (1/2)**(1/2) + mix2_init = (1/16)**(1/2) + + self.Wq = nn.Linear(embedding_dim, head_num * qkv_dim, bias=False) + self.Wk = nn.Linear(embedding_dim, head_num * qkv_dim, bias=False) + self.Wv = nn.Linear(embedding_dim, head_num * qkv_dim, bias=False) + + mix1_weight = torch.torch.distributions.Uniform(low=-mix1_init, high=mix1_init).sample((head_num, 2, ms_hidden_dim)) + mix1_bias = torch.torch.distributions.Uniform(low=-mix1_init, high=mix1_init).sample((head_num, ms_hidden_dim)) + self.mix1_weight = nn.Parameter(mix1_weight) + # shape: (head, 2, ms_hidden) + self.mix1_bias = nn.Parameter(mix1_bias) + # shape: (head, ms_hidden) + + mix2_weight = torch.torch.distributions.Uniform(low=-mix2_init, high=mix2_init).sample((head_num, ms_hidden_dim, 1)) + mix2_bias = torch.torch.distributions.Uniform(low=-mix2_init, high=mix2_init).sample((head_num, 1)) + self.mix2_weight = nn.Parameter(mix2_weight) + # shape: (head, ms_hidden, 1) + self.mix2_bias = nn.Parameter(mix2_bias) + # shape: (head, 1) + + def forward(self, row_emb, col_emb, cost_mat): + # q shape: (batch, head_num, row_cnt, qkv_dim) + # k,v shape: (batch, head_num, col_cnt, qkv_dim) + # cost_mat.shape: (batch, row_cnt, col_cnt) + head_num = self.model_params['head_num'] + + q = reshape_by_heads(self.Wq(row_emb), head_num=head_num) + # q shape: (batch, head_num, row_cnt, qkv_dim) + k = reshape_by_heads(self.Wk(col_emb), head_num=head_num) + v = reshape_by_heads(self.Wv(col_emb), head_num=head_num) + + batch_size = q.size(0) + row_cnt = q.size(2) + col_cnt = k.size(2) + + head_num = self.model_params['head_num'] + qkv_dim = self.model_params['qkv_dim'] + + dot_product = torch.matmul(q, k.transpose(2, 3)) + # shape: (batch, head_num, row_cnt, col_cnt) + + dot_product_score = dot_product / math.sqrt(qkv_dim) + # shape: (batch, head_num, row_cnt, col_cnt) + + cost_mat_score = cost_mat[:, None, :, :].expand(batch_size, head_num, row_cnt, col_cnt) + # shape: (batch, head_num, row_cnt, col_cnt) + + two_scores = torch.stack((dot_product_score, cost_mat_score), dim=4) + # shape: (batch, head_num, row_cnt, col_cnt, 2) + + two_scores_transposed = two_scores.transpose(1,2) + # shape: (batch, row_cnt, head_num, col_cnt, 2) + + ms1 = torch.matmul(two_scores_transposed, self.mix1_weight) + # shape: (batch, row_cnt, head_num, col_cnt, ms_hidden_dim) + + ms1 = ms1 + self.mix1_bias[None, None, :, None, :] + # shape: (batch, row_cnt, head_num, col_cnt, ms_hidden_dim) + + ms1_activated = F.relu(ms1) + + ms2 = torch.matmul(ms1_activated, self.mix2_weight) + # shape: (batch, row_cnt, head_num, col_cnt, 1) + + ms2 = ms2 + self.mix2_bias[None, None, :, None, :] + # shape: (batch, row_cnt, head_num, col_cnt, 1) + + mixed_scores = ms2.transpose(1,2) + # shape: (batch, head_num, row_cnt, col_cnt, 1) + + mixed_scores = mixed_scores.squeeze(4) + # shape: (batch, head_num, row_cnt, col_cnt) + + weights = nn.Softmax(dim=3)(mixed_scores) + # shape: (batch, head_num, row_cnt, col_cnt) + + out = torch.matmul(weights, v) + # shape: (batch, head_num, row_cnt, qkv_dim) + + out_transposed = out.transpose(1, 2) + # shape: (batch, row_cnt, head_num, qkv_dim) + + out_concat = out_transposed.reshape(batch_size, row_cnt, head_num * qkv_dim) + # shape: (batch, row_cnt, head_num*qkv_dim) + + return out_concat + + +class InitEmbeddings(nn.Module): + def __init__(self, model_params) -> None: + super().__init__() + self.model_params = model_params + + def forward(self, problems): + # problems.shape: (batch, job_cnt, machine_cnt) + batch_size = problems.size(0) + job_cnt = problems.size(1) + machine_cnt = problems.size(2) + embedding_dim = self.model_params['embedding_dim'] + + row_emb = torch.zeros(size=(batch_size, job_cnt, embedding_dim)) + + # shape: (batch, job_cnt, embedding) + col_emb = torch.zeros(size=(batch_size, machine_cnt, embedding_dim)) + # shape: (batch, machine_cnt, embedding) + + seed_cnt = max(machine_cnt, self.model_params['one_hot_seed_cnt']) + rand = torch.rand(batch_size, seed_cnt) + batch_rand_perm = rand.argsort(dim=1) + rand_idx = batch_rand_perm[:, :machine_cnt] + + b_idx = torch.arange(batch_size)[:, None].expand(batch_size, machine_cnt) + m_idx = torch.arange(machine_cnt)[None, :].expand(batch_size, machine_cnt) + col_emb[b_idx, m_idx, rand_idx] = 1 + # shape: (batch, machine_cnt, embedding) + return row_emb, col_emb + + +class CommunicationLayer(nn.Module): + + def __init__(self, model_params): + super().__init__() + self.mha = MultiHeadAttention(model_params) + self.feed_forward = TransformerFFN(**model_params) + + def forward(self, x): + bs, pomo = x.shape[:2] + x = rearrange(x, "b p ... -> (b p) ...") + # mha with residual connection and normalization + x = self.feed_forward(self.mha(x), x) + return rearrange(x, "(b p) ... -> b p ...", b=bs, p=pomo) + + + +class TransformerFFN(nn.Module): + def __init__(self, **model_params) -> None: + super().__init__() + + if model_params.get("parallel_gated_mlp", None) is not None: + ffn = ParallelGatedMLP(**model_params["parallel_gated_mlp"]) + else: + ffn = FeedForward(**model_params) + + self.ops = nn.ModuleDict( + { + "norm1": Normalization(**model_params), + "ffn": ffn, + "norm2": Normalization(**model_params), + } + ) + + def forward(self, x, x_old): + + x = self.ops["norm1"](x_old + x) + x = self.ops["norm2"](x + self.ops["ffn"](x)) + + return x + + +class ParallelGatedMLP(nn.Module): + def __init__( + self, + dim: int, + hidden_dim: int, + multiple_of: int, + ffn_dim_multiplier: Optional[float]=None, + out_dim: int = None + ): + + super().__init__() + hidden_dim = int(2 * hidden_dim / 3) + # custom dim factor multiplier + if ffn_dim_multiplier is not None: + hidden_dim = int(ffn_dim_multiplier * hidden_dim) + hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of) + out_dim = out_dim or hidden_dim + + + self.l1 = nn.Linear( + in_features=dim, + out_features=hidden_dim, + bias=False, + ) + self.l2 = nn.Linear( + in_features=dim, + out_features=hidden_dim, + bias=False, + ) + self.l3 = nn.Linear( + in_features=hidden_dim, + out_features=out_dim, + bias=False, + ) + + def forward(self, x): + return self.l3(F.silu(self.l1(x)) * self.l2(x)) + + + +class MatNetBlock(nn.Module): + def __init__(self, **model_params): + super().__init__() + self.model_params = model_params + embedding_dim = self.model_params['embedding_dim'] + head_num = self.model_params['head_num'] + qkv_dim = self.model_params['qkv_dim'] + + self.mixed_score_MHA = MixedScore_MultiHeadAttention(**model_params) + self.multi_head_combine = nn.Linear(head_num * qkv_dim, embedding_dim) + self.feed_forward = TransformerFFN(**model_params) + + def forward(self, row_emb, col_emb, cost_mat): + # NOTE: row and col can be exchanged, if cost_mat.transpose(1,2) is used + # input1.shape: (batch, row_cnt, embedding) + # input2.shape: (batch, col_cnt, embedding) + # cost_mat.shape: (batch, row_cnt, col_cnt) + + out_concat = self.mixed_score_MHA(row_emb, col_emb, cost_mat) + # shape: (batch, row_cnt, head_num*qkv_dim) + + multi_head_out = self.multi_head_combine(out_concat) + # shape: (batch, row_cnt, embedding) + ffn_out = self.feed_forward(multi_head_out, row_emb) + + return ffn_out + # shape: (batch, row_cnt, embedding) + +######################################## +def reshape_by_heads(qkv, head_num): + return rearrange(qkv, "... g (h s) -> ... h g s", h=head_num) \ No newline at end of file diff --git a/parco/tasks/ffsp_old/FFSP_PARCO/FFSPTrainer.py b/parco/tasks/ffsp_old/FFSP_PARCO/FFSPTrainer.py new file mode 100644 index 0000000..79c37d8 --- /dev/null +++ b/parco/tasks/ffsp_old/FFSP_PARCO/FFSPTrainer.py @@ -0,0 +1,398 @@ +import torch +from logging import getLogger + +from FFSPEnv import FFSPEnv as Env +from FFSPModel import FFSPModel + +from torch.optim import AdamW as Optimizer +from torch.optim.lr_scheduler import MultiStepLR, ExponentialLR, ReduceLROnPlateau, CyclicLR, CosineAnnealingLR + +import wandb + +from utils.utils import * +from FFSProblemDef import load_problems_from_file, get_random_problems + +import numpy as np +# +scheduler_map = { + "multistep": MultiStepLR, + "exponential": ExponentialLR, + "cyclic": CyclicLR, + "plateau": ReduceLROnPlateau, + "cos": CosineAnnealingLR +} + + + +class FFSPTrainer: + def __init__(self, + env_params, + model_params, + optimizer_params, + trainer_params, + tester_params): + + # save arguments + torch.manual_seed(env_params["seed"]) + self.env_params = env_params + self.model_params = model_params + self.optimizer_params = optimizer_params + self.trainer_params = trainer_params + self.tester_params = tester_params + self.grad_accumulation_steps = trainer_params["accumulation_steps"] + # result folder, logger + self.logger = getLogger(name='trainer') + self.result_folder = get_result_folder() + self.result_log = LogData() + + self.wandb = wandb.init( + project="parco-ffsp", + tags=[ + f"jobs:{env_params['job_cnt']}", + f"machines:{env_params['ma_cnt_str']}" + ], + config={ + "model": dict(model_params), + "optimizer": dict(optimizer_params), + "train": dict(trainer_params) + } + ) + + # cuda + use_cuda = self.trainer_params['use_cuda'] and torch.cuda.is_available() + if use_cuda: + cuda_device_num = self.trainer_params['cuda_device_num'] + torch.cuda.set_device(cuda_device_num) + device = torch.device('cuda', cuda_device_num) + torch.set_default_tensor_type('torch.cuda.FloatTensor') + else: + device = torch.device('cpu') + torch.set_default_tensor_type('torch.FloatTensor') + + + self.model = FFSPModel(**self.model_params) + self.env = Env(**self.env_params) + self.optimizer = Optimizer(self.model.parameters(), **self.optimizer_params['optimizer']) + Scheduler = scheduler_map[self.optimizer_params['scheduler']["class"]] + self.scheduler = Scheduler(self.optimizer, **self.optimizer_params['scheduler']["kwargs"]) + + # restore + self.start_epoch = 1 + + + # utility + self.time_estimator = TimeEstimator() + + # Load all problems + self.logger.info(" *** Loading Saved Problems *** ") + saved_problem_folder = self.tester_params['saved_problem_folder'] + saved_problem_filename = self.tester_params['saved_problem_filename'] + filename = os.path.join(saved_problem_folder, saved_problem_filename) + try: + self.ALL_problems_INT_list = load_problems_from_file(filename, device=device) + except: + self.ALL_problems_INT_list = get_random_problems( + self.tester_params["problem_count"], + self.env_params["machine_cnt_list"], + self.env_params["job_cnt"], + self.env_params["process_time_params"] + ) + + self.logger.info("Done. ") + + + def run(self): + """ + Run training for multiple epochs + """ + + self.time_estimator.reset(self.start_epoch) + for epoch in range(self.start_epoch, self.trainer_params['epochs']+1): + self.logger.info('=================================================================') + + + + # Train + train_score, train_loss, steps = self._train_one_epoch(epoch) + self.result_log.append('train_score', epoch, train_score) + self.result_log.append('train_loss', epoch, train_loss) + self.result_log.append('steps', epoch, steps) + # LR Decay + self.scheduler.step() + + ############################ + # Logs & Checkpoint + ############################ + elapsed_time_str, remain_time_str = self.time_estimator.get_est_string(epoch, self.trainer_params['epochs']) + self.logger.info("Epoch {:3d}/{:3d}: Time Est.: Elapsed[{}], Remain[{}]".format( + epoch, self.trainer_params['epochs'], elapsed_time_str, remain_time_str)) + + all_done = (epoch == self.trainer_params['epochs']) + model_save_interval = self.trainer_params['logging']['model_save_interval'] + img_save_interval = self.trainer_params['logging']['img_save_interval'] + + if epoch > 1: # save latest images, every epoch + self.logger.info("Saving log_image") + image_prefix = '{}/latest'.format(self.result_folder) + util_save_log_image_with_label(image_prefix, self.trainer_params['logging']['log_image_params_1'], + self.result_log, labels=['train_score']) + util_save_log_image_with_label(image_prefix, self.trainer_params['logging']['log_image_params_2'], + self.result_log, labels=['train_loss']) + + if all_done or (epoch % model_save_interval) == 0: + self.logger.info("Saving trained_model") + checkpoint_dict = { + 'epoch': epoch, + 'model_state_dict': self.model.state_dict(), + 'optimizer_state_dict': self.optimizer.state_dict(), + 'scheduler_state_dict': self.scheduler.state_dict(), + 'result_log': self.result_log.get_raw_data() + } + torch.save(checkpoint_dict, '{}/checkpoint-{}.pt'.format(self.result_folder, epoch)) + + if all_done or (epoch % img_save_interval) == 0: + image_prefix = '{}/img/checkpoint-{}'.format(self.result_folder, epoch) + util_save_log_image_with_label(image_prefix, self.trainer_params['logging']['log_image_params_1'], + self.result_log, labels=['train_score']) + util_save_log_image_with_label(image_prefix, self.trainer_params['logging']['log_image_params_2'], + self.result_log, labels=['train_loss']) + + if all_done: + self.logger.info(" *** Training Done *** ") + self.logger.info("Now, printing log array...") + util_print_log_array(self.logger, self.result_log) + + + + def _train_one_epoch(self, epoch): + + score_AM = AverageMeter() + loss_AM = AverageMeter() + steps_AM = AverageMeter() + + train_num_episode = self.trainer_params['train_episodes'] + episode = 0 + + while episode < train_num_episode: + + remaining = train_num_episode - episode + batch_size = min(self.trainer_params['train_batch_size'], remaining) + + avg_score, avg_loss, steps_mean = self._train_one_batch(batch_size, self.grad_accumulation_steps) + score_AM.update(avg_score, batch_size) + loss_AM.update(avg_loss, batch_size) + steps_AM.update(steps_mean, batch_size) + + episode += batch_size + + self.logger.info( + 'Epoch {:3d}: Train {:3d}/{:3d}({:1.1f}%) Score: {:.4f}, Loss: {:.4f}, Steps: {}' + .format( + epoch, episode, train_num_episode, + 100. * episode / train_num_episode, + score_AM.avg, loss_AM.avg, steps_AM.avg + ) + ) + + self.logger.info("skip ratio: {}".format(np.mean(self.env.skip_ratio))) + + self.wandb.log({ + "score": score_AM.avg, + "loss": loss_AM.avg, + "steps": steps_AM.avg, + }) + return score_AM.avg, loss_AM.avg, steps_AM.avg + + def _train_one_batch(self, batch_size, accumulation_steps=1): + + # Prep + ############################################### + self.model.train() + mini_batch_size = batch_size // accumulation_steps + self.optimizer.zero_grad() + score_mean = 0 + steps_mean = 0 + for _ in range(accumulation_steps): + self.env.load_problems(mini_batch_size) + reset_state, _, _ = self.env.reset() + self.model.pre_forward(reset_state) + # shape: (batch, pomo, 0~makespan) + prob_list = torch.zeros(size=(mini_batch_size, self.env.pomo_size, 0)) + # Rollout + state, reward, done = self.env.pre_step() + + steps = 0 + while not done: + jobs, machines, prob = self.model(state) + # shape: (batch, pomo) + state, reward, done = self.env.step(jobs, machines) + prob_list = torch.cat((prob_list, prob), dim=-1) + steps += 1 + # LEARNING + ############################################### + advantage = reward - reward.float().mean(dim=1, keepdims=True) + # shape: (batch, pomo) + log_prob = prob_list.log().sum(dim=2) + # size = (batch, pomo) + loss = -advantage * log_prob # Minus Sign: To Increase REWARD + # shape: (batch, pomo) + + loss_mean = loss.mean() / accumulation_steps + loss_mean.backward() + + # Score + ############################################### + max_pomo_reward, _ = reward.max(dim=1) # get best results from pomo + score_mean += -(max_pomo_reward.float().mean().item() / accumulation_steps) # negative sign to make positive value + steps_mean += steps / accumulation_steps + + for group in self.optimizer.param_groups: + torch.nn.utils.clip_grad_norm_(group['params'], self.trainer_params["max_grad_norm"]) + + # Step & Return + ############################################### + self.optimizer.step() + self.model.zero_grad() + + return score_mean, loss_mean.item(), steps_mean + + + def _train_one_batch_self_labeling(self, batch_size): + + # Prep + ############################################### + self.model.train() + self.env.load_problems(batch_size) + reset_state, _, _ = self.env.reset() + self.model.pre_forward(reset_state) + + prob_list = torch.zeros(size=(batch_size, self.env.pomo_size, 0)) + # shape: (batch, pomo, 0~makespan) + + # Rollout + ############################################### + state, reward, done = self.env.pre_step() + + while not done: + + jobs, machines, prob = self.model(state) + # shape: (batch, pomo) + state, reward, done = self.env.step(jobs, machines) + + prob_list = torch.cat((prob_list, prob), dim=-1) + + # LEARNING + ############################################### + max, argmax = reward.float().max(dim=1) + # shape: (batch, pomo) + log_prob = prob_list.log().sum(dim=2) + # size = (batch, pomo) + loss = -log_prob.gather(1, argmax.unsqueeze(1)).mean() + + + # Score + ############################################### + score_mean = -max.float().mean() # negative sign to make positive value + + # Step & Return + ############################################### + self.model.zero_grad() + loss.backward() + self.optimizer.step() + return score_mean.item(), loss.item() + + + def eval(self): + + # save_solution = self.tester_params['save_solution']['enable'] + # solution_list = [] + + self.time_estimator.reset() + + score_AM = AverageMeter() + aug_score_AM = AverageMeter() + + test_num_episode = self.tester_params['problem_count'] + episode = 0 + + while episode < test_num_episode: + + remaining = test_num_episode - episode + batch_size = min(self.tester_params['test_batch_size'], remaining) + + problems_INT_list = [] + for stage_idx in range(self.env.stage_cnt): + problems_INT_list.append(self.ALL_problems_INT_list[stage_idx][episode:episode+batch_size]) + + score, aug_score = self._test_one_batch(problems_INT_list) + + score_AM.update(score, batch_size) + aug_score_AM.update(aug_score, batch_size) + + episode += batch_size + + ############################ + # Logs + ############################ + elapsed_time_str, remain_time_str = self.time_estimator.get_est_string(episode, test_num_episode) + self.logger.info("episode {:3d}/{:3d}, Elapsed[{}], Remain[{}], score:{:.3f}, aug_score:{:.3f}".format( + episode, test_num_episode, elapsed_time_str, remain_time_str, score, aug_score)) + + all_done = (episode == test_num_episode) + + if all_done: + self.logger.info(" *** Test Done *** ") + self.logger.info(" NO-AUG SCORE: {:.4f} ".format(score_AM.avg)) + self.logger.info(" AUGMENTATION SCORE: {:.4f} ".format(aug_score_AM.avg)) + + self.wandb.log({ + "test_score": score_AM.avg, + "test_score_aug": aug_score_AM.avg, + }) + + def _test_one_batch(self, problems_INT_list): + + batch_size = problems_INT_list[0].size(0) + + # Augmentation + ############################################### + if self.tester_params['augmentation_enable']: + aug_factor = self.tester_params['aug_factor'] + batch_size = aug_factor*batch_size + for stage_idx in range(self.env.stage_cnt): + problems_INT_list[stage_idx] = problems_INT_list[stage_idx].repeat(aug_factor, 1, 1) + # shape: (batch*aug_factor, job_cnt, machine_cnt) + else: + aug_factor = 1 + + # Ready + ############################################### + self.model.eval() + with torch.no_grad(): + self.env.load_problems_manual(problems_INT_list) + reset_state, _, _ = self.env.reset() + self.model.pre_forward(reset_state) + + # POMO Rollout + ############################################### + state, reward, done = self.env.pre_step() + while not done: + jobs, machines, _ = self.model(state) + # shape: (batch, pomo) + state, reward, done = self.env.step(jobs, machines) + + # Return + ############################################### + batch_size = batch_size//aug_factor + aug_reward = reward.reshape(aug_factor, batch_size, self.env.pomo_size) + # shape: (augmentation, batch, pomo) + + max_pomo_reward, _ = aug_reward.max(dim=2) # get best results from pomo + # shape: (augmentation, batch) + no_aug_score = -max_pomo_reward[0, :].float().mean() # negative sign to make positive value + + max_aug_pomo_reward, _ = max_pomo_reward.max(dim=0) # get best results from augmentation + # shape: (batch,) + aug_score = -max_aug_pomo_reward.float().mean() # negative sign to make positive value + + return no_aug_score.item(), aug_score.item() \ No newline at end of file diff --git a/parco/tasks/ffsp_old/FFSP_PARCO/HAMLayer.py b/parco/tasks/ffsp_old/FFSP_PARCO/HAMLayer.py new file mode 100644 index 0000000..7af70a6 --- /dev/null +++ b/parco/tasks/ffsp_old/FFSP_PARCO/HAMLayer.py @@ -0,0 +1,146 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import math +from einops import rearrange +from FFSPModel_SUB import MultiHeadAttention, TransformerFFN, Normalization + + +class MixedScoreFF(nn.Module): + def __init__(self, **model_params) -> None: + super().__init__() + ms_hidden_dim = model_params['ms_hidden_dim'] + num_heads = model_params['head_num'] + + self.lin1 = nn.Linear(2 * num_heads, num_heads * ms_hidden_dim, bias=False) + self.lin2 = nn.Linear(num_heads * ms_hidden_dim, 2 * num_heads, bias=False) + + def forward(self, dot_product_score, cost_mat_score): + # dot_product_score shape: (batch, head_num, row_cnt, col_cnt) + # cost_mat_score shape: (batch, head_num, row_cnt, col_cnt) + # shape: (batch, head_num, row_cnt, col_cnt, 2) + two_scores = torch.stack((dot_product_score, cost_mat_score), dim=-1) + two_scores = rearrange(two_scores, "b h r c s -> b r c (h s)") + # shape: (batch, row_cnt, col_cnt, 2 * num_heads) + ms = self.lin2(F.relu(self.lin1(two_scores))) + # shape: (batch, row_cnt, head_num, col_cnt) + mixed_scores = rearrange(ms, "b r c (h two) -> b h r c two", two=2) + ms1, ms2 = mixed_scores.chunk(2, dim=-1) + + return ms1.squeeze(-1), ms2.squeeze(-1) + + +class EfficientMixedScoreMultiHeadAttention(nn.Module): + def __init__(self, **model_params): + super().__init__() + embedding_dim = model_params['embedding_dim'] + self.num_heads = model_params['head_num'] + qkv_dim = model_params["qkv_dim"] + self.scale_dots = model_params["scale_dots"] + + self.qkv_dim = qkv_dim + self.norm_factor = 1 / math.sqrt(qkv_dim) + + self.Wqv1 = nn.Linear(embedding_dim, 2 * embedding_dim, bias=False) + self.Wkv2 = nn.Linear(embedding_dim, 2 * embedding_dim, bias=False) + + # self.init_parameters() + self.mixed_scores_layer = MixedScoreFF(**model_params) + + self.out_proj1 = nn.Linear(embedding_dim, embedding_dim, bias=False) + self.out_proj2 = nn.Linear(embedding_dim, embedding_dim, bias=False) + + + def forward(self, x1, x2, attn_mask = None, cost_mat = None): + batch_size = x1.size(0) + row_cnt = x1.size(-2) + col_cnt = x2.size(-2) + + # Project query, key, value + q, v1 = rearrange( + self.Wqv1(x1), "b s (two h d) -> two b h s d", two=2, h=self.num_heads + ).unbind(dim=0) + + # Project query, key, value + k, v2 = rearrange( + self.Wqv1(x2), "b s (two h d) -> two b h s d", two=2, h=self.num_heads + ).unbind(dim=0) + + # shape: (batch, num_heads, row_cnt, col_cnt) + dot = self.norm_factor * torch.matmul(q, k.transpose(-2, -1)) + + if cost_mat is not None: + # shape: (batch, num_heads, row_cnt, col_cnt) + cost_mat_score = cost_mat[:, None, :, :].expand_as(dot) + ms1, ms2 = self.mixed_scores_layer(dot, cost_mat_score) + + if attn_mask is not None: + attn_mask = attn_mask.view(batch_size, 1, row_cnt, col_cnt).expand_as(dot) + dot.masked_fill_(~attn_mask, float("-inf")) + + h1 = self.out_proj1( + apply_weights_and_combine(ms1, v2, scale=self.scale_dots) + ) + h2 = self.out_proj2( + apply_weights_and_combine(ms2.transpose(-2, -1), v1, scale=self.scale_dots) + ) + + return h1, h2 + + +class EncoderLayer(nn.Module): + def __init__(self, **model_params): + super().__init__() + + self.op_attn = MultiHeadAttention(model_params) + self.ma_attn = MultiHeadAttention(model_params) + self.cross_attn = EfficientMixedScoreMultiHeadAttention(**model_params) + + self.op_ffn = TransformerFFN(**model_params) + self.ma_ffn = TransformerFFN(**model_params) + + self.op_norm = Normalization(**model_params) + self.ma_norm = Normalization(**model_params) + + + def forward( + self, + op_in, + ma_in, + cost_mat, + op_mask=None, + ma_mask=None, + cross_mask=None + ): + + op_cross_out, ma_cross_out = self.cross_attn(op_in, ma_in, attn_mask=cross_mask, cost_mat=cost_mat) + op_cross_out = self.op_norm(op_cross_out + op_in) + ma_cross_out = self.ma_norm(ma_cross_out + ma_in) + + # (bs, num_jobs, ops_per_job, d) + op_self_out = self.op_attn(op_cross_out, attn_mask=op_mask) + # (bs, num_ma, d) + ma_self_out = self.ma_attn(ma_cross_out, attn_mask=ma_mask) + + op_out = self.op_ffn(op_cross_out, op_self_out) + ma_out = self.ma_ffn(ma_cross_out, ma_self_out) + + return op_out, ma_out + + + +def apply_weights_and_combine(logits, v, tanh_clipping=10, scale=True): + if scale: + # scale to avoid numerical underflow + logits = logits / logits.std() + if tanh_clipping > 0: + # tanh clipping to avoid explosions + logits = torch.tanh(logits) * tanh_clipping + # shape: (batch, num_heads, row_cnt, col_cnt) + weights = nn.Softmax(dim=-1)(logits) + weights = weights.nan_to_num(0) + # shape: (batch, num_heads, row_cnt, qkv_dim) + out = torch.matmul(weights, v) + # shape: (batch, row_cnt, num_heads, qkv_dim) + out = rearrange(out, "b h s d -> b s (h d)") + return out diff --git a/parco/tasks/ffsp_old/FFSP_PARCO/main.py b/parco/tasks/ffsp_old/FFSP_PARCO/main.py new file mode 100644 index 0000000..3de1de6 --- /dev/null +++ b/parco/tasks/ffsp_old/FFSP_PARCO/main.py @@ -0,0 +1,45 @@ +import os +import sys + +os.chdir(os.path.dirname(os.path.abspath(__file__))) +sys.path.insert(0, "..") # for problem_def + + +########################################################################################## +# import + +import hydra +from omegaconf import DictConfig +from utils.utils import create_logger +from FFSPTrainer import FFSPTrainer as Trainer + + +########################################################################################## +# main +@hydra.main(version_base="1.3", config_path="../../configs/ffsp", config_name="config.yaml") +def main(cfg: DictConfig): + + + env_params = cfg["env"] + model_params = cfg["model"] + optimizer_params = cfg["optimizer"] + trainer_params = cfg["train"] + tester_params = cfg["test"] + logger_params = cfg["logger"] + create_logger(**logger_params) + + trainer = Trainer(env_params=env_params, + model_params=model_params, + optimizer_params=optimizer_params, + trainer_params=trainer_params, + tester_params=tester_params) + + trainer.run() + + trainer.eval() + + +########################################################################################## + +if __name__ == "__main__": + main() diff --git a/parco/tasks/ffsp_old/FFSP_PARCO/speed.py b/parco/tasks/ffsp_old/FFSP_PARCO/speed.py new file mode 100644 index 0000000..d9c0ceb --- /dev/null +++ b/parco/tasks/ffsp_old/FFSP_PARCO/speed.py @@ -0,0 +1,104 @@ +from hydra import compose, initialize +from omegaconf import OmegaConf +import os +import sys + +os.chdir(os.path.dirname(os.path.abspath(__file__))) +sys.path.insert(0, "..") # for problem_def + +import timeit +import torch +from FFSPEnv import FFSPEnv as Env +from FFSPModel import FFSPModel +from FFSProblemDef import load_problems_from_file, get_random_problems + + +with initialize(version_base=None, config_path="../../configs"): + cfg = compose(config_name="config", overrides=["env=ffsp20", "model.use_comm_layer=True"]) + +print(OmegaConf.to_yaml(cfg)) + + + +device_num = 6 + +env_params = cfg["env"] +model_params = cfg["model"] +optimizer_params = cfg["optimizer"] +trainer_params = cfg["train"] +tester_params = cfg["test"] +logger_params = cfg["logger"] + + +use_cuda = torch.cuda.is_available() +if use_cuda: + cuda_device_num = device_num + torch.cuda.set_device(cuda_device_num) + device = torch.device('cuda', cuda_device_num) + torch.set_default_tensor_type('torch.cuda.FloatTensor') +else: + device = torch.device('cpu') + torch.set_default_tensor_type('torch.FloatTensor') + + +model = FFSPModel(**model_params) +env = Env(**env_params) + +#ffsp20 +checkpoint_fullname = "FFSP/FFSP_PARCO/result/20240814_230605_matnet_train/checkpoint-100.pt" +# #ffsp50 comm +# checkpoint_fullname = "FFSP/FFSP_PARCO/result/20240813_213230_matnet_train/checkpoint-150.pt" +# #ffsp100 comm +# checkpoint_fullname = "FFSP/FFSP_PARCO/result/20240814_021241_matnet_train/checkpoint-200.pt" +# ffsp20 no comm +# checkpoint_fullname = "FFSP/FFSP_PARCO/result/20240816_192812_matnet_train/checkpoint-100.pt" + + + +checkpoint = torch.load(checkpoint_fullname, map_location=device) +model.load_state_dict(checkpoint['model_state_dict']) + + +saved_problem_folder = tester_params['saved_problem_folder'] +saved_problem_filename = tester_params['saved_problem_filename'] +filename = os.path.join(saved_problem_folder, saved_problem_filename) +try: + ALL_problems_INT_list = load_problems_from_file(filename, device=device) +except: + ALL_problems_INT_list = get_random_problems( + tester_params["problem_count"], + env_params["machine_cnt_list"], + env_params["job_cnt"], + env_params["process_time_params"] + ) + + +def solve_one_instance(episode=0): + batch_size = 1 + problems_INT_list = [] + for stage_idx in range(env.stage_cnt): + problems_INT_list.append(ALL_problems_INT_list[stage_idx][episode:episode+batch_size]) + model.eval() + with torch.inference_mode(): + env.load_problems_manual(problems_INT_list) + reset_state, _, _ = env.reset() + model.pre_forward(reset_state) + + # POMO Rollout + ############################################### + state, reward, done = env.pre_step() + while not done: + jobs, machines, _ = model(state) + # shape: (batch, pomo) + state, reward, done = env.step(jobs, machines) + + +if __name__ == "__main__": + import numpy as np + nums = 20 + res = timeit.repeat(f"for i in range({nums}): solve_one_instance(i)", "from __main__ import solve_one_instance", number=1) + # exclude first for warmup (gpu) + if isinstance(res, float): + print(res / nums) + else: + print(np.array(res[1:]).mean() / nums) diff --git a/parco/tasks/ffsp_old/FFSProblemDef.py b/parco/tasks/ffsp_old/FFSProblemDef.py new file mode 100644 index 0000000..4dae1a3 --- /dev/null +++ b/parco/tasks/ffsp_old/FFSProblemDef.py @@ -0,0 +1,86 @@ + +import torch + + +def get_random_problems(batch_size, machine_cnt_list, job_cnt, process_time_params): + + time_low = process_time_params['time_low'] + time_high = process_time_params['time_high'] + stage_cnt = len(machine_cnt_list) + problems_INT_list = [] + for stage_num in range(stage_cnt): + machine_cnt = machine_cnt_list[stage_num] + stage_problems_INT = torch.randint(low=time_low, high=time_high, size=(batch_size, job_cnt, machine_cnt)) + problems_INT_list.append(stage_problems_INT) + + + return problems_INT_list + + +def load_problems_from_file(filename, device=torch.device('cpu')): + data = torch.load(filename) + + problems_INT_list = data['problems_INT_list'] + + for stage_idx in range(data['stage_cnt']): + problems_INT_list[stage_idx] = problems_INT_list[stage_idx].to(device) + + return problems_INT_list + +def get_random_problems_by_random_state(rand, batch_size, machine_cnt_list, job_cnt, **process_time_params): + distribution = process_time_params['distribution'] + same_process_time_within_stage = process_time_params['same_process_time_within_stage'] + min_process_time_list = process_time_params['min_process_time_list'] + max_process_time_list = process_time_params['max_process_time_list'] + + if same_process_time_within_stage: + if distribution == 'uniform': + return [ + torch.tensor(rand.randint(low=min_time, high=max_time, size=(batch_size, job_cnt, 1)), + dtype=torch.float32).expand((batch_size, job_cnt, m_cnt)) + for min_time, max_time, m_cnt in zip(min_process_time_list, + max_process_time_list, + machine_cnt_list)] + elif distribution == 'normal': + return [ + torch.tensor(rand.normal(loc=max_time - min_time, + scale=(max_time - min_time) / 3, + size=(batch_size, job_cnt, 1) + ).clip(min_time, max_time).astype(int), + dtype=torch.float32).expand((batch_size, job_cnt, m_cnt)) + for min_time, max_time, m_cnt in zip(min_process_time_list, + max_process_time_list, + machine_cnt_list)] + else: + if distribution == 'uniform': + return [torch.tensor(rand.randint(low=min_time, high=max_time, size=(batch_size, job_cnt, m_cnt)), + dtype=torch.float32) + for min_time, max_time, m_cnt in zip(min_process_time_list, + max_process_time_list, + machine_cnt_list)] + elif distribution == 'normal': + return [torch.tensor(rand.normal(loc=max_time - min_time, + scale=(max_time - min_time) / 3, + size=(batch_size, job_cnt, m_cnt)).clip(min_time, max_time).astype(int), + dtype=torch.float32) + for min_time, max_time, m_cnt in zip(min_process_time_list, + max_process_time_list, + machine_cnt_list)] + raise NotImplementedError + + +def load_ONE_problem_from_file(filename, device=torch.device('cpu'), index=0): + data = torch.load(filename) + + problems_INT_list = data['problems_INT_list'] + problems_list = data['problems_list'] + + for stage_idx in range(data['stage_cnt']): + problems_INT_list[stage_idx] = problems_INT_list[stage_idx][[index], :, :] + problems_INT_list[stage_idx] = problems_INT_list[stage_idx].to(device) + + problems_list[stage_idx] = problems_list[stage_idx][[index], :, :] + problems_list[stage_idx] = problems_list[stage_idx].to(device) + + return problems_INT_list, problems_list + diff --git a/parco/tasks/ffsp_old/README.md b/parco/tasks/ffsp_old/README.md new file mode 100644 index 0000000..23c4b43 --- /dev/null +++ b/parco/tasks/ffsp_old/README.md @@ -0,0 +1,4 @@ +# PARCO for the FFSP (legacy) + +This code is based on the MatNet implementation: https://github.com/yd-kwon/MatNet + diff --git a/parco/tasks/ffsp_old/utils/log_image_style/style.json b/parco/tasks/ffsp_old/utils/log_image_style/style.json new file mode 100644 index 0000000..746b63e --- /dev/null +++ b/parco/tasks/ffsp_old/utils/log_image_style/style.json @@ -0,0 +1,19 @@ +{ + "figsize": { + "x": 7, + "y": 3.5 + }, + + + "xlim": { + "min": null, + "max": null + }, + + "ylim": { + "min": null, + "max": null + }, + + "grid": true +} diff --git a/parco/tasks/ffsp_old/utils/log_image_style/style_loss.json b/parco/tasks/ffsp_old/utils/log_image_style/style_loss.json new file mode 100644 index 0000000..0b2b006 --- /dev/null +++ b/parco/tasks/ffsp_old/utils/log_image_style/style_loss.json @@ -0,0 +1,18 @@ +{ + "figsize": { + "x": 10, + "y": 5 + }, + + "xlim": { + "min": null, + "max": null + }, + + "ylim": { + "min": null, + "max": null + }, + + "grid": true +} diff --git a/parco/tasks/ffsp_old/utils/utils.py b/parco/tasks/ffsp_old/utils/utils.py new file mode 100644 index 0000000..c860470 --- /dev/null +++ b/parco/tasks/ffsp_old/utils/utils.py @@ -0,0 +1,378 @@ +""" +The MIT License + +Copyright (c) 2021 MatNet + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + + + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +""" + +import time +import decimal +import sys +import os +import copy +from datetime import datetime +import logging +import logging.config +import pytz +import numpy as np +import matplotlib.pyplot as plt +from collections import OrderedDict +import json +import shutil + +process_start_time = datetime.now(pytz.timezone("Asia/Seoul")) +result_folder = './result/' + process_start_time.strftime("%Y%m%d_%H%M%S") + '{desc}' + + +def get_result_folder(): + return result_folder + + +def set_result_folder(folder): + global result_folder + result_folder = folder + + +def create_logger(log_file=None): + if 'filepath' not in log_file: + filepath = get_result_folder() + + if 'desc' in log_file: + filepath = filepath.format(desc='_' + log_file['desc']) + else: + filepath = filepath.format(desc='') + + set_result_folder(filepath) + + if 'filename' in log_file: + filename = filepath + '/' + log_file['filename'] + else: + filename = filepath + '/' + 'log.txt' + + if not os.path.exists(filepath): + os.makedirs(filepath) + + file_mode = 'a' if os.path.isfile(filename) else 'w' + + root_logger = logging.getLogger() + root_logger.setLevel(level=logging.INFO) + formatter = logging.Formatter("[%(asctime)s] %(filename)s(%(lineno)d) : %(message)s", "%Y-%m-%d %H:%M:%S") + + for hdlr in root_logger.handlers[:]: + root_logger.removeHandler(hdlr) + + # write to file + fileout = logging.FileHandler(filename, mode=file_mode) + fileout.setLevel(logging.INFO) + fileout.setFormatter(formatter) + root_logger.addHandler(fileout) + + # write to console + console = logging.StreamHandler(sys.stdout) + console.setLevel(logging.INFO) + console.setFormatter(formatter) + root_logger.addHandler(console) + + +class AverageMeter: + def __init__(self): + self.reset() + + def reset(self): + self.sum = 0 + self.count = 0 + + def update(self, val, n=1): + self.sum += (val * n) + self.count += n + + @property + def avg(self): + return self.sum / self.count if self.count else 0 + + +class LogData: + def __init__(self): + self.keys = set() + self.data = {} + + def get_raw_data(self): + return self.keys, self.data + + def set_raw_data(self, r_data): + self.keys, self.data = r_data + + def append_all(self, key, *args): + if len(args) == 1: + value = [list(range(len(args[0]))), args[0]] + elif len(args) == 2: + value = [args[0], args[1]] + else: + raise ValueError('Unsupported value type') + + if key in self.keys: + self.data[key].extend(value) + else: + self.data[key] = np.stack(value, axis=1).tolist() + self.keys.add(key) + + def append(self, key, *args): + if len(args) == 1: + args = args[0] + + if isinstance(args, int) or isinstance(args, float): + if self.has_key(key): + value = [len(self.data[key]), args] + else: + value = [0, args] + elif type(args) == tuple: + value = list(args) + elif type(args) == list: + value = args + else: + raise ValueError('Unsupported value type') + elif len(args) == 2: + value = [args[0], args[1]] + else: + raise ValueError('Unsupported value type') + + if key in self.keys: + self.data[key].append(value) + else: + self.data[key] = [value] + self.keys.add(key) + + def get_last(self, key): + if not self.has_key(key): + return None + return self.data[key][-1] + + def has_key(self, key): + return key in self.keys + + def get(self, key): + split = np.hsplit(np.array(self.data[key]), 2) + + return split[1].squeeze().tolist() + + def getXY(self, key, start_idx=0): + split = np.hsplit(np.array(self.data[key]), 2) + + xs = split[0].squeeze().tolist() + ys = split[1].squeeze().tolist() + + if type(xs) is not list: + return xs, ys + + if start_idx == 0: + return xs, ys + elif start_idx in xs: + idx = xs.index(start_idx) + return xs[idx:], ys[idx:] + else: + raise KeyError('no start_idx value in X axis data.') + + def get_keys(self): + return self.keys + + +class TimeEstimator: + def __init__(self): + self.logger = logging.getLogger('TimeEstimator') + self.start_time = time.time() + self.count_zero = 0 + + def reset(self, count=1): + self.start_time = time.time() + self.count_zero = count - 1 + + def get_est(self, count, total): + curr_time = time.time() + elapsed_time = curr_time - self.start_time + remain = total - count + remain_time = elapsed_time * remain / (count - self.count_zero) + + elapsed_time /= 3600.0 + remain_time /= 3600.0 + + return elapsed_time, remain_time + + def get_est_string(self, count, total): + elapsed_time, remain_time = self.get_est(count, total) + + elapsed_time_str = "{:.2f}h".format(elapsed_time) if elapsed_time > 1.0 else "{:.2f}m".format(elapsed_time * 60) + remain_time_str = "{:.2f}h".format(remain_time) if remain_time > 1.0 else "{:.2f}m".format(remain_time * 60) + + return elapsed_time_str, remain_time_str + + def print_est_time(self, count, total): + elapsed_time_str, remain_time_str = self.get_est_string(count, total) + + self.logger.info("Epoch {:3d}/{:3d}: Time Est.: Elapsed[{}], Remain[{}]".format( + count, total, elapsed_time_str, remain_time_str)) + +def util_print_log_array(logger, result_log: LogData): + assert type(result_log) == LogData, 'use LogData Class for result_log.' + + for key in result_log.get_keys(): + logger.info('{} = {}'.format(key + '_list', result_log.get(key))) + + +def util_save_log_image_with_label(result_file_prefix, + img_params, + result_log: LogData, + labels=None): + dirname = os.path.dirname(result_file_prefix) + if not os.path.exists(dirname): + os.makedirs(dirname) + + _build_log_image_plt(img_params, result_log, labels) + + if labels is None: + labels = result_log.get_keys() + file_name = '_'.join(labels) + fig = plt.gcf() + fig.savefig('{}-{}.jpg'.format(result_file_prefix, file_name)) + plt.close(fig) + + +def _build_log_image_plt(img_params, + result_log: LogData, + labels=None): + assert type(result_log) == LogData, 'use LogData Class for result_log.' + + # Read json + folder_name = img_params['json_foldername'] + file_name = img_params['filename'] + log_image_config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), folder_name, file_name) + + with open(log_image_config_file, 'r') as f: + config = json.load(f) + + figsize = (config['figsize']['x'], config['figsize']['y']) + plt.figure(figsize=figsize) + + if labels is None: + labels = result_log.get_keys() + for label in labels: + plt.plot(*result_log.getXY(label), label=label) + + ylim_min = config['ylim']['min'] + ylim_max = config['ylim']['max'] + if ylim_min is None: + ylim_min = plt.gca().dataLim.ymin + if ylim_max is None: + ylim_max = plt.gca().dataLim.ymax + plt.ylim(ylim_min, ylim_max) + + xlim_min = config['xlim']['min'] + xlim_max = config['xlim']['max'] + if xlim_min is None: + xlim_min = plt.gca().dataLim.xmin + if xlim_max is None: + xlim_max = plt.gca().dataLim.xmax + plt.xlim(xlim_min, xlim_max) + + plt.rc('legend', **{'fontsize': 18}) + plt.legend() + plt.grid(config["grid"]) + +def copy_all_src(dst_root): + # execution dir + if os.path.basename(sys.argv[0]).startswith('ipykernel_launcher'): + execution_path = os.getcwd() + else: + execution_path = os.path.dirname(sys.argv[0]) + + # home dir setting + tmp_dir1 = os.path.abspath(os.path.join(execution_path, sys.path[0])) + tmp_dir2 = os.path.abspath(os.path.join(execution_path, sys.path[1])) + + if len(tmp_dir1) > len(tmp_dir2) and os.path.exists(tmp_dir2): + home_dir = tmp_dir2 + else: + home_dir = tmp_dir1 + + # make target directory + dst_path = os.path.join(dst_root, 'src') + + if not os.path.exists(dst_path): + os.makedirs(dst_path) + + for item in sys.modules.items(): + key, value = item + + if hasattr(value, '__file__') and value.__file__: + src_abspath = os.path.abspath(value.__file__) + + if os.path.commonprefix([home_dir, src_abspath]) == home_dir: + dst_filepath = os.path.join(dst_path, os.path.basename(src_abspath)) + + if os.path.exists(dst_filepath): + split = list(os.path.splitext(dst_filepath)) + split.insert(1, '({})') + filepath = ''.join(split) + post_index = 0 + + while os.path.exists(filepath.format(post_index)): + post_index += 1 + + dst_filepath = filepath.format(post_index) + + shutil.copy(src_abspath, dst_filepath) + + +if __name__ == '__main__': + sys.path.insert(0, sys.path[0] + '\\..') + create_logger(**{ + 'log_config_file': './logging.json', + 'log_file': { + 'prefix': 'all', + 'desc': 'description', + 'filename': 'utils_log' + } + }) + create_logger(**{ + 'log_config_file': './logging.json', + 'log_file': { + 'prefix': 'all', + 'desc': 'description', + 'filename': 'utils_log' + } + }) + + LOG = logging.getLogger('env') + LOG.debug('test') + LOG.fatal('test') + LOG.debug('test') + LOG.fatal('test') + a = LogData() + a.append('train_loss', (1, 2)) + a.append('train_score', 1) + a.append('train_score', 5) + a.append('test_score', [1, 3]) + a.append('test_score', 2, 5) + plt.plot(*a.get('test_score')) + plt.plot(*a.get('train_score')) + plt.grid(True) + plt.legend() + print('end') diff --git a/parco/utils/heuristics.py b/parco/utils/heuristics.py new file mode 100755 index 0000000..b200b17 --- /dev/null +++ b/parco/utils/heuristics.py @@ -0,0 +1,92 @@ +import torch + +from rl4co.utils.ops import gather_by_index + +from parco.models.agent_handlers import RandomAgentHandler + + +class Heuristic: + """Heuristic base class for multi-agent decision making in parallel""" + + def __init__( + self, + norm_p=2, + ): + self.norm_p = norm_p + + def set_dist(self, td): + locs = td["locs"] + self.dmat = torch.cdist(locs, locs, p=self.norm_p) + + def get_action(self, td): + raise NotImplementedError("Implement in subclass") + + def __call__(self, td, env): + actions = [] + while not td["done"].all(): + action = self.get_action(td) + td.set("action", action) + td = env.step(td)["next"] + actions.append(action) + actions = torch.stack(actions, dim=1) # [batch, num decoding steps] + rewards = env.get_reward(td, actions) + return {"reward": rewards, "actions": actions, "td": td} + + +class ParallelRandomInsertionHeuristic(Heuristic): + """Random insertion heuristic for multi-agent decision making in parallel""" + + def __init__(self, *args, agent_handler=RandomAgentHandler(), **kwargs): + self.agent_handler = agent_handler + + def get_action(self, td): + actions = torch.distributions.Categorical(td["action_mask"]).sample() + current_loc_idx = td["current_node"].clone() + actions = self.agent_handler(actions, current_loc_idx, td)[0] # handle conflicts + return actions + + +class ParallelNearestInsertionHeuristic(Heuristic): + """Nearest neighbour heuristic for multi-agent decision making in parallel""" + + def __init__(self, norm_p=2, mode="open"): + self.norm_p = norm_p + assert mode in ["open", "close"], "mode must be either 'open' or 'close'" + self.mode = mode + + def get_action(self, td): + if td["i"][0].item() == 0: + actions = td["current_node"].clone() + return actions + else: + if not hasattr(self, "dmat"): + self.set_dist(td) + if not hasattr(self, "num_agents"): + self.num_agents = td["current_node"].shape[-1] + self.num_locs = td["locs"].shape[-2] + actions = [] + action_mask = td["action_mask"].clone() + + if "available" not in td: + available = td["visited"].clone() + else: + available = td["available"].clone() + + # For loop over agents to avoid collisions + for i in range(self.num_agents): + cur_dist = gather_by_index(self.dmat, td["current_node"][:, i]) + # if available has more dims than cur_dist, then we need to expand cur_dist + if len(available.shape) > len(cur_dist.shape): + cur_dist = cur_dist.unsqueeze(0) + cur_dist[~available] = float("inf") # [batch, num_nodes, num_agents] + if self.mode == "open": + # make sure that the depot is not selected if problem is open + cur_dist[action_mask[:, i, :] is False] = float("inf") + cur_dist[ + torch.arange(cur_dist.shape[0]), td["current_node"][:, i] + ] = float(100000) + action = cur_dist.argmin(dim=-1) + available.scatter_(-1, action.unsqueeze(-1), False) # update action mask + actions.append(action) + + return torch.stack(actions, dim=-1) diff --git a/parco/utils/ops.py b/parco/utils/ops.py new file mode 100644 index 0000000..096100e --- /dev/null +++ b/parco/utils/ops.py @@ -0,0 +1,102 @@ +import torch + +from tensordict import TensorDict + + +def scatter_at_index(src, idx): + """Scatter elements from parco at index idx along specified dim + + Now this function is specific for the multi agent masking, you may + want to create a general function. + + Example: + >>> src: shape [64, 3, 20] # [batch_size, num_agents, num_nodes] + >>> idx: shape [64, 3] # [batch_size, num_agents] + >>> Returns: [64, 3, 20] + """ + idx_ = torch.repeat_interleave(idx.unsqueeze(-2), dim=-2, repeats=src.shape[-2]) + return src.scatter(-1, idx_, 0) + + +def pad_tours(data): + # Determine the maximum length from all the lists + max_len = max(len(lst) for lst in data.values()) + + # Pad each list to match the maximum length + for key, value in data.items(): + data[key] = value + [0] * (max_len - len(value)) + + # Make tensor + tours = torch.tensor(list(data.values())) + return tours + + +def pad_actions(tensors): + # Determine the maximum length from all tensors + max_len = max(t.size(1) for t in tensors) + # Pad each tensor to match the maximum length + padded_tensors = [] + for t in tensors: + if t.size(1) < max_len: + pad_size = max_len - t.size(1) + pad = torch.zeros(t.size(0), pad_size).long() + padded_t = torch.cat([t, pad], dim=-1) + else: + padded_t = t + padded_tensors.append(padded_t) + return torch.stack(padded_tensors) + + +def rollout(instances, actions, env, num_agents, preprocess_actions=True, verbose=True): + assert env is not None, "Environment must be provided" + + if env.name == "mpdp": + depots = instances["depots"] + locs = instances["locs"] + diff = num_agents - 1 + else: + depots = instances[:, 0:1] + locs = instances[:, 1:] + diff = num_agents - 2 + + td = TensorDict( + { + "depots": depots, + "locs": locs, + "num_agents": torch.tensor([num_agents] * locs.shape[0]), + }, + batch_size=[locs.shape[0]], + ) + + td_init = env.reset(td) + + if preprocess_actions: + # Make actions as follows: add to all numbers except 0 the number of agents + actions_md = torch.where(actions > 0, actions + diff, actions) + else: + actions_md = actions + + # Rollout through the environment + td_init_test = td_init.clone() + next_td = td_init_test + with torch.no_grad(): + # take actions from the last dimension + for i in range(actions_md.shape[-1]): + cur_a = actions_md[:, :, i] + next_td.set("action", cur_a) + next_td = env.step(next_td)["next"] + + # Plotting + # env.render(td_init_test, actions_md, plot_number=True) + reward = env.get_reward(next_td, actions_md) + if verbose: + print(f"Average reward: {reward.mean()}") + # return instances, actions, actions_md, reward, next_td + return { + "instances": instances, + "actions": actions, + "actions_md": actions_md, + "reward": reward, + "td": next_td, + "td_init": td_init, + } diff --git a/parco/utils/plot.py b/parco/utils/plot.py new file mode 100644 index 0000000..48133a6 --- /dev/null +++ b/parco/utils/plot.py @@ -0,0 +1,70 @@ +import matplotlib.pyplot as plt +import numpy as np + +from matplotlib import cm + + +def actions_table(actions, num_agent, num_city): + """Visualize the actions in a table + Args: + actions: (num_agent, num_step) + num_agent: int + num_city: int + """ + actions_reshape = actions.reshape(num_agent, -1) + _, num_step = actions_reshape.shape + action_table = np.zeros((num_city, num_step)) + + # Plot + _, ax = plt.subplots(1, 1, figsize=(int(num_step / 2), int(num_city / 2))) + back_to_depot_list = np.zeros(num_agent) + for step_idx in range(num_step): + for agent_idx in range(num_agent): + pd_flag = 0 # Flag for pickup or delivery + if actions_reshape[agent_idx, step_idx] > 10: + item_idx = actions_reshape[agent_idx, step_idx] - 10 + pd_flag = 2 + else: + item_idx = actions_reshape[agent_idx, step_idx] + pd_flag = 1 + action_table[item_idx, step_idx:] = pd_flag + + # Not text in depot + if item_idx == 0: + back_to_depot_list[agent_idx] = 1 + else: + ax.text( + step_idx, + item_idx, + f"A{agent_idx}", + ha="center", + va="center", + color=cm.Set3(agent_idx), + ) + + # Text the number of agents back to depot in the depot + ax.text( + step_idx, + 0, + f"{int(sum(back_to_depot_list))}", + ha="center", + va="center", + color="white", + ) + + action_table[0, :] = 2 + ax.matshow(action_table, cmap=plt.cm.Greys) + + ax.set_xticks(range(num_step)) + ax.set_xticklabels(np.array(range(num_step)) + 1) + ax.xaxis.tick_bottom() + + ytick_lable_list = np.array(range(num_city)) + ytick_lable_list = ["D"] + list(ytick_lable_list[1:]) + ax.set_yticks(range(num_city)) + ax.set_yticklabels(ytick_lable_list) + + ax.set_xlabel("Step") + ax.set_ylabel("Item") + + plt.tight_layout() diff --git a/pyproject.toml b/pyproject.toml new file mode 100755 index 0000000..7264090 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,69 @@ +[tool.poetry] +name = "parco" +version = "0.1.0" +description = "PARCO: Learning Parallel Autoregressive Policies for Efficient Multi-Agent Combinatorial Optimization" +authors = [ + "Federico Berto ", + "Chuanbo Hua ", + "Laurin Luttmann ", + "Jiwoo Son", + "Junyoung Park", + "Kyuree Ahn", + "Changhyun Kwon", + "Lin Xie", + "Jinkyoo Park", +] +license = "MIT" +packages = [{ include = "parco" }] + +[tool.poetry.dependencies] +rl4co = {version = ">=0.5.0", extras = ["dev"]} + +[tool.black] +line-length = 90 +target-version = ["py311"] +include = '\.pyi?$' +exclude = ''' +( + /( + \.direnv + | \.eggs + | \.git + | \.tox + | \.venv + | _build + | build + | dist + | venv + )/ +) +''' + +[tool.ruff] +select = ["F", "E", "W", "I001"] +line-length = 90 +show-fixes = false +target-version = "py311" +task-tags = ["TODO", "FIXME"] +ignore = ["E501"] # never enforce `E501` (line length violations), done in Black + +[tool.ruff.per-file-ignores] +"__init__.py" = ["E402", "F401"] + +[tool.ruff.isort] +known-first-party = [] +known-third-party = [] +section-order = [ + "future", + "standard-library", + "third-party", + "first-party", + "local-folder", +] +combine-as-imports = true +split-on-trailing-comma = false +lines-between-types = 1 + +[build-system] +requires = ["poetry"] +build-backend = "poetry.core.masonry.api" \ No newline at end of file diff --git a/test.py b/test.py new file mode 100644 index 0000000..2d27dd2 --- /dev/null +++ b/test.py @@ -0,0 +1,124 @@ +import argparse +import os +import time +import warnings + +import torch + +from rl4co.data.utils import load_npz_to_tensordict +from tqdm.auto import tqdm + +from parco.models import PARCORLModule +from parco.tasks.eval import get_dataloader + +warnings.filterwarnings("ignore", category=FutureWarning) + +# Tricks for faster inference +try: + torch._C._jit_set_profiling_executor(False) + torch._C._jit_set_profiling_mode(False) +except AttributeError: + pass +torch.set_float32_matmul_precision("medium") + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument( + "--problem", type=str, default="hcvrp", help="Problem name: hcvrp, omdcpdp, etc." + ) + parser.add_argument( + "--datasets", + help="Filename of the dataset(s) to evaluate. Defaults to all under data/{problem}/ dir", + default=None, + ) + parser.add_argument( + "--decode_type", + type=str, + default="greedy", + help="Decoding type. Available: greedy, sampling", + ) + parser.add_argument( + "--sample_size", + type=int, + default=1, + help="Number of samples to use for sampling decoding", + ) + parser.add_argument("--batch_size", type=int, default=128) + parser.add_argument("--checkpoint", type=str, default=None) + parser.add_argument("--device", type=str, default="cuda") + + # Use load_from_checkpoint with map_location, which is handled internally by Lightning + # Suppress FutureWarnings related to torch.load and weights_only + warnings.filterwarnings("ignore", message=".*weights_only.*", category=FutureWarning) + + opts = parser.parse_args() + + batch_size = opts.batch_size + sample_size = opts.sample_size + decode_type = opts.decode_type + checkpoint_path = opts.checkpoint + problem = opts.problem + if "cuda" in opts.device and torch.cuda.is_available(): + device = torch.device("cuda:0") + else: + device = torch.device("cpu") + if checkpoint_path is None: + assert ( + problem is not None + ), "Problem must be specified if checkpoint is not provided" + checkpoint_path = f"./checkpoints/{problem}/parco.ckpt" + if decode_type == "greedy": + assert sample_size == 1 + if opts.datasets is None: + assert problem is not None, "Problem must be specified if dataset is not provided" + data_paths = [f"./data/{problem}/{f}" for f in os.listdir(f"./data/{problem}")] + else: + data_paths = [opts.datasets] if isinstance(opts.datasets, str) else opts.datasets + data_paths = sorted(data_paths) # Sort for consistency + + # Load the checkpoint as usual + print("Loading checkpoint from ", checkpoint_path) + model = PARCORLModule.load_from_checkpoint( + checkpoint_path, map_location="cpu", strict=False + ) + env = model.env + policy = model.policy.to(device).eval() # Use mixed precision if supported + + for dataset in data_paths: + tour_lengths = [] + inference_times = [] + eval_steps = [] + + print(f"Loading {dataset}") + td_test = load_npz_to_tensordict(dataset) + dataloader = get_dataloader(td_test, batch_size=batch_size) + + with torch.cuda.amp.autocast() if "cuda" in opts.device else torch.inference_mode(): # Use mixed precision if supported + with torch.inference_mode(): + for td_test_batch in tqdm(dataloader): + td_reset = env.reset(td_test_batch).to(device) + start_time = time.time() + out = policy( + td_reset, + env, + decode_type=decode_type, + num_samples=sample_size, + return_actions=False, + ) + end_time = time.time() + inference_time = end_time - start_time + if decode_type == "greedy": + tour_lengths.append(-out["reward"].mean().item()) + else: + tour_lengths.extend( + -out["reward"].reshape(-1, sample_size).max(dim=-1)[0] + ) + inference_times.append(inference_time) + eval_steps.append(out["steps"]) + + print(f"Average tour length: {sum(tour_lengths)/len(tour_lengths):.4f}") + print( + f"Per step inference time: {sum(inference_times)/len(inference_times):.4f}s" + ) + print(f"Total inference time: {sum(inference_times):.4f}s") + print(f"Average eval steps: {sum(eval_steps)/len(eval_steps):.2f}") diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test.py b/tests/test.py new file mode 100644 index 0000000..b6c78a4 --- /dev/null +++ b/tests/test.py @@ -0,0 +1,27 @@ +import pytest +import torch +from parco.envs import HCVRPEnv, OMDCPDPEnv, FFSPEnv +from parco.models import PARCOPolicy as PARCOPolicyRouting +from parco.models import PARCOMultiStagePolicy + + +@pytest.mark.parametrize("env_class", [HCVRPEnv, OMDCPDPEnv]) +def test_parco_routing(env_class): + env = env_class(generator_params={"num_loc":20, "num_agents":3}) + td_test_data = env.generator(batch_size=[2]) + td_init = env.reset(td_test_data.clone()) + td_init_test = td_init.clone() + policy = PARCOPolicyRouting(env_name=env.name) + out = policy(td_init_test.clone(), env) + assert out["reward"].shape == (2,) + + +def test_parco_scheduling(): + num_machine, num_stage = 3, 4 + env = FFSPEnv(generator_params={"num_machine":num_machine, "num_stage":num_stage}) + td_test_data = env.generator(batch_size=[2]) + td_init = env.reset(td_test_data.clone()) + td_init_test = td_init.clone() + parco = PARCOMultiStagePolicy(env_name=env.name, init_embedding_kwargs={"one_hot_seed_cnt":num_machine}, num_stages=num_stage) + out = parco(td_init_test.clone(), env=env) + assert out["reward"].shape == (2,) diff --git a/train.py b/train.py new file mode 100644 index 0000000..b272953 --- /dev/null +++ b/train.py @@ -0,0 +1,116 @@ +from typing import List, Optional, Tuple + +import hydra +import lightning as L +import pyrootutils +import torch + +from lightning import Callback, LightningModule +from lightning.pytorch.loggers import Logger +from omegaconf import DictConfig +from rl4co import utils +from rl4co.utils import RL4COTrainer + +pyrootutils.setup_root(__file__, indicator=".gitignore", pythonpath=True) + + +log = utils.get_pylogger(__name__) + + +@utils.task_wrapper +def run(cfg: DictConfig) -> Tuple[dict, dict]: + """Trains the model. Can additionally evaluate on a testset, using best weights obtained during + training. + This method is wrapped in optional @task_wrapper decorator, that controls the behavior during + failure. Useful for multiruns, saving info about the crash, etc. + + Args: + cfg (DictConfig): Configuration composed by Hydra. + Returns: + Tuple[dict, dict]: Dict with metrics and dict with all instantiated objects. + """ + + # set seed for random number generators in pytorch, numpy and python.random + if cfg.get("seed"): + L.seed_everything(cfg.seed, workers=True) + + # We instantiate the environment separately and then pass it to the model + log.info(f"Instantiating environment <{cfg.env._target_}>") + env = hydra.utils.instantiate(cfg.env) + + # Note that the RL environment is instantiated inside the model + log.info(f"Instantiating model <{cfg.model._target_}>") + model: LightningModule = hydra.utils.instantiate(cfg.model, env) + + log.info("Instantiating callbacks...") + callbacks: List[Callback] = utils.instantiate_callbacks(cfg.get("callbacks")) + + log.info("Instantiating loggers...") + logger: List[Logger] = utils.instantiate_loggers(cfg.get("logger"), model) + + log.info("Instantiating trainer...") + trainer: RL4COTrainer = hydra.utils.instantiate( + cfg.trainer, + callbacks=callbacks, + logger=logger, + ) + + object_dict = { + "cfg": cfg, + "model": model, + "callbacks": callbacks, + "logger": logger, + "trainer": trainer, + } + + if logger: + log.info("Logging hyperparameters!") + utils.log_hyperparameters(object_dict) + + if cfg.get("compile", False): + log.info("Compiling model!") + model = torch.compile(model) + + if cfg.get("train"): + log.info("Starting training!") + trainer.fit(model=model, ckpt_path=cfg.get("ckpt_path")) + + train_metrics = trainer.callback_metrics + + if cfg.get("test"): + log.info("Starting testing!") + ckpt_path = trainer.checkpoint_callback.best_model_path + if ckpt_path == "": + log.warning("Best ckpt not found! Using current weights for testing...") + ckpt_path = None + trainer.test(model=model, ckpt_path=ckpt_path) + log.info(f"Best ckpt path: {ckpt_path}") + + test_metrics = trainer.callback_metrics + + # merge train and test metrics + metric_dict = {**train_metrics, **test_metrics} + + return metric_dict, object_dict + + +@hydra.main(version_base="1.3", config_path="configs", config_name="main.yaml") +def train(cfg: DictConfig) -> Optional[float]: + # apply extra utilities + # (e.g. ask for tags if none are provided in cfg, print cfg tree, etc.) + utils.extras(cfg) + + # train the model + metric_dict, _ = run(cfg) + + # safely retrieve metric value for hydra-based hyperparameter optimization + metric_value = utils.get_metric_value( + metric_dict=metric_dict, metric_name=cfg.get("optimized_metric") + ) + + # return optimized metric + return metric_value + + +if __name__ == "__main__": + train()