From 5cc0c9c207452b8e30f26842c23894a376336b84 Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 3 Feb 2022 10:59:15 +0100 Subject: [PATCH 01/21] add eo-crops --- eo-crops | 1 + 1 file changed, 1 insertion(+) create mode 160000 eo-crops diff --git a/eo-crops b/eo-crops new file mode 160000 index 0000000..5412cc9 --- /dev/null +++ b/eo-crops @@ -0,0 +1 @@ +Subproject commit 5412cc9e1b66c782514d3ae400f310ce0a9e7b50 From 1fa9df3b91ab91f0f428a8efd841fca3377bbef9 Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 3 Feb 2022 12:15:06 +0100 Subject: [PATCH 02/21] add eo-crops --- eo-crops | 1 - eo-flow/.gitignore | 17 + eo-flow/LICENSE | 23 + eo-flow/MODELS.md | 40 ++ eo-flow/README.md | 74 ++ eo-flow/checkpoint | 2 + eo-flow/configs/example.json | 29 + eo-flow/configs/example_val.json | 38 + eo-flow/configs/fcn_example.json | 43 ++ eo-flow/configs/tfcn_example.json | 44 ++ eo-flow/configs/tfcn_example_real_eval.json | 50 ++ eo-flow/configs/tfcn_example_real_pred.json | 50 ++ eo-flow/configs/tfcn_example_real_train.json | 58 ++ .../tfcn_example_real_train_and_eval.json | 78 +++ eo-flow/eoflow/__init__.py | 1 + eo-flow/eoflow/base/__init__.py | 5 + eo-flow/eoflow/base/base_custom_training.py | 141 ++++ eo-flow/eoflow/base/base_input.py | 8 + eo-flow/eoflow/base/base_task.py | 28 + eo-flow/eoflow/base/base_training.py | 157 +++++ eo-flow/eoflow/base/configuration.py | 74 ++ eo-flow/eoflow/execute.py | 47 ++ eo-flow/eoflow/input/__init__.py | 0 eo-flow/eoflow/input/eopatch.py | 117 ++++ eo-flow/eoflow/input/hdf5.py | 44 ++ eo-flow/eoflow/input/numpy.py | 102 +++ eo-flow/eoflow/input/operations.py | 210 ++++++ eo-flow/eoflow/input/random.py | 76 ++ eo-flow/eoflow/models/__init__.py | 4 + eo-flow/eoflow/models/callbacks.py | 91 +++ eo-flow/eoflow/models/embeddings.py | 29 + eo-flow/eoflow/models/layers.py | 407 +++++++++++ eo-flow/eoflow/models/losses.py | 234 +++++++ eo-flow/eoflow/models/metrics.py | 335 +++++++++ eo-flow/eoflow/models/pse_tae_layers.py | 176 +++++ .../models/segmentation_task/__init__.py | 0 .../segmentation_task/segmentation_base.py | 164 +++++ .../segmentation_task/segmentation_unets.py | 651 +++++++++++++++++ .../eoflow/models/tempnets_task/__init__.py | 0 .../models/tempnets_task/cnn_tempnets.py | 349 +++++++++ .../models/tempnets_task/mlp_tempnets.py | 182 +++++ .../models/tempnets_task/rnn_tempnets.py | 232 ++++++ .../models/tempnets_task/tempnets_base.py | 173 +++++ .../models/transformer_encoder_layers.py | 193 +++++ eo-flow/eoflow/tasks/__init__.py | 3 + eo-flow/eoflow/tasks/evaluate.py | 28 + eo-flow/eoflow/tasks/predict.py | 21 + eo-flow/eoflow/tasks/train.py | 61 ++ eo-flow/eoflow/utils/__init__.py | 2 + eo-flow/eoflow/utils/tf_utils.py | 21 + eo-flow/eoflow/utils/utils.py | 34 + eo-flow/examples/exporting_data.ipynb | 196 ++++++ eo-flow/examples/input.py | 122 ++++ eo-flow/examples/models.py | 39 ++ .../examples/notebook_classification.ipynb | 662 ++++++++++++++++++ eo-flow/examples/pretraining.py | 0 eo-flow/examples/remove_file.py | 11 + eo-flow/examples/test_cnns.py | 105 +++ eo-flow/figures/fcn-architecture.png | Bin 0 -> 148643 bytes eo-flow/figures/rfcn-architecture.png | Bin 0 -> 172044 bytes eo-flow/figures/tfcn-architecture.png | Bin 0 -> 174574 bytes eo-flow/requirements-dev.txt | 4 + eo-flow/requirements.txt | 8 + eo-flow/setup.py | 29 + eo-flow/tests/test_layers.py | 47 ++ eo-flow/tests/test_losses.py | 115 +++ eo-flow/tests/test_metrics.py | 239 +++++++ 67 files changed, 6523 insertions(+), 1 deletion(-) delete mode 160000 eo-crops create mode 100644 eo-flow/.gitignore create mode 100644 eo-flow/LICENSE create mode 100644 eo-flow/MODELS.md create mode 100644 eo-flow/README.md create mode 100644 eo-flow/checkpoint create mode 100644 eo-flow/configs/example.json create mode 100644 eo-flow/configs/example_val.json create mode 100644 eo-flow/configs/fcn_example.json create mode 100644 eo-flow/configs/tfcn_example.json create mode 100644 eo-flow/configs/tfcn_example_real_eval.json create mode 100644 eo-flow/configs/tfcn_example_real_pred.json create mode 100644 eo-flow/configs/tfcn_example_real_train.json create mode 100644 eo-flow/configs/tfcn_example_real_train_and_eval.json create mode 100644 eo-flow/eoflow/__init__.py create mode 100644 eo-flow/eoflow/base/__init__.py create mode 100644 eo-flow/eoflow/base/base_custom_training.py create mode 100644 eo-flow/eoflow/base/base_input.py create mode 100644 eo-flow/eoflow/base/base_task.py create mode 100644 eo-flow/eoflow/base/base_training.py create mode 100644 eo-flow/eoflow/base/configuration.py create mode 100644 eo-flow/eoflow/execute.py create mode 100644 eo-flow/eoflow/input/__init__.py create mode 100644 eo-flow/eoflow/input/eopatch.py create mode 100644 eo-flow/eoflow/input/hdf5.py create mode 100644 eo-flow/eoflow/input/numpy.py create mode 100644 eo-flow/eoflow/input/operations.py create mode 100644 eo-flow/eoflow/input/random.py create mode 100644 eo-flow/eoflow/models/__init__.py create mode 100644 eo-flow/eoflow/models/callbacks.py create mode 100644 eo-flow/eoflow/models/embeddings.py create mode 100644 eo-flow/eoflow/models/layers.py create mode 100644 eo-flow/eoflow/models/losses.py create mode 100644 eo-flow/eoflow/models/metrics.py create mode 100644 eo-flow/eoflow/models/pse_tae_layers.py create mode 100644 eo-flow/eoflow/models/segmentation_task/__init__.py create mode 100644 eo-flow/eoflow/models/segmentation_task/segmentation_base.py create mode 100644 eo-flow/eoflow/models/segmentation_task/segmentation_unets.py create mode 100644 eo-flow/eoflow/models/tempnets_task/__init__.py create mode 100644 eo-flow/eoflow/models/tempnets_task/cnn_tempnets.py create mode 100644 eo-flow/eoflow/models/tempnets_task/mlp_tempnets.py create mode 100644 eo-flow/eoflow/models/tempnets_task/rnn_tempnets.py create mode 100644 eo-flow/eoflow/models/tempnets_task/tempnets_base.py create mode 100644 eo-flow/eoflow/models/transformer_encoder_layers.py create mode 100644 eo-flow/eoflow/tasks/__init__.py create mode 100644 eo-flow/eoflow/tasks/evaluate.py create mode 100644 eo-flow/eoflow/tasks/predict.py create mode 100644 eo-flow/eoflow/tasks/train.py create mode 100644 eo-flow/eoflow/utils/__init__.py create mode 100644 eo-flow/eoflow/utils/tf_utils.py create mode 100644 eo-flow/eoflow/utils/utils.py create mode 100644 eo-flow/examples/exporting_data.ipynb create mode 100644 eo-flow/examples/input.py create mode 100644 eo-flow/examples/models.py create mode 100644 eo-flow/examples/notebook_classification.ipynb create mode 100644 eo-flow/examples/pretraining.py create mode 100644 eo-flow/examples/remove_file.py create mode 100644 eo-flow/examples/test_cnns.py create mode 100644 eo-flow/figures/fcn-architecture.png create mode 100644 eo-flow/figures/rfcn-architecture.png create mode 100644 eo-flow/figures/tfcn-architecture.png create mode 100644 eo-flow/requirements-dev.txt create mode 100644 eo-flow/requirements.txt create mode 100644 eo-flow/setup.py create mode 100644 eo-flow/tests/test_layers.py create mode 100644 eo-flow/tests/test_losses.py create mode 100644 eo-flow/tests/test_metrics.py diff --git a/eo-crops b/eo-crops deleted file mode 160000 index 5412cc9..0000000 --- a/eo-crops +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 5412cc9e1b66c782514d3ae400f310ce0a9e7b50 diff --git a/eo-flow/.gitignore b/eo-flow/.gitignore new file mode 100644 index 0000000..de40ef9 --- /dev/null +++ b/eo-flow/.gitignore @@ -0,0 +1,17 @@ +# pyc files +*.pyc + +# VS files +.vscode/ + +# temp output folder +temp/ + +# pycharm files +.idea/ + +# egg folder +*.egg-info/ + +# Jupyter checkpoints +.ipynb_checkpoints \ No newline at end of file diff --git a/eo-flow/LICENSE b/eo-flow/LICENSE new file mode 100644 index 0000000..3664919 --- /dev/null +++ b/eo-flow/LICENSE @@ -0,0 +1,23 @@ + +MIT License + +Copyright (c) 2017-2020 Matej Aleksandrov, Matej Batič, Matic Lubej, Grega Milčinski (Sinergise) +Copyright (c) 2017-2020 Devis Peressutti, Jernej Puc, Anže Zupanc, Lojze Žust, Jovan Višnjić (Sinergise) + +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. diff --git a/eo-flow/MODELS.md b/eo-flow/MODELS.md new file mode 100644 index 0000000..21fe27b --- /dev/null +++ b/eo-flow/MODELS.md @@ -0,0 +1,40 @@ +# Models + +## Fully-Convolutional-Network (FCN) + +The vanilla architecture as in the following figure is implemented. Convolutions are run along spatial dimensions of input tensor, which is supposed to have `[M, H, W, D]` shape, where M is the mini-batch size, and H, W and D are the height, width and number of bands (i.e. depth) of the input image tensor. The 2d convolutions perform a `VALID` convolution, therefore the output tensor size is smaller than the input size. + +![FCN](./figures/fcn-architecture.png "FCN") + +An example training script is provided. To run it execute the `configs/fcn_example.json` configuration: +``` +python -m eoflow.execute configs/fcn_example.json +``` + +The example configuration can be used as a base to run your own experiments. + +## Temporal Fully-Convolutional-Network (TFCN) + +Similarly to the RFCN, the TFCN works with time-series of input shape `[M, T, H, W, D]`. This network performs 3d convolutions along the tempo-spatial dimensions, i.e. the convolutional kernels are 3d `k x k x k`. As default, the temporal dimension is not pooled. For temporal pooling, enough time-frames need to be available in the input tensors. At the bottom of the TFCN and along the skip connections, a 1d convolution along the temporal dimension is performed to linearly combine the temporal features. The resulting tensors are 4d of shape `[M, H, W, D]`. The decoding path is as in FCN. + +![TFCN](./figures/tfcn-architecture.png "TFCN") + +An example training script is provided. To run it execute the `configs/tfcn_example.json` configuration: +``` +python -m eoflow.execute configs/tfcn_example.json +``` + +The example configuration can be used as a base to run your own experiments. + +## Recurrent Fully-Convolutional-Network (RFCN) + +A recurrent version of the **FCN** is implemented as in below figure. The input tensor in this case is 5d with shape `[M, T, H, W, D]`, where `T` is the number of temporal acquisitions. As for the FCN, the 2d convolutions operate along the `H` and `W` dimensions. The recurrent layers are applied along the skip connections and the bottom layers to model the temporal relationship between the features extracted by the 2d convolutions. The output of the recurrent layers is a 4d tensor of shape `[M, H, W, D]` (the height, width and depth of the tensors will vary along the network). The decoding path is as in **FCN**. The 2d convolutions perform a `VALID` convolution, therefore the output tensor size is smaller than the input size. + +![RFCN](./figures/rfcn-architecture.png "RFCN") + +An example training script is provided. To run it execute the `configs/rfcn_example.json` configuration: +``` +python -m eoflow.execute configs/rfcn_example.json +``` + +The example configuration can be used as a base to run your own experiments. diff --git a/eo-flow/README.md b/eo-flow/README.md new file mode 100644 index 0000000..fa47fec --- /dev/null +++ b/eo-flow/README.md @@ -0,0 +1,74 @@ +# EOFlow + +This repository provides code and examples for creation of Earth Observation (EO) projects using TensorFlow. The code uses TensorFlow 2.0 with Keras as the main model building API. + +Common model architectures, layers, and input methods for EO tasks are provided in the package `eoflow`. Custom models and input methods can also be implemented building on top of the provided abstract classes. This package aims at seamlessly integrate with [`eo-learn`](https://github.com/sentinel-hub/eo-learn), and favours both creation of models for prototypying as well as production of EO applications. + +Architectures and examples for land cover and crop classification using time-series derived from satellite images are provided. + +## Installation + +The package can be installed by running the following command. +``` +$ pip install git+https://github.com/sentinel-hub/eo-flow +``` + +You can also install the package from source. Clone the repository and run the following command in the root directory of the project. +``` +$ pip install . +``` + +## Getting started + +The `eoflow` package can be used in two ways. For best control over the workflow and faster prototyping, the package can be used programmatically (in code). The [example notebook](examples/notebook.ipynb) should help you get started with that. It demonstrates how to prepare a dataset pipeline, train the model, evaluate the model and make predictions using the trained model. + +An alternate way of using `eoflow` is by writing configuration `json` files and running them using `eoflow`'s execute script. Configuration files specify and configure the task (training, evaluation, etc.) and contain the configurations of the model and input methods. Example configurations are provided in the `configs` directory. Once a configuration file is created it can be run using the execute command. + +A simple example can be run using the following command. More advanced configurations are also provided. +``` +$ python -m eoflow.execute configs/example.json +``` + +This will create an output folder `temp/experiment` containing the tensorboard logs and model checkpoints. + +To visualize the logs in TensorBoard, run +``` +$ tensorboard --logdir=temp/experiment +``` + +## Writing custom code + +To get started with writing custom models and input methods for `eoflow` take a look at the example implementations ([`examples` folder](examples/)). Custom classes use schemas to define the configuration parameters in order to work with the execute script and configuration files. Since eoflow builds on top of TF2 and Keras, model building is very similar. + +## Package structure + +The subpackages of `eoflow` are as follows: +* `base`: this directory contains the abstract classes to build models, inputs and tasks. Any useful abstract class should go in this folder. +* `models`: classes implementing the TF models (e.g. Fully-Convolutional-Network, GANs, seq2seq, ...). These classes inherit and implement the `BaseModel` abstract class. The module also contains custom losses, metrics and layers. +* `tasks`: classes handling the configurable actions that can be applied to each TF model, when using the execute script. These actions may include training, inference, exporting the model, validation, etc. The tasks inherit the `BaseTask` abstract class. +* `input`: building blocks and helper methods for loading the input data (EOPatch, numpy arrays, etc.) into a tensoflow Dataset and applying different transformations (data augmentation, patch extraction) +* `utils`: collection of utility functions + +### Examples and scripts + +Project also contains other folders: +* `configs`: folder containing example configurations for different models. Config parameters are stored in .json files. Results of an experiment should be reproducible by re-running the same config file. Config files specify the whole workflow (model, task, data input if required). +* `examples`: folder containing example implementations of custom models and input functions. Also contains a jupyter notebook example. + +## Implemented architectures + +Segmentation models for land cover semantic segmentation: +* **Fully-Convolutional-Network (FCN, a.k.a. U-net)**, vanilla implementation of method described in this [paper](https://arxiv.org/abs/1505.04597). This network expects 2D MSI images as inputs and predicts 2D label maps as output. +* **Temporal FCN**, where the whole time-series is considered as a 3D MSI volume and convolutions are performed along the temporal dimension as well spatial dimension. The output of the network is a 2D label map as in previous cases. More details can be found in this [paper](https://www.researchgate.net/publication/333262625_Spatio-Temporal_Deep_Learning_An_Application_to_Land_Cover_Classification). +* **ResUNet-a**, architecture proposed in Diakogiannis et al. ["ResUNet-a: A deep learning framework for semantic segmetnation of remotely sensed data"](https://www.sciencedirect.com/science/article/abs/pii/S0924271620300149). Original `mxnet` implementation can be found [here](https://github.com/feevos/resuneta). + +Classification models for crop classification using time-series: +* **TCN**: Implementation of the TCN network taken from the [keras-TCN implementation by Philippe Remy](https://github.com/philipperemy/keras-tcn). +* **TempCNN**: Implementation of the TempCNN network taken from the [temporalCNN implementation of Charlotte Pelletier](https://github.com/charlotte-pel/temporalCNN). +* **Recurrent NN**: Implementation of (bidirectional) Recurrent Neural Networks for the classification of time-series. Implementation allows to use either `SimpleRNN`, `GRU` or `LSTM` layers as building blocks of the architecture. +* **TransformerEncoder**: Implementation of a time-series classification architecture based on [self-attention](https://arxiv.org/abs/1706.03762) layers. This implementation follows [this PyTorch implementation of Marc Russwurm](https://github.com/MarcCoru/crop-type-mapping). +* **PSE+TAE**: Implementation of the Pixel-Set Encoder and temporal Self-attention proposed in Garnot V. _et al._ +["Satellite Image Time Series Classification with Pixel-Set Encoders and Temporal Self-Attention"](https://hal.archives-ouvertes.fr/hal-02879223/document). +This implementation is adapted from the [Pytorch version](https://github.com/VSainteuf/pytorch-psetae). + +Descriptions and examples of semantic segmentation architectures are available [here](MODELS.md). diff --git a/eo-flow/checkpoint b/eo-flow/checkpoint new file mode 100644 index 0000000..a6e034f --- /dev/null +++ b/eo-flow/checkpoint @@ -0,0 +1,2 @@ +model_checkpoint_path: "model" +all_model_checkpoint_paths: "model" diff --git a/eo-flow/configs/example.json b/eo-flow/configs/example.json new file mode 100644 index 0000000..22f4046 --- /dev/null +++ b/eo-flow/configs/example.json @@ -0,0 +1,29 @@ +{ + "model": { + "classname": "examples.models.ExampleModel", + "config": { + "output_size": 10, + "hidden_units": 256, + "learning_rate": 0.001 + } + }, + "task": { + "classname": "eoflow.tasks.TrainTask", + "config": { + "num_epochs": 10, + "model_directory": "./temp/experiment", + "input_config":{ + "classname": "examples.input.ExampleInput", + "config": { + "input_shape": [512], + "num_classes": 10, + "batch_size": 20, + "batches_per_epoch": 200 + } + }, + "iterations_per_epoch": 200, + "save_steps": 400, + "summary_steps": 50 + } + } + } diff --git a/eo-flow/configs/example_val.json b/eo-flow/configs/example_val.json new file mode 100644 index 0000000..a4e5f3f --- /dev/null +++ b/eo-flow/configs/example_val.json @@ -0,0 +1,38 @@ +{ + "model": { + "classname": "examples.models.ExampleModel", + "config": { + "output_size": 10, + "hidden_units": 256, + "learning_rate": 0.01 + } + }, + "task": { + "classname": "eoflow.tasks.TrainAndEvaluateTask", + "config": { + "num_epochs": 10, + "iterations_per_epoch": 1000, + "model_directory": "./temp/experiment", + "train_input_config":{ + "classname": "examples.input.ExampleInput", + "config": { + "input_shape": [512], + "num_classes": 10, + "batch_size": 20, + "batches_per_epoch": 200 + } + }, + "val_input_config":{ + "classname": "examples.input.ExampleInput", + "config": { + "input_shape": [512], + "num_classes": 10, + "batch_size": 1, + "batches_per_epoch": 200 + } + }, + "save_steps": 400, + "summary_steps": 50 + } + } + } diff --git a/eo-flow/configs/fcn_example.json b/eo-flow/configs/fcn_example.json new file mode 100644 index 0000000..cfb86cf --- /dev/null +++ b/eo-flow/configs/fcn_example.json @@ -0,0 +1,43 @@ +{ + "model": { + "classname": "eoflow.models.FCNModel", + "config": { + "learning_rate": 0.0001, + "n_layers": 3, + "n_classes": 3, + "keep_prob": 0.8, + "features_root": 32, + "conv_size": 3, + "conv_stride": 1, + "deconv_size": 2, + "add_dropout": true, + "add_batch_norm": false, + "bias_init": 0.0, + "padding": "VALID", + "pool_size": 2, + "pool_stride": 2, + "loss": "focal_loss", + "metrics": ["accuracy"] + } + }, + "task": { + "classname": "eoflow.tasks.TrainTask", + "config": { + "num_epochs": 2, + "model_directory": "./temp/experiment_fcn", + "input_config":{ + "classname": "eoflow.input.random.RandomSegmentationInput", + "config": { + "input_shape": [128, 128, 13], + "output_shape": [128, 128], + "num_classes": 3, + "batch_size": 2, + "batches_per_epoch": 200 + } + }, + "iterations_per_epoch": 50, + "save_steps": 100, + "summary_steps": 50 + } + } + } diff --git a/eo-flow/configs/tfcn_example.json b/eo-flow/configs/tfcn_example.json new file mode 100644 index 0000000..94f497d --- /dev/null +++ b/eo-flow/configs/tfcn_example.json @@ -0,0 +1,44 @@ +{ + "model": { + "classname": "eoflow.models.TFCNModel", + "config": { + "learning_rate": 0.0001, + "n_layers": 3, + "n_classes": 2, + "keep_prob": 0.8, + "features_root": 16, + "conv_size": 3, + "conv_stride": 1, + "deconv_size": 2, + "add_dropout": true, + "add_batch_norm": false, + "bias_init": 0.0, + "padding": "VALID", + "pool_size": 2, + "pool_stride": 2, + "pool_time": false, + "single_encoding_conv": true, + "conv_size_reduce": 3, + "loss": "cross_entropy" + } + }, + "task": { + "classname": "eoflow.tasks.TrainTask", + "config": { + "num_epochs": 2, + "model_directory": "./temp/experiment_tfcn", + "input_config":{ + "classname": "eoflow.input.random.RandomSegmentationInput", + "config": { + "input_shape": [10, 128, 128, 13], + "output_shape": [128, 128], + "num_classes": 2, + "batch_size": 1, + "batches_per_epoch": 100 + } + }, + "save_steps": 100, + "summary_steps": 50 + } + } + } diff --git a/eo-flow/configs/tfcn_example_real_eval.json b/eo-flow/configs/tfcn_example_real_eval.json new file mode 100644 index 0000000..f7ae912 --- /dev/null +++ b/eo-flow/configs/tfcn_example_real_eval.json @@ -0,0 +1,50 @@ +{ + "model": { + "classname": "eoflow.models.TFCNModel", + "config": { + "learning_rate": 0.0001, + "n_layers": 3, + "n_classes": 10, + "keep_prob": 0.8, + "features_root": 16, + "conv_size": 3, + "conv_stride": 1, + "deconv_size": 2, + "add_dropout": true, + "add_batch_norm": false, + "bias_init": 0.0, + "padding": "VALID", + "pool_size": 2, + "pool_stride": 2, + "pool_time": false, + "single_encoding_conv": true, + "conv_size_reduce": 3 + } + }, + "task": { + "classname": "eoflow.tasks.EvaluateTask", + "config": { + "model_directory": "./temp/tfcn_svn_lulc", + "input_config":{ + "classname": "examples.input.EOPatchInputExample", + "config": { + "data_dir": "/storage/jupyter/data/svn_lulc/data/train-val-linear-v01-aws/test", + "input_feature_type": "data", + "input_feature_name": "FEATURES", + "input_feature_axis": [1,2], + "input_feature_shape": [23, -1, -1, 9], + "labels_feature_type": "mask_timeless", + "labels_feature_name": "LULC_RABA", + "labels_feature_axis": [0,1], + "labels_feature_shape": [-1, -1, 1], + "patch_size": [128, 128], + "interleave_size": 3, + "batch_size": 1, + "num_classes": 10, + "cache_file": "./temp/tfcn_svn_lulc/dataset/cache_val", + "num_subpatches": 5 + } + } + } + } + } diff --git a/eo-flow/configs/tfcn_example_real_pred.json b/eo-flow/configs/tfcn_example_real_pred.json new file mode 100644 index 0000000..4185114 --- /dev/null +++ b/eo-flow/configs/tfcn_example_real_pred.json @@ -0,0 +1,50 @@ +{ + "model": { + "classname": "eoflow.models.TFCNModel", + "config": { + "learning_rate": 0.0001, + "n_layers": 3, + "n_classes": 10, + "keep_prob": 0.8, + "features_root": 16, + "conv_size": 3, + "conv_stride": 1, + "deconv_size": 2, + "add_dropout": true, + "add_batch_norm": false, + "bias_init": 0.0, + "padding": "VALID", + "pool_size": 2, + "pool_stride": 2, + "pool_time": false, + "single_encoding_conv": true, + "conv_size_reduce": 3 + } + }, + "task": { + "classname": "eoflow.tasks.PredictTask", + "config": { + "model_directory": "./temp/tfcn_svn_lulc", + "input_config":{ + "classname": "examples.input.EOPatchInputExample", + "config": { + "data_dir": "/storage/jupyter/data/svn_lulc/data/train-val-linear-v01-aws/test", + "input_feature_type": "data", + "input_feature_name": "FEATURES", + "input_feature_axis": [1,2], + "input_feature_shape": [23, -1, -1, 9], + "labels_feature_type": "mask_timeless", + "labels_feature_name": "LULC_RABA", + "labels_feature_axis": [0,1], + "labels_feature_shape": [-1, -1, 1], + "patch_size": [128, 128], + "interleave_size": 3, + "batch_size": 1, + "num_classes": 10, + "cache_file": "./temp/tfcn_svn_lulc/dataset/cache_val", + "num_subpatches": 5 + } + } + } + } + } diff --git a/eo-flow/configs/tfcn_example_real_train.json b/eo-flow/configs/tfcn_example_real_train.json new file mode 100644 index 0000000..a551bf7 --- /dev/null +++ b/eo-flow/configs/tfcn_example_real_train.json @@ -0,0 +1,58 @@ +{ + "model": { + "classname": "eoflow.models.TFCNModel", + "config": { + "learning_rate": 0.0001, + "n_layers": 3, + "n_classes": 10, + "keep_prob": 0.8, + "features_root": 16, + "conv_size": 3, + "conv_stride": 1, + "deconv_size": 2, + "add_dropout": true, + "add_batch_norm": false, + "bias_init": 0.0, + "padding": "SAME", + "pool_size": 2, + "pool_stride": 2, + "pool_time": false, + "single_encoding_conv": true, + "conv_size_reduce": 3, + "loss": "focal_loss", + "metrics": ["accuracy", "iou"], + "prediction_visualization": true + } + }, + "task": { + "classname": "eoflow.tasks.TrainTask", + "config": { + "num_epochs": 50, + "iterations_per_epoch": 10, + "model_directory": "./temp/tfcn_svn_lulc", + "input_config":{ + "classname": "examples.input.EOPatchInputExample", + "config": { + "data_dir": "/home/devis/Desktop/train-val-linear-v01-aws/train", + "input_feature_type": "data", + "input_feature_name": "FEATURES", + "input_feature_axis": [1,2], + "input_feature_shape": [23, -1, -1, 9], + "labels_feature_type": "mask_timeless", + "labels_feature_name": "LULC_RABA", + "labels_feature_axis": [0,1], + "labels_feature_shape": [-1, -1, 1], + "patch_size": [128, 128], + "interleave_size": 3, + "batch_size": 2, + "num_classes": 10, + "cache_file": "./temp/tfcn_svn_lulc/dataset/cache", + "num_subpatches": 5, + "data_augmentation": true + } + }, + "save_steps": 100, + "summary_steps": 1 + } + } + } diff --git a/eo-flow/configs/tfcn_example_real_train_and_eval.json b/eo-flow/configs/tfcn_example_real_train_and_eval.json new file mode 100644 index 0000000..ad58b21 --- /dev/null +++ b/eo-flow/configs/tfcn_example_real_train_and_eval.json @@ -0,0 +1,78 @@ +{ + "model": { + "classname": "eoflow.models.TFCNModel", + "config": { + "learning_rate": 0.0001, + "n_layers": 3, + "n_classes": 10, + "keep_prob": 0.8, + "features_root": 16, + "conv_size": 3, + "conv_stride": 1, + "deconv_size": 2, + "add_dropout": true, + "add_batch_norm": false, + "bias_init": 0.0, + "padding": "SAME", + "pool_size": 2, + "pool_stride": 2, + "pool_time": false, + "single_encoding_conv": true, + "conv_size_reduce": 3, + "loss": "focal_loss", + "metrics": ["accuracy", "iou"], + "prediction_visualization": true + } + }, + "task": { + "classname": "eoflow.tasks.TrainAndEvaluateTask", + "config": { + "num_epochs": 100, + "iterations_per_epoch": 10, + "model_directory": "./temp/tfcn_svn_lulc", + "train_input_config":{ + "classname": "examples.input.EOPatchInputExample", + "config": { + "data_dir": "/home/devis/Desktop/train-val-linear-v01-aws/train", + "input_feature_type": "data", + "input_feature_name": "FEATURES", + "input_feature_axis": [1,2], + "input_feature_shape": [23, -1, -1, 9], + "labels_feature_type": "mask_timeless", + "labels_feature_name": "LULC_RABA", + "labels_feature_axis": [0,1], + "labels_feature_shape": [-1, -1, 1], + "patch_size": [128, 128], + "interleave_size": 3, + "batch_size": 2, + "num_classes": 10, + "cache_file": "./temp/tfcn_svn_lulc/dataset/cache_train", + "num_subpatches": 5, + "data_augmentation": true + } + }, + "val_input_config":{ + "classname": "examples.input.EOPatchInputExample", + "config": { + "data_dir": "/home/devis/Desktop/train-val-linear-v01-aws/test", + "input_feature_type": "data", + "input_feature_name": "FEATURES", + "input_feature_axis": [1,2], + "input_feature_shape": [23, -1, -1, 9], + "labels_feature_type": "mask_timeless", + "labels_feature_name": "LULC_RABA", + "labels_feature_axis": [0,1], + "labels_feature_shape": [-1, -1, 1], + "patch_size": [128, 128], + "interleave_size": 3, + "batch_size": 2, + "num_classes": 10, + "cache_file": "./temp/tfcn_svn_lulc/dataset/cache_val", + "num_subpatches": 5 + } + }, + "save_steps": 10, + "summary_steps": 1 + } + } + } diff --git a/eo-flow/eoflow/__init__.py b/eo-flow/eoflow/__init__.py new file mode 100644 index 0000000..b9863c0 --- /dev/null +++ b/eo-flow/eoflow/__init__.py @@ -0,0 +1 @@ +name = 'eoflow' diff --git a/eo-flow/eoflow/base/__init__.py b/eo-flow/eoflow/base/__init__.py new file mode 100644 index 0000000..ced878a --- /dev/null +++ b/eo-flow/eoflow/base/__init__.py @@ -0,0 +1,5 @@ +from .configuration import Configurable +from .base_input import BaseInput +from .base_task import BaseTask +from .base_training import BaseModelTraining +from .base_custom_training import BaseModelCustomTraining \ No newline at end of file diff --git a/eo-flow/eoflow/base/base_custom_training.py b/eo-flow/eoflow/base/base_custom_training.py new file mode 100644 index 0000000..1b9836b --- /dev/null +++ b/eo-flow/eoflow/base/base_custom_training.py @@ -0,0 +1,141 @@ +import tensorflow as tf +from sklearn.utils import shuffle +import numpy as np +import pickle + +import os + +import tensorflow as tf + +from . import Configurable + + +class BaseModelCustomTraining(tf.keras.Model, Configurable): + def __init__(self, config_specs): + tf.keras.Model.__init__(self) + Configurable.__init__(self, config_specs) + + self.net = None + self.init_model() + + def init_model(self): + """ Called on __init__. Keras self initialization. Create self here if does not require the inputs shape """ + pass + + def build(self, inputs_shape): + """ Keras method. Called once to build the self. Build the self here if the input shape is required. """ + pass + + def call(self, inputs, training=False): + pass + + def prepare(self, optimizer=None, loss=None, metrics=None, + epoch_loss_metric = None, + epoch_val_metric = None, + **kwargs): + """ Prepares the self for training and evaluation. This method should create the + optimizer, loss and metric functions and call the compile method of the self. The self + should provide the defaults for the optimizer, loss and metrics, which can be overriden + with custom arguments. """ + + raise NotImplementedError + + @tf.function + def train_step(self, + train_ds): + # pb_i = Progbar(len(list(train_ds)), stateful_metrics='acc') + + for x_batch_train, y_batch_train in train_ds: # tqdm + with tf.GradientTape() as tape: + y_preds = self.call(x_batch_train, + training=True) + cost = self.loss(y_batch_train, y_preds) + + grads = tape.gradient(cost, self.trainable_variables) + self.optimizer.apply_gradients(zip(grads, self.trainable_variables)) + self.loss_metric.update_state(cost) + self.metric.update_state(y_batch_train+1, y_preds+1) + + # Function to run the validation step. + @tf.function + def val_step(self, val_ds): + for x, y in val_ds: + y_preds = self.call(x, training=False) + cost = self.loss(y, y_preds) + self.loss_metric.update_state(cost) + self.metric.update_state(y +1, y_preds+1) + + def fit(self, + dataset, + val_dataset, + batch_size, + num_epochs, + model_directory, + iterations_per_epoch=10, + function=np.min): + + train_loss, val_loss, val_acc = ([np.inf] for i in range(3)) + + x_train, y_train = dataset + n, t, d = x_train.shape + + x_val, y_val = val_dataset + val_ds = tf.data.Dataset.from_tensor_slices((x_val, y_val)).batch(batch_size) + + _ = self(tf.zeros([n, t, d])) + + + for epoch in range(num_epochs + 1): + + x_train, y_train = shuffle(x_train, y_train) + train_ds = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(batch_size) + + self.train_step(train_ds) + + # End epoch + loss_epoch = self.loss_metric.result().numpy() + train_loss.append(loss_epoch) + self.loss_metric.reset_states() + + if epoch % iterations_per_epoch == 0: + self.val_step(val_ds) + val_loss_epoch = self.loss_metric.result().numpy() + val_acc_result = self.metric.result().numpy() + print( + "Epoch {0}: Train loss {1}, Val loss {2}, Val acc {3}".format( + str(epoch), + str(loss_epoch), + str(round(val_loss_epoch, 4)), + str(round(val_acc_result, 4)), + )) + + if val_acc_result < function(val_acc): + self.save_weights(os.path.join(model_directory, 'model')) + + val_loss.append(val_loss_epoch) + val_acc.append(val_acc_result) + self.loss_metric.reset_states() + self.metric.reset_states() + + # History of the training + losses = dict(train_loss_results=train_loss, + val_loss_results=val_acc + ) + with open(os.path.join(model_directory, 'history.pickle'), 'wb') as d: + pickle.dump(losses, d, protocol=pickle.HIGHEST_PROTOCOL) + + + def train_and_evaluate(self, + train_dataset, + val_dataset, + num_epochs, + iterations_per_epoch, + model_directory, + **kwargs): + + return self.fit(train_dataset, + val_dataset, + num_epochs=num_epochs, + model_directory=model_directory, + iterations_per_epoch=iterations_per_epoch, + **kwargs) \ No newline at end of file diff --git a/eo-flow/eoflow/base/base_input.py b/eo-flow/eoflow/base/base_input.py new file mode 100644 index 0000000..f3abf0e --- /dev/null +++ b/eo-flow/eoflow/base/base_input.py @@ -0,0 +1,8 @@ +from . import Configurable + + +class BaseInput(Configurable): + def get_dataset(self): + """Builds and returns a tensorflow Dataset object for reading the data.""" + + raise NotImplementedError diff --git a/eo-flow/eoflow/base/base_task.py b/eo-flow/eoflow/base/base_task.py new file mode 100644 index 0000000..60e0c31 --- /dev/null +++ b/eo-flow/eoflow/base/base_task.py @@ -0,0 +1,28 @@ +from . import Configurable, BaseInput +from ..utils import parse_classname + + +class BaseTask(Configurable): + def __init__(self, model, config_specs): + super().__init__(config_specs) + + self.model = model + + @staticmethod + def parse_input(input_config): + """ Builds the input dataset using the provided configuration. """ + + classname, config = input_config.classname, input_config.config + + cls = parse_classname(classname) + if not issubclass(cls, BaseInput): + raise ValueError("Data input class does not inherit from BaseInput.") + + model_input = cls(config) + + return model_input.get_dataset() + + def run(self): + """Executes the task.""" + + raise NotImplementedError diff --git a/eo-flow/eoflow/base/base_training.py b/eo-flow/eoflow/base/base_training.py new file mode 100644 index 0000000..dbd5dce --- /dev/null +++ b/eo-flow/eoflow/base/base_training.py @@ -0,0 +1,157 @@ +import os + +import tensorflow as tf + +from . import Configurable + + +class BaseModelTraining(tf.keras.Model, Configurable): + def __init__(self, config_specs): + tf.keras.Model.__init__(self) + Configurable.__init__(self, config_specs) + + self.net = None + + self.init_model() + + def init_model(self): + """ Called on __init__. Keras model initialization. Create model here if does not require the inputs shape """ + pass + + def build(self, inputs_shape): + """ Keras method. Called once to build the model. Build the model here if the input shape is required. """ + pass + + def call(self, inputs, training=False): + pass + + def prepare(self, optimizer=None, loss=None, metrics=None, **kwargs): + """ Prepares the model for training and evaluation. This method should create the + optimizer, loss and metric functions and call the compile method of the model. The model + should provide the defaults for the optimizer, loss and metrics, which can be overriden + with custom arguments. """ + + raise NotImplementedError + + def load_latest(self, model_directory): + """ Loads weights from the latest checkpoint in the model directory. """ + + checkpoints_path = os.path.join(model_directory, 'checkpoints', 'model.ckpt') + return self.load_weights(checkpoints_path).expect_partial() + + + def _fit(self, + dataset, + num_epochs, + model_directory, + iterations_per_epoch, + val_dataset=None, + save_steps=100, + summary_steps='epoch', + callbacks=[], + **kwargs): + """ Trains and evaluates the model on a given dataset, saving the model and recording summaries. """ + logs_path = os.path.join(model_directory, 'logs') + checkpoints_path = os.path.join(model_directory, 'checkpoints', 'model.ckpt') + + # Tensorboard callback + tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logs_path, + update_freq=summary_steps, + profile_batch=0) + + # Checkpoint saving callback + checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(checkpoints_path, + save_best_only=True, + save_freq=save_steps, + save_weights_only=True) + return self.fit(dataset, + validation_data=val_dataset, + epochs=num_epochs, + steps_per_epoch=iterations_per_epoch, + callbacks=[tensorboard_callback, checkpoint_callback] + callbacks, + **kwargs) + + def train(self, + dataset, + num_epochs, + model_directory, + iterations_per_epoch=None, + save_steps=100, + summary_steps='epoch', + callbacks=[], + **kwargs): + """ Trains the model on a given dataset. Takes care of saving the model and recording summaries. + + :param dataset: A tf.data Dataset containing the input training data. + The dataset must be of shape (features, labels) where features and labels contain the data + in the shape required by the model. + :type dataset: tf.data.Dataset + :param num_epochs: Number of epochs. One epoch is equal to one pass over the dataset. + :type num_epochs: int + :param model_directory: Output directory, where the model checkpoints and summaries are saved. + :type model_directory: str + :param iterations_per_epoch: Number of training steps to make every epoch. + Training dataset is repeated automatically when the end is reached. + :type iterations_per_epoch: int + :param save_steps: Number of steps between saving model checkpoints. + :type save_steps: int + :param summary_steps: Number of steps between recording summaries. + :type summary_steps: str or int + :param callbacks: Customised Keras callbacks to use during training/evaluation + :type callbacks: tf.keras.callbacks + + Other keyword parameters are passed to the Model.fit method. + """ + + return self._fit(dataset if iterations_per_epoch is None else dataset.repeat(), + num_epochs=num_epochs, + model_directory=model_directory, + iterations_per_epoch=iterations_per_epoch, + save_steps=save_steps, + summary_steps=summary_steps, + callbacks=callbacks, + **kwargs) + + def train_and_evaluate(self, + train_dataset, + val_dataset, + num_epochs, + iterations_per_epoch, + model_directory, + save_steps=100, summary_steps='epoch', + callbacks=[], + **kwargs): + """ Trains the model on a given dataset. At the end of each epoch an evaluation is performed on the provided + validation dataset. Takes care of saving the model and recording summaries. + + :param train_dataset: A tf.data Dataset containing the input training data. + The dataset must be of shape (features, labels) where features and labels contain the data + in the shape required by the model. + :type train_dataset: tf.data.Dataset + :param val_dataset: Same as for `train_dataset`, but for the validation data. + :type val_dataset: tf.data.Dataset + :param num_epochs: Number of epochs. Epoch size is independent from the dataset size. + :type num_epochs: int + :param iterations_per_epoch: Number of training steps to make every epoch. + Training dataset is repeated automatically when the end is reached. + :type iterations_per_epoch: int + :param model_directory: Output directory, where the model checkpoints and summaries are saved. + :type model_directory: str + :param save_steps: Number of steps between saving model checkpoints. + :type save_steps: int + :param summary_steps: Number of steps between recodring summaries. + :type summary_steps: str or int + :param callbacks: Customised Keras callbacks to use during training/evaluation + :type callbacks: tf.keras.callbacks + + Other keyword parameters are passed to the Model.fit method. + """ + return self._fit(train_dataset.repeat(), + num_epochs, + model_directory, + iterations_per_epoch, + val_dataset=val_dataset, + save_steps=save_steps, + summary_steps=summary_steps, + callbacks=callbacks, + **kwargs) diff --git a/eo-flow/eoflow/base/configuration.py b/eo-flow/eoflow/base/configuration.py new file mode 100644 index 0000000..50532d7 --- /dev/null +++ b/eo-flow/eoflow/base/configuration.py @@ -0,0 +1,74 @@ +from abc import ABC +import inspect +import json + +from marshmallow import Schema, fields +from munch import Munch + + +def dict_to_munch(obj): + """ Recursively convert a dict to Munch. (there is a Munch.from_dict method, but it's not python3 compatible) + """ + if isinstance(obj, list): + return [dict_to_munch(element) for element in obj] + if isinstance(obj, dict): + return Munch({k: dict_to_munch(v) for k, v in obj.items()}) + return obj + + +class ObjectConfiguration(Schema): + classname = fields.String(required=True, description="Class to instantiate.") + config = fields.Dict(required=True, descripton="Configuration used for instantiation of the class.") + + +class Configurable(ABC): + """ Base class for all configurable objects. + """ + + def __init__(self, config_specs): + self.schema = self.initialize_schema() + self.config = self._prepare_config(config_specs) + + @classmethod + def initialize_schema(cls): + """ A Schema should be provided as an internal class of any class that inherits from Configurable. + This method finds the Schema by traversing the inheritance tree. If no Schema is provided or inherited + an error is raised. + """ + for item in vars(cls).values(): + if inspect.isclass(item) and issubclass(item, Schema): + return item() + + if len(cls.__bases__) > 1: + raise RuntimeError('Class does not have a defined schema however it inherits from multiple ' + 'classes. Which one should schema be inherited from?') + + parent_class = cls.__bases__[0] + + if parent_class is Configurable: + raise NotImplementedError('Configuration schema not provided.') + + return parent_class.initialize_schema() + + def _prepare_config(self, config_specs): + """ Collects and validates configuration dictionary + """ + + # if config_specs is a path + if isinstance(config_specs, str): + with open(config_specs, 'r') as config_file: + config_specs = json.load(config_file) + + return Config(self.schema.load(config_specs)) + + def show_config(self): + print(json.dumps(self.config, indent=4)) + + +class Config(Munch): + """ Config object used for automatic object creation from a dict. + """ + def __init__(self, config): + config = dict_to_munch(config) + + super().__init__(config) diff --git a/eo-flow/eoflow/execute.py b/eo-flow/eoflow/execute.py new file mode 100644 index 0000000..39d73de --- /dev/null +++ b/eo-flow/eoflow/execute.py @@ -0,0 +1,47 @@ +import argparse +import json + +from marshmallow import Schema, fields + +from .base import BaseModelTraining, BaseTask +from .base.configuration import ObjectConfiguration, Config +from .utils import parse_classname + + +class ExecutionConfig(Schema): + model = fields.Nested(ObjectConfiguration, required=True, description='Model configuration') + task = fields.Nested(ObjectConfiguration, required=True, description='Task configuration') + + +def execute(config_file): + """Executes a workflow defined in a config file.""" + + with open(config_file) as file: + config = json.load(file) + + config = Config(ExecutionConfig().load(config)) + + # Parse model config + model_cls = parse_classname(config.model.classname) + if not issubclass(model_cls, BaseModelTraining): + raise ValueError("Model class does not inherit from BaseModel.") + model = model_cls(config.model.config) + + # Parse task config + task_cls = parse_classname(config.task.classname) + if not issubclass(task_cls, BaseTask): + raise ValueError("Task class does not inherit from BaseTask.") + task = task_cls(model, config.task.config) + + # Run task + task.run() + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Executes a workflow described in a provided config file.') + + parser.add_argument('config_file', type=str, help='Path to the configuration file.') + + args = parser.parse_args() + + execute(config_file=args.config_file) diff --git a/eo-flow/eoflow/input/__init__.py b/eo-flow/eoflow/input/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/eo-flow/eoflow/input/eopatch.py b/eo-flow/eoflow/input/eopatch.py new file mode 100644 index 0000000..42e1630 --- /dev/null +++ b/eo-flow/eoflow/input/eopatch.py @@ -0,0 +1,117 @@ +import os +import numpy as np +import tensorflow as tf +from marshmallow import fields, Schema +from marshmallow.validate import OneOf +from eolearn.core import EOPatch, FeatureType + +from ..base import BaseInput + +_valid_types = [t.value for t in FeatureType] + + +def eopatch_dataset(root_dir_or_list, features_data, fill_na=None): + """ Creates a tf dataset with features from saved EOPatches. + + :param root_dir_or_list: Root directory containing eopatches or a list of eopatch directories. + :type root_dir_or_list: str or list(str) + :param features_data: List of tuples containing data about features to extract. + Tuple structure: (feature_type, feature_name, out_feature_name, feature_dtype, feature_shape) + :type features_data: (str, str, str, np.dtype, tuple) + :param fill_na: Value with wich to replace nan values. No replacement is done if None. + :type fill_na: int + """ + + if isinstance(root_dir_or_list, str): + file_pattern = os.path.join(root_dir_or_list, '*') + dataset = tf.data.Dataset.list_files(file_pattern) + else: + dataset = tf.data.Dataset.from_tensor_slices(root_dir_or_list) + + def _read_patch(path): + """ TF op for reading an eopatch at a given path. """ + def _func(path): + path = path.numpy().decode('utf-8') + + # Load only relevant features + features = [(data[0], data[1]) for data in features_data] + patch = EOPatch.load(path, features=features) + + data = [] + for feat_type, feat_name, out_name, dtype, shape in features_data: + arr = patch[feat_type][feat_name].astype(dtype) + + if fill_na is not None: + arr[np.isnan(arr)] = fill_na + + data.append(arr) + + return data + + out_types = [tf.as_dtype(data[3]) for data in features_data] + data = tf.py_function(_func, [path], out_types) + + out_data = {} + for f_data, feature in zip(features_data, data): + feat_type, feat_name, out_name, dtype, shape = f_data + feature.set_shape(shape) + out_data[out_name] = feature + + return out_data + + dataset = dataset.map(_read_patch) + return dataset + + +class EOPatchSegmentationInput(BaseInput): + """ An input method for basic EOPatch reading. Reads features and segmentation labels. For more complex behaviour + (subpatch extraction, data augmentation, caching, ...) create your own input method (see examples). + """ + + class _Schema(Schema): + data_dir = fields.String(description="The directory containing EOPatches.", required=True) + + input_feature_type = fields.String(description="Feature type of the input feature.", required=True, validate=OneOf(_valid_types)) + input_feature_name = fields.String(description="Name of the input feature.", required=True) + input_feature_axis = fields.List(fields.Int, description="Height and width axis for the input features", required=True, example=[1,2]) + input_feature_shape = fields.List(fields.Int, description="Shape of the input feature. Use -1 for unknown dimesnions.", + required=True, example=[-1, 100, 100, 3]) + + labels_feature_type = fields.String(description="Feature type of the labels feature.", required=True, validate=OneOf(_valid_types)) + labels_feature_name = fields.String(description="Name of the labels feature.", required=True) + labels_feature_axis = fields.List(fields.Int, description="Height and width axis for the labels", required=True, example=[1,2]) + labels_feature_shape = fields.List(fields.Int, description="Shape of the labels feature. Use -1 for unknown dimesnions.", + required=True, example=[-1, 100, 100, 3]) + + batch_size = fields.Int(description="Number of examples in a batch.", required=True, example=20) + num_classes = fields.Int(description="Number of classes. Used for one-hot encoding.", required=True, example=2) + + def _parse_shape(self, shape): + shape = [None if s < 0 else s for s in shape] + return shape + + def get_dataset(self): + cfg = self.config + + # Create a tf.data.Dataset from EOPatches + features_data = [ + (cfg.input_feature_type, cfg.input_feature_name, 'features', np.float32, self._parse_shape(cfg.input_feature_shape)), + (cfg.labels_feature_type, cfg.labels_feature_name, 'labels', np.int64, self._parse_shape(cfg.labels_feature_shape)) + ] + dataset = eopatch_dataset(self.config.data_dir, features_data, fill_na=-2) + + # One-hot encode labels and return tuple + def _prepare_data(data): + features = data['features'] + labels = data['labels'][...,0] + + labels_oh = tf.one_hot(labels, depth=self.config.num_classes) + + return features, labels_oh + + dataset = dataset.map(_prepare_data) + + # Create batches + dataset = dataset.batch(self.config.batch_size) + + return dataset diff --git a/eo-flow/eoflow/input/hdf5.py b/eo-flow/eoflow/input/hdf5.py new file mode 100644 index 0000000..f634f1b --- /dev/null +++ b/eo-flow/eoflow/input/hdf5.py @@ -0,0 +1,44 @@ +import os + +import h5py +import tensorflow as tf + +def hdf5_dataset(path, features): + """ Creates a tf.data.Dataset from a hdf5 file + + :param path: path to the hdf5 file, + :type path: str + :param features: dict of (`dataset` -> `feature_name`) mappings, where `dataset` is the dataset name in the hdf5 file + and `feature_name` is the name of the feature it is saved to. + :type features: dict + + :return: dataset containing examples merged from files + :rtype: tf.data.Dataset + """ + + fields = list(features.keys()) + feature_names = [features[f] for f in features] + + # Reads dataset row by row + def _generator(): + with h5py.File(path, 'r') as file: + datasets = [file[field] for field in fields] + for row in zip(*datasets): + yield row + + # Converts a database of tuples to database of dicts + def _to_dict(*features): + return {name: feat for name, feat in zip(feature_names, features)} + + # Reads hdf5 metadata (types and shapes) + with h5py.File(path, 'r') as file: + datasets = [file[field] for field in fields] + + types = tuple(ds.dtype for ds in datasets) + shapes = tuple(ds.shape[1:] for ds in datasets) + + # Create dataset + ds = tf.data.Dataset.from_generator(_generator, types, shapes) + ds = ds.map(_to_dict) + + return ds diff --git a/eo-flow/eoflow/input/numpy.py b/eo-flow/eoflow/input/numpy.py new file mode 100644 index 0000000..1afb15a --- /dev/null +++ b/eo-flow/eoflow/input/numpy.py @@ -0,0 +1,102 @@ +import os + +import numpy as np +import tensorflow as tf + +def numpy_dataset(np_array_dict): + """ Creates a tf.data Dataset from a dict of numpy arrays. """ + + # Unpack + feature_names = list(np_array_dict.keys()) + np_arrays = [np_array_dict[name] for name in feature_names] + + # Check that arrays match in the first dimension + n_samples = np_arrays[0].shape[0] + assert all(n_samples == arr.shape[0] for arr in np_arrays) + + # Extract types and shapes form np arrays + types = tuple(arr.dtype for arr in np_arrays) + shapes = tuple(arr.shape[1:] for arr in np_arrays) + + def _generator(): + # Iterate through the first dimension of arrays + for slices in zip(*np_arrays): + yield slices + + ds = tf.data.Dataset.from_generator(_generator, types, shapes) + ds = ds.take(n_samples) + + # Converts a database of tuples to database of dicts + def _to_dict(*features): + return {name: feat for name, feat in zip(feature_names, features)} + + ds = ds.map(_to_dict) + + return ds + +def _read_numpy_file(file_path, fields): + """ Reads a single npz file. """ + + data = np.load(file_path) + np_arrays = [data[f] for f in fields] + + # Check that arrays match in the first dimension + n_samples = np_arrays[0].shape[0] + assert all(n_samples == arr.shape[0] for arr in np_arrays) + + return tuple(np_arrays) + +def npz_dir_dataset(file_dir_or_list, features, num_parallel=5): + """ Creates a tf.data.Dataset from a directory containing numpy .npz files. Files are loaded + lazily when needed. `num_parallel` files are read in parallel and interleaved together. + + :param file_dir_or_list: directory containing .npz files or a list of paths to .npz files + :type file_dir_or_list: str | list(str) + :param features: dict of (`field` -> `feature_name`) mappings, where `field` is the field in the .npz array + and `feature_name` is the name of the feature it is saved to. + :type features: dict + :param num_parallel: number of files to read in parallel and intereleave, defaults to 5 + :type num_parallel: int, optional + + :return: dataset containing examples merged from files + :rtype: tf.data.Dataset + """ + + files = file_dir_or_list + + # If dir, then list files + if isinstance(file_dir_or_list, str): + files = [os.path.join(file_dir_or_list, f) for f in os.listdir(file_dir_or_list)] + + fields = list(features.keys()) + feature_names = [features[f] for f in features] + + # Read one file for shape info + file = next(iter(files)) + data = np.load(file) + np_arrays = [data[f] for f in fields] + + # Read shape and type info + types = tuple(arr.dtype for arr in np_arrays) + shapes = tuple((None,) + arr.shape[1:] for arr in np_arrays) + + def _data_generator(files, fields): + """ Returns samples from one file at a time. """ + for f in files: + yield _read_numpy_file(f, fields) + + # Converts a database of tuples to database of dicts + def _to_dict(*features): + return {name: feat for name, feat in zip(feature_names, features)} + + # Create dataset + ds = tf.data.Dataset.from_generator(lambda:_data_generator(files, fields), types, shapes) + + # Prefetch needed amount of files for interleaving + ds = ds.prefetch(num_parallel) + + # Unbatch and interleave + ds = ds.interleave(lambda *x: tf.data.Dataset.from_tensor_slices(x), cycle_length=num_parallel) + ds = ds.map(_to_dict) + + return ds diff --git a/eo-flow/eoflow/input/operations.py b/eo-flow/eoflow/input/operations.py new file mode 100644 index 0000000..988dd93 --- /dev/null +++ b/eo-flow/eoflow/input/operations.py @@ -0,0 +1,210 @@ +import os +import numpy as np +import tensorflow as tf + +from ..utils import create_dirs + + +def extract_subpatches(patch_size, spatial_features_and_axis, random_sampling=False, num_random_samples=20, + grid_overlap=0.2): + """ Builds a TF op for building a dataset of subpatches from tensors. Subpatches sampling can be random or grid based. + + :param patch_size: Width and height of extracted patches + :type patch_size: (int, int) + :param spatial_features_and_axis: List of features from which subpatches are extracted and their height and width axis. + Elements are tuples of (feature_name, (axis_h, axis_w)). + :type spatial_features_and_axis: list of (string, (int, int)) + :param random_sampling: If True random sampling is used. Else grid based sampling is used. + :type random_sampling: bool + :param num_random_samples: Defines the number of subpatches to sample, when random sampling is used. + :type num_random_samples: int + :param grid_overlap: Amount of overlap between subpatches extracted from a grid + :type grid_overlap: float + """ + + patch_w, patch_h = patch_size + + def _fn(data): + feat_name_ref, axis_ref = spatial_features_and_axis[0] + ay_ref, ax_ref = axis_ref + # Get random coordinates + + def _py_get_random(image): + x_space = image.shape[ax_ref]-patch_w + if x_space > 0: + x_rand = np.random.randint(x_space, size=num_random_samples, dtype=np.int64) + else: + x_rand = np.zeros(num_random_samples, np.int64) + + y_space = image.shape[ay_ref]-patch_h + if y_space > 0: + y_rand = np.random.randint(y_space, size=num_random_samples, dtype=np.int64) + else: + y_rand = np.zeros(num_random_samples, np.int64) + + return x_rand, y_rand + + # Get coordinates on a grid + def _py_get_gridded(image): + + # alpha is overlaping ratio (w.r.t. patch size) + alpha = grid_overlap + + img_height = image.shape[ay_ref] + img_width = image.shape[ax_ref] + + # number of patches in x and y direction + nx = int(np.ceil((img_width - alpha * patch_w) / (patch_w * (1 - alpha)))) + ny = int(np.ceil((img_height - alpha * patch_h) / (patch_h * (1 - alpha)))) + + # total number of patches + N = nx * ny + # allocate output vectors (top-left patch coordinates) + tl_x = np.zeros(N, dtype=np.int64) + tl_y = np.zeros(N, dtype=np.int64) + + # calculate actual x and y coordinates + for yi in range(ny): + if yi == 0: + # the highest patch has x0 = 0 + y_ = 0 + elif yi == ny - 1: + # the lowest patch has y0 = H - patch_h + y_ = img_height - patch_h + else: + # calculate top-left y coordinate and take into account overlaping, too + y_ = np.round(yi * patch_h - yi * alpha * patch_h) + + for xi in range(nx): + if xi == 0: + # the left-most patch has x0 = 0 + x_ = 0 + elif xi == nx - 1: + # the right-most patch has x0 = W - patch_w + x_ = img_width - patch_w + else: + # calculate top-left x coordinate and take into account overlaping, too + x_ = np.round(xi * patch_w - xi * alpha * patch_w) + + id = yi * nx + xi + tl_x[id] = np.int64(x_) + tl_y[id] = np.int64(y_) + + return tl_x, tl_y + + if random_sampling: + x_samp, y_samp = tf.py_function(_py_get_random, [data[feat_name_ref]], [tf.int64, tf.int64]) + else: + x_samp, y_samp = tf.py_function(_py_get_gridded, [data[feat_name_ref]], [tf.int64, tf.int64]) + + def _py_get_patches(axis): + ay, ax = axis + # Extract patches for given coordinates + + def _func(image, x_samp, y_samp): + patches = [] + + # Pad if necessary + x_pad = max(0, patch_w - image.shape[ax]) + y_pad = max(0, patch_h - image.shape[ay]) + + if x_pad > 0 or y_pad > 0: + pad_x1 = x_pad//2 + pad_x2 = x_pad - pad_x1 + pad_y1 = y_pad//2 + pad_y2 = y_pad - pad_y1 + + padding = [(0,0) for _ in range(image.ndim)] + padding[ax] = (pad_x1,pad_x2) + padding[ay] = (pad_y1,pad_y2) + image = np.pad(image, padding, 'constant') + + # Extract patches + for x, y in zip(x_samp, y_samp): + # Slice on specified axis + slicing = [slice(None) for _ in range(image.ndim)] + slicing[ax] = slice(x, x+patch_w) + slicing[ay] = slice(y, y+patch_h) + + patch = image[slicing] + patches.append(patch) + return np.stack(patches) + + return _func + + data_out = {} + # TODO: repeat the rest of the data + for feat_name, axis in spatial_features_and_axis: + ay, ax = axis + shape = data[feat_name].shape.as_list() + patches = tf.py_function(_py_get_patches(axis), [data[feat_name], x_samp, y_samp], data[feat_name].dtype) + + # Update shape information + shape[ax] = patch_w + shape[ay] = patch_h + shape = [None] + shape + patches.set_shape(shape) + + data_out[feat_name] = patches + + # TODO: shuffle subpatches + return tf.data.Dataset.from_tensor_slices(data_out) + + return _fn + + +def augment_data(features_to_augment, brightness_delta=0.1, contrast_bounds=(0.9,1.1)): + """ Builds a function that randomly augments features in specified ways. + + param features_to_augment: List of features to augment and which operations to perform on them. + Each element is of shape (feature, list_of_operations). + type features_to_augment: list of (str, list of str) + param brightness_delta: Maximum brightness change. + type brightness_delta: float + param contrast_bounds: Upper and lower bounds of contrast multiplier. + type contrast_bounds: (float, float) + """ + + def _augment(data): + contrast_lower, contrast_upper = contrast_bounds + + flip_lr_cond = tf.random.uniform(shape=[]) > 0.5 + flip_ud_cond = tf.random.uniform(shape=[]) > 0.5 + rot90_amount = tf.random.uniform(shape=[], maxval=4, dtype=tf.int32) + + # Available operations + operations = { + 'flip_left_right': lambda x: tf.cond(flip_lr_cond, lambda: tf.image.flip_left_right(x), lambda: x), + 'flip_up_down': lambda x: tf.cond(flip_ud_cond, lambda: tf.image.flip_up_down(x), lambda: x), + 'rotate': lambda x: tf.image.rot90(x, rot90_amount), + 'brightness': lambda x: tf.image.random_brightness(x, brightness_delta), + 'contrast': lambda x: tf.image.random_contrast(x, contrast_lower, contrast_upper) + } + + for feature, ops in features_to_augment: + # Apply specified ops to feature + for op in ops: + operation_fn = operations[op] + data[feature] = operation_fn(data[feature]) + + return data + + return _augment + + +def cache_dataset(dataset, path): + """ Caches dataset into a file. Each element in the dataset will be computed only once. """ + + # Create dir if missing + directory = os.path.dirname(path) + create_dirs([directory]) + + # Cache + dataset = dataset.cache(path) + + # Disable map and batch fusion to prevent a bug when caching + options = tf.data.Options() + options.experimental_optimization.map_and_batch_fusion = False + dataset = dataset.with_options(options) + + return dataset diff --git a/eo-flow/eoflow/input/random.py b/eo-flow/eoflow/input/random.py new file mode 100644 index 0000000..dc53647 --- /dev/null +++ b/eo-flow/eoflow/input/random.py @@ -0,0 +1,76 @@ +import numpy as np +import tensorflow as tf +from marshmallow import fields, Schema + +from ..base import BaseInput + + +class RandomClassificationInput(BaseInput): + """ Class to create random batches for classification tasks. Can be used for prototyping. """ + + class _Schema(Schema): + input_shape = fields.List(fields.Int, description="Shape of a single input example.", required=True, example=[784]) + num_classes = fields.Int(description="Number of classes.", required=True, example=10) + + batch_size = fields.Int(description="Number of examples in a batch.", required=True, example=20) + batches_per_epoch = fields.Int(required=True, description='Number of batches in epoch', example=20) + + def _generate_batch(self): + for i in range(self.config.batches_per_epoch): + input_shape = [self.config.batch_size] + self.config.input_shape + input_data = np.random.rand(*input_shape) + + onehot = np.eye(self.config.num_classes) + output_shape = [self.config.batch_size] + classes = np.random.randint(self.config.num_classes, size=output_shape) + labels = onehot[classes] + + yield input_data, labels + + def get_dataset(self): + input_shape = [self.config.batch_size] + self.config.input_shape + output_shape = [self.config.batch_size, self.config.num_classes] + + dataset = tf.data.Dataset.from_generator( + self._generate_batch, + (tf.float32, tf.float32), + (tf.TensorShape(input_shape), tf.TensorShape(output_shape)) + ) + + return dataset + + +class RandomSegmentationInput(BaseInput): + """ Class to create random batches for segmentation tasks. Can be used for prototyping. """ + + class _Schema(Schema): + input_shape = fields.List(fields.Int, description="Shape of a single input example.", required=True, example=[512,512,3]) + output_shape = fields.List(fields.Int, description="Shape of a single output mask.", required=True, example=[128,128]) + num_classes = fields.Int(description="Number of segmentation classes.", required=True, example=10) + + batch_size = fields.Int(description="Number of examples in a batch.", required=True, example=20) + batches_per_epoch = fields.Int(required=True, description='Number of batches in epoch', example=20) + + def _generate_batch(self): + for i in range(self.config.batches_per_epoch): + input_shape = [self.config.batch_size] + self.config.input_shape + input_data = np.random.rand(*input_shape) + + onehot = np.eye(self.config.num_classes) + output_shape = [self.config.batch_size] + self.config.output_shape + classes = np.random.randint(self.config.num_classes, size=output_shape) + labels = onehot[classes] + + yield input_data, labels + + def get_dataset(self): + input_shape = [self.config.batch_size] + self.config.input_shape + output_shape = [self.config.batch_size] + self.config.output_shape + [self.config.num_classes] + + dataset = tf.data.Dataset.from_generator( + self._generate_batch, + (tf.float32, tf.float32), + (tf.TensorShape(input_shape), tf.TensorShape(output_shape)) + ) + + return dataset diff --git a/eo-flow/eoflow/models/__init__.py b/eo-flow/eoflow/models/__init__.py new file mode 100644 index 0000000..a7525a8 --- /dev/null +++ b/eo-flow/eoflow/models/__init__.py @@ -0,0 +1,4 @@ +from eoflow.models.segmentation_task.segmentation_unets import FCNModel, TFCNModel +from eoflow.models.tempnets_task.cnn_tempnets import TCNModel, TempCNNModel +from eoflow.models.tempnets_task.rnn_tempnets import BiRNN, ConvLSTM +#from eoflow.models.tempnets_task.mlp_tempnets import TransformerEncoder, PseTae, MLP \ No newline at end of file diff --git a/eo-flow/eoflow/models/callbacks.py b/eo-flow/eoflow/models/callbacks.py new file mode 100644 index 0000000..14657f3 --- /dev/null +++ b/eo-flow/eoflow/models/callbacks.py @@ -0,0 +1,91 @@ +import tensorflow as tf +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt + +from ..utils.tf_utils import plot_to_image + + +class VisualizationCallback(tf.keras.callbacks.Callback): + """ Keras Callback for saving prediction visualizations to TensorBoard. """ + + def __init__(self, val_images, log_dir, time_index=0, rgb_indices=[2, 1, 0]): + """ + :param val_images: Images to run predictions on. Tuple of (images, labels). + :type val_images: (np.array, np.array) + :param log_dir: Directory where the TensorBoard logs are written. + :type log_dir: str + :param time_index: Time index to use, when multiple time slices are available, defaults to 0 + :type time_index: int, optional + :param rgb_indices: Indices for R, G and B bands in the input image, defaults to [0,1,2] + :type rgb_indices: list, optional + """ + super().__init__() + + self.val_images = val_images + self.time_index = time_index + self.rgb_indices = rgb_indices + + self.file_writer = tf.summary.create_file_writer(log_dir) + + @staticmethod + def plot_predictions(input_image, labels, predictions, n_classes): + # TODO: fix figsize (too wide?) + fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5)) + + scaled_image = np.clip(input_image*2.5, 0., 1.) + ax1.imshow(scaled_image) + ax1.title.set_text('Input image') + + cnorm = mpl.colors.NoNorm() + cmap = plt.cm.get_cmap('Set3', n_classes) + + ax2.imshow(labels, cmap=cmap, norm=cnorm) + ax2.title.set_text('Labeled classes') + + img = ax3.imshow(predictions, cmap=cmap, norm=cnorm) + ax3.title.set_text('Predicted classes') + + plt.colorbar(img, ax=[ax1, ax2, ax3], shrink=0.8, ticks=list(range(n_classes))) + + return fig + + def prediction_summaries(self, step): + images, labels = self.val_images + preds_raw = self.model.predict(images) + + pred_shape = tf.shape(preds_raw) + + # If temporal data only use time_index slice + if images.ndim == 5: + images = images[:, self.time_index, :, :, :] + + # Crop images and labels to output size + labels = tf.image.resize_with_crop_or_pad(labels, pred_shape[1], pred_shape[2]) + images = tf.image.resize_with_crop_or_pad(images, pred_shape[1], pred_shape[2]) + + # Take RGB values + images = images.numpy()[..., self.rgb_indices] + + num_classes = labels.shape[-1] + + # Get class ids + preds_raw = np.argmax(preds_raw, axis=-1) + labels = np.argmax(labels, axis=-1) + + vis_images = [] + for image_i, labels_i, pred_i in zip(images, labels, preds_raw): + # Plot predictions and convert to image + fig = self.plot_predictions(image_i, labels_i, pred_i, num_classes) + img = plot_to_image(fig) + + vis_images.append(img) + + n_images = len(vis_images) + vis_images = tf.concat(vis_images, axis=0) + + with self.file_writer.as_default(): + tf.summary.image('predictions', vis_images, step=step, max_outputs=n_images) + + def on_epoch_end(self, epoch, logs=None): + self.prediction_summaries(epoch) diff --git a/eo-flow/eoflow/models/embeddings.py b/eo-flow/eoflow/models/embeddings.py new file mode 100644 index 0000000..c24c133 --- /dev/null +++ b/eo-flow/eoflow/models/embeddings.py @@ -0,0 +1,29 @@ +from sklearn.base import BaseEstimator,RegressorMixin +from sklearn.exceptions import NotFittedError + +class EmbeddingEstimator(BaseEstimator,RegressorMixin): + def __init__(self, model): + self.model = model + self.estimator_fitted = False + + def get_embeddings(self, x): + self.model.predict(x) + return self.model.get_feature_map(inputs=x) + + def define_estimator(self, estimator): + self.estimator = estimator + return self + + def fit(self, x,y): + x = self.get_embeddings(x) + self.estimator.fit(x, y) + self.estimator_fitted = True + return self + + def predict(self, x): + if not self.estimator_fitted: + raise NotFittedError( + 'The estimator must be fitted before calling predict(...).' + ) + x = self.get_embeddings(x) + return self.estimator.predict(x) \ No newline at end of file diff --git a/eo-flow/eoflow/models/layers.py b/eo-flow/eoflow/models/layers.py new file mode 100644 index 0000000..bc07bca --- /dev/null +++ b/eo-flow/eoflow/models/layers.py @@ -0,0 +1,407 @@ +import tensorflow as tf + +from tensorflow.keras.layers import Activation, SpatialDropout1D, Lambda, UpSampling2D, AveragePooling2D +from tensorflow.keras.layers import Conv1D, BatchNormalization, LayerNormalization + + +class ResidualBlock(tf.keras.layers.Layer): + """ Code taken from keras-tcn implementation on available on + https://github.com/philipperemy/keras-tcn/blob/master/tcn/tcn.py#L140 """ + def __init__(self, + dilation_rate, + nb_filters, + kernel_size, + padding, + activation='relu', + dropout_rate=0, + kernel_initializer='he_normal', + kernel_regularizer = 0, + use_batch_norm=False, + use_layer_norm=False, + last_block=True, + **kwargs): + + """ Defines the residual block for the WaveNet TCN + + :param dilation_rate: The dilation power of 2 we are using for this residual block + :param nb_filters: The number of convolutional filters to use in this block + :param kernel_size: The size of the convolutional kernel + :param padding: The padding used in the convolutional layers, 'same' or 'causal'. + :param activation: The final activation used in o = Activation(x + F(x)) + :param dropout_rate: Float between 0 and 1. Fraction of the input units to drop. + :param kernel_initializer: Initializer for the kernel weights matrix (Conv1D). + :param use_batch_norm: Whether to use batch normalization in the residual layers or not. + :param use_layer_norm: Whether to use layer normalization in the residual layers or not. + :param last_block: Whether to add a residual connection to the convolution layer or not. + :param kwargs: Any initializers for Layer class. + """ + + self.dilation_rate = dilation_rate + self.nb_filters = nb_filters + self.kernel_size = kernel_size + self.padding = padding + self.activation = activation + self.dropout_rate = dropout_rate + self.use_batch_norm = use_batch_norm + self.use_layer_norm = use_layer_norm + self.kernel_initializer = kernel_initializer + self.kernel_regularizer = kernel_regularizer + self.last_block = last_block + self.residual_layers = [] + self.shape_match_conv = None + self.res_output_shape = None + self.final_activation = None + + super(ResidualBlock, self).__init__(**kwargs) + + def _add_and_activate_layer(self, layer): + """Helper function for building layer + Args: + layer: Appends layer to internal layer list and builds it based on the current output + shape of ResidualBlocK. Updates current output shape. + """ + self.residual_layers.append(layer) + self.residual_layers[-1].build(self.res_output_shape) + self.res_output_shape = self.residual_layers[-1].compute_output_shape(self.res_output_shape) + + def build(self, input_shape): + + with tf.keras.backend.name_scope(self.name): # name scope used to make sure weights get unique names + self.res_output_shape = input_shape + + for k in range(2): + name = f'conv1D_{k}' + with tf.keras.backend.name_scope(name): # name scope used to make sure weights get unique names + self._add_and_activate_layer(Conv1D(filters=self.nb_filters, + kernel_size=self.kernel_size, + dilation_rate=self.dilation_rate, + padding=self.padding, + name=name, + kernel_regularizer = tf.keras.regularizers.l2(self.kernel_regularizer), + kernel_initializer=self.kernel_initializer)) + + if self.use_batch_norm: + self._add_and_activate_layer(BatchNormalization()) + elif self.use_layer_norm: + self._add_and_activate_layer(LayerNormalization()) + + self._add_and_activate_layer(SpatialDropout1D(rate=self.dropout_rate)) + self._add_and_activate_layer(Activation('relu')) + + + if not self.last_block: + # 1x1 conv to match the shapes (channel dimension). + name = f'conv1D_{k+1}' + with tf.keras.backend.name_scope(name): + # make and build this layer separately because it directly uses input_shape + self.shape_match_conv = Conv1D(filters=self.nb_filters, + kernel_size=1, + padding='same', + name=name, + kernel_regularizer = tf.keras.regularizers.l2(self.kernel_regularizer), + kernel_initializer=self.kernel_initializer) + + else: + self.shape_match_conv = Lambda(lambda x: x, name='identity') + + self.shape_match_conv.build(input_shape) + self.res_output_shape = self.shape_match_conv.compute_output_shape(input_shape) + + self.final_activation = Activation(self.activation) + self.final_activation.build(self.res_output_shape) # probably isn't necessary + + # this is done to force keras to add the layers in the list to self._layers + for layer in self.residual_layers: + self.__setattr__(layer.name, layer) + + super(ResidualBlock, self).build(input_shape) # done to make sure self.built is set True + + def call(self, inputs, training=None): + """ + Returns: A tuple where the first element is the residual model tensor, and the second + is the skip connection tensor. + """ + x = inputs + for layer in self.residual_layers: + if isinstance(layer, SpatialDropout1D): + x = layer(x, training=training) + else: + x = layer(x) + + x2 = self.shape_match_conv(inputs) + res_x = tf.keras.layers.add([x2, x]) + return [self.final_activation(res_x), x] + + def compute_output_shape(self, input_shape): + return [self.res_output_shape, self.res_output_shape] + + + +class Conv2D(tf.keras.layers.Layer): + """ Multiple repetitions of 2d convolution, batch normalization and dropout layers. """ + + def __init__(self, filters, kernel_size=3, + strides=1, dilation=1, padding='VALID', + add_dropout=True, + dropout_rate=0.2, activation='relu', batch_normalization=False, use_bias=True, num_repetitions=1): + super().__init__() + + repetitions = [] + + for _ in range(num_repetitions): + layer = [ + tf.keras.layers.Conv2D( + filters=filters, + kernel_size=kernel_size, + strides=strides, + dilation_rate=dilation, + padding=padding, + use_bias=use_bias, + activation=activation, + ) + ] + + if batch_normalization: + layer.append(tf.keras.layers.BatchNormalization()) + + if add_dropout: + layer.append(tf.keras.layers.Dropout(rate=dropout_rate)) + + layer = tf.keras.Sequential(layer) + + repetitions.append(layer) + + self.combined_layer = tf.keras.Sequential(repetitions) + + def call(self, inputs, training=False): + return self.combined_layer(inputs, training=training) + + +class ResConv2D(tf.keras.layers.Layer): + """ + Layer of N residual convolutional blocks stacked in parallel + + This layer stacks in parallel a sequence of 2 2D convolutional layers and returns the addition of their output + feature tensors with the input tensor. N number of convolutional blocks can be added together with different kernel + size and dilation rate, which are specified as a list. If the inputs are not a list, the same parameters are used + for all convolutional blocks. + + """ + + def __init__(self, filters, kernel_size=3, strides=1, dilation=1, padding='VALID', add_dropout=True, + dropout_rate=0.2, activation='relu', use_bias=True, batch_normalization=False, num_parallel=1): + super().__init__() + + if isinstance(kernel_size, list) and len(kernel_size) != num_parallel: + raise ValueError('Number of specified kernel sizes needs to match num_parallel') + + if isinstance(dilation, list) and len(dilation) != num_parallel: + raise ValueError('Number of specified dilation rate sizes needs to match num_parallel') + + kernel_list = kernel_size if isinstance(kernel_size, list) else [kernel_size]*num_parallel + dilation_list = dilation if isinstance(dilation, list) else [dilation]*num_parallel + + self.convs = [Conv2D(filters, + kernel_size=k, + strides=strides, + dilation=d, + padding=padding, + activation=activation, + add_dropout=add_dropout, + dropout_rate=dropout_rate, + use_bias=use_bias, + batch_normalization=batch_normalization, + num_repetitions=2) for k, d in zip(kernel_list, dilation_list)] + + self.add = tf.keras.layers.Add() + + def call(self, inputs, training=False): + outputs = [conv_layer(inputs, training=training) for conv_layer in self.convs] + + return self.add(outputs + [inputs]) + + +class Conv3D(tf.keras.layers.Layer): + """ Multiple repetitions of 3d convolution, batch normalization and dropout layers. """ + + def __init__(self, filters, kernel_size=3, strides=1, padding='VALID', add_dropout=True, dropout_rate=0.2, + batch_normalization=False, use_bias=True, num_repetitions=1, convolve_time=True): + super().__init__() + + repetitions = [] + + t_size = kernel_size if convolve_time else 1 + kernel_shape = (t_size, kernel_size, kernel_size) + + for _ in range(num_repetitions): + layer = [ + tf.keras.layers.Conv3D( + filters=filters, + kernel_size=kernel_shape, + strides=strides, + padding=padding, + use_bias=use_bias, + activation='relu', + ) + ] + + if batch_normalization: + layer.append(tf.keras.layers.BatchNormalization()) + + if add_dropout: + layer.append(tf.keras.layers.Dropout(rate=dropout_rate)) + + layer = tf.keras.Sequential(layer) + + repetitions.append(layer) + + self.combined_layer = tf.keras.Sequential(repetitions) + + def call(self, inputs, training=False): + return self.combined_layer(inputs, training=training) + + +class Deconv2D(tf.keras.layers.Layer): + """ 2d transpose convolution with optional batch normalization. """ + + def __init__(self, filters, kernel_size=2, batch_normalization=False): + super().__init__() + + layer = [tf.keras.layers.Conv2DTranspose( + filters=filters, + kernel_size=kernel_size, + strides=kernel_size, + padding='SAME', + activation='relu' + )] + + if batch_normalization: + layer.append(tf.keras.layers.BatchNormalization()) + + self.layer = tf.keras.Sequential(layer) + + def call(self, inputs, training=None): + return self.layer(inputs, training=training) + + +class CropAndConcat(tf.keras.layers.Layer): + """ Layer that crops the first tensor and concatenates it with the second. Used for skip connections. """ + @staticmethod + def call(x1, x2): + # Crop x1 to shape of x2 + x2_shape = tf.shape(x2) + x1_crop = tf.image.resize_with_crop_or_pad(x1, x2_shape[1], x2_shape[2]) + + # Concatenate along last dimension and return + return tf.concat([x1_crop, x2], axis=-1) + + +class MaxPool3D(tf.keras.layers.Layer): + def __init__(self, kernel_size=2, strides=2, pool_time=False): + super().__init__() + + tsize = kernel_size if pool_time else 1 + tstride = strides if pool_time else 1 + + kernel_shape = (tsize, kernel_size, kernel_size) + strides = (tstride, strides, strides) + + self.layer = tf.keras.layers.MaxPool3D( + pool_size=kernel_shape, + strides=strides, + padding='SAME' + ) + + def call(self, inputs, training=None): + return self.layer(inputs, training=training) + + +class Reduce3DTo2D(tf.keras.layers.Layer): + """ Reduces 3d representations into 2d using 3d convolution over the whole time dimension. """ + + def __init__(self, filters, kernel_size=3, stride=1, add_dropout=False, dropout_rate=0.2): + super().__init__() + + self.filters = filters + self.kernel_size = kernel_size + self.stride = stride + self.add_dropout = add_dropout + self.dropout_rate = dropout_rate + self.layer = None + + def build(self, input_size): + t_size = input_size[1] + layer = [tf.keras.layers.Conv3D( + self.filters, + kernel_size=(t_size, self.kernel_size, self.kernel_size), + strides=(1, self.stride, self.stride), + padding='VALID', + activation='relu' + )] + + if self.add_dropout: + layer.append(tf.keras.layers.Dropout(rate=self.dropout_rate)) + + self.layer = tf.keras.Sequential(layer) + + def call(self, inputs, training=None): + r = self.layer(inputs, training=training) + + # Squeeze along temporal dimension + return tf.squeeze(r, axis=[1]) + + +class PyramidPoolingModule(tf.keras.layers.Layer): + """ + Implementation of the Pyramid Pooling Module + + Implementation taken from the following paper + + Zhao et al. - Pyramid Scene Parsing Network - https://arxiv.org/pdf/1612.01105.pdf + + PyTorch implementation https://github.com/hszhao/semseg/blob/master/model/pspnet.py + """ + def __init__(self, filters, bins=(1, 2, 4, 8), interpolation='bilinear', batch_normalization=False): + super().__init__() + + self.filters = filters + self.bins = bins + self.batch_normalization = batch_normalization + self.interpolation = interpolation + self.layers = None + + def build(self, input_size): + _, height, width, n_features = input_size + + layers = [] + + for bin_size in self.bins: + + size_factors = height // bin_size, width // bin_size + + layer = tf.keras.Sequential() + layer.add(AveragePooling2D(pool_size=size_factors, + padding='same')) + layer.add(tf.keras.layers.Conv2D(filters=self.filters//len(self.bins), + kernel_size=1, + padding='same', + use_bias=False)) + if self.batch_normalization: + layer.add(BatchNormalization()) + layer.add(Activation('relu')) + + layer.add(UpSampling2D(size=size_factors, interpolation=self.interpolation)) + + layers.append(layer) + + self.layers = layers + + def call(self, inputs, training=None): + """ Concatenate the output of the pooling layers, resampled to original size """ + _, height, width, _ = inputs.shape + + outputs = [inputs] + + outputs += [layer(inputs, training=training) for layer in self.layers] + + return tf.concat(outputs, axis=-1) diff --git a/eo-flow/eoflow/models/losses.py b/eo-flow/eoflow/models/losses.py new file mode 100644 index 0000000..63aa8f7 --- /dev/null +++ b/eo-flow/eoflow/models/losses.py @@ -0,0 +1,234 @@ +import tensorflow as tf +from tensorflow.keras.losses import Loss, Reduction + + +def cropped_loss(loss_fn): + """ Wraps loss function. Crops the labels to match the logits size. """ + + def _loss_fn(labels, logits): + logits_shape = tf.shape(logits) + labels_crop = tf.image.resize_with_crop_or_pad(labels, logits_shape[1], logits_shape[2]) + + return loss_fn(labels_crop, logits) + + return _loss_fn + + +class CategoricalCrossEntropy(Loss): + """ Wrapper class for cross-entropy with class weights """ + def __init__(self, from_logits=True, class_weights=None, reduction=Reduction.AUTO, name='FocalLoss'): + """Categorical cross-entropy. + + :param from_logits: Whether predictions are logits or softmax, defaults to True + :type from_logits: bool + :param class_weights: Array of class weights to be applied to loss. Needs to be of `n_classes` length + :type class_weights: np.array + :param reduction: reduction to be used, defaults to Reduction.AUTO + :type reduction: tf.keras.losses.Reduction, optional + :param name: name of the loss, defaults to 'FocalLoss' + :type name: str + """ + super().__init__(reduction=reduction, name=name) + + self.from_logits = from_logits + self.class_weights = class_weights + + def call(self, y_true, y_pred): + # Perform softmax + if self.from_logits: + y_pred = tf.nn.softmax(y_pred) + + # Clip the prediction value to prevent NaN's and Inf's + epsilon = tf.keras.backend.epsilon() + y_pred = tf.clip_by_value(y_pred, epsilon, 1.) + + # Calculate Cross Entropy + loss = -y_true * tf.math.log(y_pred) + + # Multiply cross-entropy with class-wise weights + if self.class_weights is not None: + loss = tf.multiply(loss, self.class_weights) + + # Sum over classes + loss = tf.reduce_sum(loss, axis=-1) + + return loss + + +class CategoricalFocalLoss(Loss): + """ Categorical version of focal loss. + + References: + Official paper: https://arxiv.org/pdf/1708.02002.pdf + Keras implementation: https://github.com/umbertogriffo/focal-loss-keras + """ + + def __init__(self, gamma=2., alpha=.25, from_logits=True, class_weights=None, + reduction=Reduction.AUTO, + name='FocalLoss'): + """Categorical version of focal loss. + + :param gamma: gamma value, defaults to 2. + :type gamma: float + :param alpha: alpha value, defaults to .25 + :type alpha: float + :param from_logits: Whether predictions are logits or softmax, defaults to True + :type from_logits: bool + :param class_weights: Array of class weights to be applied to loss. Needs to be of `n_classes` length + :type class_weights: np.array + :param reduction: reduction to be used, defaults to Reduction.AUTO + :type reduction: tf.keras.losses.Reduction, optional + :param name: name of the loss, defaults to 'FocalLoss' + :type name: str + """ + super().__init__(reduction=reduction, name=name) + + self.gamma = gamma + self.alpha = alpha + self.from_logits = from_logits + self.class_weights = class_weights + + def call(self, y_true, y_pred): + + # Perform softmax + if self.from_logits: + y_pred = tf.nn.softmax(y_pred) + + # Clip the prediction value to prevent NaN's and Inf's + epsilon = tf.keras.backend.epsilon() + y_pred = tf.clip_by_value(y_pred, epsilon, 1.) + + # Calculate Cross Entropy + cross_entropy = -y_true * tf.math.log(y_pred) + + # Calculate Focal Loss + loss = self.alpha * tf.math.pow(1 - y_pred, self.gamma) * cross_entropy + + # Multiply focal loss with class-wise weights + if self.class_weights is not None: + loss = tf.multiply(cross_entropy, self.class_weights) + + # Sum over classes + loss = tf.reduce_sum(loss, axis=-1) + + return loss + + +class JaccardDistanceLoss(Loss): + """ Implementation of the Jaccard distance, or Intersection over Union IoU loss. + + Jaccard = (|X & Y|)/ (|X|+ |Y| - |X & Y|) + = sum(|A*B|)/(sum(|A|)+sum(|B|)-sum(|A*B|)) + + Implementation taken from https://github.com/keras-team/keras-contrib/blob/master/keras_contrib/losses/jaccard.py + """ + def __init__(self, smooth=1, from_logits=True, class_weights=None, reduction=Reduction.AUTO, name='JaccardLoss'): + """ Jaccard distance loss. + + :param smooth: Smoothing factor. Default is 1. + :type smooth: int + :param from_logits: Whether predictions are logits or softmax, defaults to True + :type from_logits: bool + :param class_weights: Array of class weights to be applied to loss. Needs to be of `n_classes` length + :type class_weights: np.array + :param reduction: reduction to be used, defaults to Reduction.AUTO + :type reduction: tf.keras.losses.Reduction, optional + :param name: name of the loss, defaults to 'JaccardLoss' + :type name: str + """ + super().__init__(reduction=reduction, name=name) + + self.smooth = smooth + self.from_logits = from_logits + + self.class_weights = class_weights + + def call(self, y_true, y_pred): + + # Perform softmax + if self.from_logits: + y_pred = tf.nn.softmax(y_pred) + + intersection = tf.reduce_sum(y_true * y_pred, axis=(1, 2)) + + sum_ = tf.reduce_sum(y_true + y_pred, axis=(1, 2)) + + jac = (intersection + self.smooth) / (sum_ - intersection + self.smooth) + + loss = (1 - jac) * self.smooth + + if self.class_weights is not None: + loss = tf.multiply(loss, self.class_weights) + + loss = tf.reduce_sum(loss, axis=-1) + + return loss + + +class TanimotoDistanceLoss(Loss): + """ Implementation of the Tanimoto distance, which is modified version of the Jaccard distance. + + Tanimoto = (|X & Y|)/ (|X|^2+ |Y|^2 - |X & Y|) + = sum(|A*B|)/(sum(|A|^2)+sum(|B|^2)-sum(|A*B|)) + + Implementation taken from + https://github.com/feevos/resuneta/blob/145be5519ee4bec9a8cce9e887808b8df011f520/nn/loss/loss.py#L7 + """ + def __init__(self, smooth=1.0e-5, from_logits=True, class_weights=None, + reduction=Reduction.AUTO, normalise=False, name='TanimotoLoss'): + """ Tanimoto distance loss. + + :param smooth: Smoothing factor. Default is 1.0e-5. + :type smooth: float + :param from_logits: Whether predictions are logits or softmax, defaults to True + :type from_logits: bool + :param class_weights: Array of class weights to be applied to loss. Needs to be of `n_classes` length + :type class_weights: np.array + :param reduction: Reduction to be used, defaults to Reduction.AUTO + :type reduction: tf.keras.losses.Reduction, optional + :param normalise: Whether to normalise loss by number of positive samples in class, defaults to `False` + :type normalise: bool + :param name: Name of the loss, defaults to 'TanimotoLoss' + :type name: str + """ + super().__init__(reduction=reduction, name=name) + + self.smooth = smooth + self.from_logits = from_logits + self.normalise = normalise + + self.class_weights = class_weights + + def call(self, y_true, y_pred): + + # Perform softmax + if self.from_logits: + y_pred = tf.nn.softmax(y_pred) + + n_classes = y_true.shape[-1] + + volume = tf.reduce_mean(tf.reduce_sum(y_true, axis=(1, 2)), axis=0) \ + if self.normalise else tf.ones(n_classes, dtype=tf.float32) + + weights = tf.math.reciprocal(tf.math.square(volume)) + new_weights = tf.where(tf.math.is_inf(weights), tf.zeros_like(weights), weights) + weights = tf.where(tf.math.is_inf(weights), tf.ones_like(weights) * tf.reduce_max(new_weights), weights) + + intersection = tf.reduce_sum(y_true * y_pred, axis=(1, 2)) + + sum_ = tf.reduce_sum(y_true * y_true + y_pred * y_pred, axis=(1, 2)) + + num_ = tf.multiply(intersection, weights) + self.smooth + + den_ = tf.multiply(sum_ - intersection, weights) + self.smooth + + tanimoto = num_ / den_ + + loss = (1 - tanimoto) + + if self.class_weights is not None: + loss = tf.multiply(loss, self.class_weights) + + loss = tf.reduce_sum(loss, axis=-1) + + return loss diff --git a/eo-flow/eoflow/models/metrics.py b/eo-flow/eoflow/models/metrics.py new file mode 100644 index 0000000..a2af3a9 --- /dev/null +++ b/eo-flow/eoflow/models/metrics.py @@ -0,0 +1,335 @@ +import warnings + +from typing import Any, Callable, List + +from skimage import measure +from scipy import ndimage + +import tensorflow as tf +import tensorflow_addons as tfa +import numpy as np + + +class InitializableMetric(tf.keras.metrics.Metric): + """ Metric that has to be initialized from model configuration. """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.initialized = False + + def init_from_config(self, model_config=None): + """ Initializes the metric from configuration. """ + + self.initialized = True + + def assert_initialized(self): + """ Checks if the metric is initialized. """ + + if not self.initialized: + raise ValueError("InitializableMetric was not initialized before use.") + + +class MeanIoU(InitializableMetric): + """ Computes mean intersection over union metric for semantic segmentation. + Wraps keras MeanIoU to work on logits. """ + + def __init__(self, default_max_classes=32, name='mean_iou'): + """ Creates MeanIoU metric + + :param default_max_classes: Default value for max number of classes. Required by Keras MeanIoU. + Must be greater or equal to the actual number of classes. + Will not be used if n_classes is in model configuration. Defaults to 32. + :type default_max_classes: int + :param name: Name of the metric + :type name: str + """ + + super().__init__(name=name, dtype=tf.float32) + self.default_max_classes = default_max_classes + self.metric = None + + def init_from_config(self, model_config=None): + super().init_from_config(model_config) + + if model_config is not None and 'n_classes' in model_config: + self.metric = tf.keras.metrics.MeanIoU(num_classes=model_config['n_classes']) + else: + print("n_classes not found in model config or model config not provided. Using default max value.") + self.metric = tf.keras.metrics.MeanIoU(num_classes=self.default_max_classes) + + def update_state(self, y_true, y_pred, sample_weight=None): + self.assert_initialized() + + y_pred_c = tf.argmax(y_pred, axis=-1) + y_true_c = tf.argmax(y_true, axis=-1) + + return self.metric.update_state(y_true_c, y_pred_c, sample_weight) + + def result(self): + self.assert_initialized() + + return self.metric.result() + + def reset_states(self): + self.assert_initialized() + + return self.metric.reset_states() + + def get_config(self): + self.assert_initialized() + + return self.metric.get_config() + + +class CroppedMetric(tf.keras.metrics.Metric): + """ Wraps a metric. Crops the labels to match the logits size. """ + + def __init__(self, metric): + super().__init__(name=metric.name, dtype=metric.dtype) + self.metric = metric + + def update_state(self, y_true, y_pred, sample_weight=None): + logits_shape = tf.shape(y_pred) + labels_crop = tf.image.resize_with_crop_or_pad(y_true, logits_shape[1], logits_shape[2]) + + return self.metric.update_state(labels_crop, y_pred, sample_weight) + + def result(self): + return self.metric.result() + + def reset_states(self): + return self.metric.reset_states() + + def get_config(self): + return self.metric.get_config() + + +class RSquared(InitializableMetric): + def __init__(self,name = 'r_square'): + super().__init__(name=name, dtype=tf.float32) + self.metric = None + + def init_from_config(self, model_config=None): + super().init_from_config(model_config) + self.metric = tfa.metrics.RSquare(dtype=tf.float32, y_shape=(1,)) + + def update_state(self, y_true, y_pred): + self.assert_initialized() + + return self.metric.update_state(y_true, y_pred) + + def result(self): + self.assert_initialized() + + return self.metric.result() + + def reset_states(self): + self.assert_initialized() + + return self.metric.reset_states() + + def get_config(self): + self.assert_initialized() + + return self.metric.get_config() + + +class MCCMetric(InitializableMetric): + """ Computes Mathew Correlation Coefficient metric. Wraps metrics.MatthewsCorrelationCoefficient from + tensorflow-addons, and reshapes the input (logits) into (m, n_classes) tensors. The logits are thresholded to get + "one-hot encoded" values for (multi)class metrics """ + + def __init__(self, default_n_classes=2, default_threshold=0.5, name='mcc'): + """ Creates MCCMetric metric + + :param default_n_classes: Default number of classes + :type default_n_classes: int + :param default_threshold: Default value for threshold + :type default_threshold: float + :param name: Name of the metric + :type name: str + """ + + super().__init__(name=name, dtype=tf.float32) + self.metric = None + self.default_n_classes = default_n_classes + self.threshold = default_threshold + + def init_from_config(self, model_config=None): + super().init_from_config(model_config) + + if model_config is not None and 'n_classes' in model_config: + self.metric = tfa.metrics.MatthewsCorrelationCoefficient(num_classes=model_config['n_classes']) + else: + print("n_classes not found in model config or model config not provided. Using default max value.") + self.metric = tfa.metrics.MatthewsCorrelationCoefficient(num_classes=self.default_n_classes) + + if model_config is not None and 'mcc_threshold' in model_config: + self.threshold = model_config['mcc_threshold'] + else: + print(f"Using default value for threshold: {self.threshold}.") + + self.metric = tfa.metrics.MatthewsCorrelationCoefficient(num_classes=model_config['n_classes']) + + def update_state(self, y_true, y_pred, sample_weight=None): + self.assert_initialized() + + n = tf.math.reduce_prod(tf.shape(y_pred)[:-1]) + y_pred_c = tf.reshape(y_pred > self.threshold, (n, self.metric.num_classes)) + y_true_c = tf.reshape(y_true, (n, self.metric.num_classes)) + + return self.metric.update_state(y_true_c, y_pred_c, sample_weight=sample_weight) + + def result(self): + self.assert_initialized() + + return self.metric.result() + + def reset_states(self): + self.assert_initialized() + + return self.metric.reset_states() + + def get_config(self): + self.assert_initialized() + + return self.metric.get_config() + + +class GeometricMetrics(InitializableMetric): + """" + Implementation of Geometric error metrics. Oversegmentation, Undersegmentation, Border, Fragmentation errors. + + The error metrics are based on a paper by C. Persello, A Novel Protocol for Accuracy Assessment in Classification of + Very High Resolution Images (https://ieeexplore.ieee.org/document/5282610) + """ + + @staticmethod + def _detect_edges(im: np.ndarray, thr: float = 0) -> np.ndarray: + """ Edge detection function using the sobel operator. """ + sx = ndimage.sobel(im, axis=0, mode='constant') + sy = ndimage.sobel(im, axis=1, mode='constant') + sob = np.hypot(sx, sy) + return sob > thr + + @staticmethod + def _segmentation_error(intersection_area: float, object_area: float) -> float: + return 1. - intersection_area / object_area + + @staticmethod + def _intersection(mask1: np.ndarray, mask2: np.ndarray) -> float: + return np.sum(np.logical_and(mask1, mask2)) + + def _border_err(self, border_ref_edge: np.ndarray, border_meas_edge: np.ndarray) -> float: + ref_edge_size = np.sum(border_ref_edge) + intersection = self._intersection(border_ref_edge, border_meas_edge) + err = intersection / ref_edge_size if ref_edge_size != 0 else 0 + return 1. - err + + def _fragmentation_err(self, r: int, reference_mask: np.ndarray) -> float: + if r <= 1: + return 0 + den = np.sum(reference_mask) - self.pixel_size + return (r - 1.) / den if den > 0 else 0 + + @staticmethod + def _validate_input(reference, measurement): + if np.ndim(reference) != np.ndim(measurement): + raise ValueError("Reference and measurement input shapes must match.") + + def __init__(self, pixel_size: int = 1, edge_func: Callable = None, **edge_func_params: Any): + + super().__init__(name='geometric_metrics', dtype=tf.float64) + + self.oversegmentation_error = [] + self.undersegmentation_error = [] + self.border_error = [] + self.fragmentation_error = [] + + self.edge_func = self._detect_edges if edge_func is None else edge_func + self.edge_func_params = edge_func_params + self.pixel_size = pixel_size + + def update_state(self, reference: np.ndarray, measurement: np.ndarray, encode_reference: bool = True, + background_value: int = 0) -> None: + """ Calculate the error metrics for a measurement and reference arrays. For each . + + If encode_reference is set to True, connected components will be used to label objects in the reference and + measurements. + """ + + if not tf.executing_eagerly(): + warnings.warn("Geometric metrics must be run with eager execution. If running as a compiled Keras model, " + "enable eager execution with model.run_eagerly = True") + + reference = reference.numpy() if isinstance(reference, tf.Tensor) else reference + measurement = measurement.numpy() if isinstance(reference, tf.Tensor) else measurement + + self._validate_input(reference, measurement) + + for ref, meas in zip(reference, measurement): + ref = ref + meas = meas + + if encode_reference: + cc_reference = measure.label(ref, background=background_value) + else: + cc_reference = ref + + cc_measurement = measure.label(meas, background=background_value) + components_reference = set(np.unique(cc_reference)).difference([background_value]) + + ref_edges = self.edge_func(cc_reference) + meas_edges = self.edge_func(cc_measurement) + for component in components_reference: + reference_mask = cc_reference == component + + uniq, count = np.unique(cc_measurement[reference_mask & (cc_measurement != background_value)], + return_counts=True) + ref_area = np.sum(reference_mask) + + max_interecting_measurement = uniq[count.argmax()] if len(count) > 0 else background_value + meas_mask = cc_measurement == max_interecting_measurement + meas_area = np.count_nonzero(cc_measurement == max_interecting_measurement) + intersection_area = count.max() if len(count) > 0 else 0 + + self.oversegmentation_error.append(self._segmentation_error(intersection_area, ref_area)) + self.undersegmentation_error.append(self._segmentation_error(intersection_area, meas_area)) + border_ref_edge = ref_edges.squeeze() & reference_mask.squeeze() + border_meas_edge = meas_edges.squeeze() & meas_mask.squeeze() + + self.border_error.append(self._border_err(border_ref_edge, border_meas_edge)) + self.fragmentation_error.append(self._fragmentation_err(len(uniq), reference_mask)) + + def get_oversegmentation_error(self) -> float: + """ Return oversegmentation error. """ + return np.array(self.oversegmentation_error).mean() + + def get_undersegmentation_error(self) -> float: + """ Return undersegmentation error. """ + + return np.array(self.undersegmentation_error).mean() + + def get_border_error(self) -> float: + """ Return border error. """ + + return np.array(self.border_error).mean() + + def get_fragmentation_error(self) -> float: + """ Return fragmentation error. """ + + return np.array(self.fragmentation_error).mean() + + def result(self) -> List[float]: + """ Return a list of values representing oversegmentation, undersegmentation, border, fragmentation errors. """ + + return [self.get_oversegmentation_error(), + self.get_undersegmentation_error(), + self.get_border_error(), self.get_fragmentation_error()] + + def reset_states(self) -> None: + """ Empty all the error arrays. """ + self.oversegmentation_error = [] + self.undersegmentation_error = [] + self.border_error = [] + self.fragmentation_error = [] diff --git a/eo-flow/eoflow/models/pse_tae_layers.py b/eo-flow/eoflow/models/pse_tae_layers.py new file mode 100644 index 0000000..794d8cc --- /dev/null +++ b/eo-flow/eoflow/models/pse_tae_layers.py @@ -0,0 +1,176 @@ +import numpy as np +import tensorflow as tf +import tensorflow.keras.layers as L + +from .transformer_encoder_layers import scaled_dot_product_attention, positional_encoding + +pooling_methods = { + 'mean': tf.math.reduce_mean, + 'std': tf.math.reduce_std, + 'max': tf.math.reduce_max, + 'min': tf.math.reduce_min +} + +class PixelSetEncoder(tf.keras.layers.Layer): + def __init__(self, mlp1=[10, 32, 64], mlp2=[64, 128], pooling='mean_std'): + super().__init__() + + self.mlp1 = tf.keras.Sequential([LinearLayer(out_dim) for out_dim in mlp1]) + + pooling_methods = [SetPooling(method) for method in pooling.split('_')] + self.pooling = SummaryConcatenate(pooling_methods, axis=-1) + + mlp2_layers = [LinearLayer(out_dim) for out_dim in mlp2[:-1]] + mlp2_layers.append(LinearLayer(mlp2[-1], activation=False)) + self.mlp2 = tf.keras.Sequential(mlp2_layers) + + self.encoder = tf.keras.Sequential([ + self.mlp1, + self.pooling, + self.mlp2 + ]) + + def call(self, x, training=None, mask=None): + return self.encoder(x, training=training, mask=mask) + + +class MultiHeadAttention(tf.keras.layers.Layer): + def __init__(self, n_head, d_k, name='multi_head_attention'): + super().__init__(name=name) + + self.n_head = n_head + self.d_k = d_k + + self.fc1_q = L.Dense(d_k * n_head, + kernel_initializer=tf.random_normal_initializer(mean=0, stddev=np.sqrt(2.0 / d_k))) + + self.fc1_k = L.Dense(d_k * n_head, + kernel_initializer=tf.random_normal_initializer(mean=0, stddev=np.sqrt(2.0 / d_k))) + + self.fc2 = tf.keras.Sequential([ + L.BatchNormalization(), + L.Dense(d_k) + ]) + + def split_heads(self, x, batch_size): + """Split the last dimension into (n_head, d_k). + Transpose the result such that the shape is (batch_size, n_head, seq_len, d_k) + """ + + x = tf.reshape(x, (batch_size, -1, self.n_head, self.d_k)) + return tf.transpose(x, perm=[0, 2, 1, 3]) + + def call(self, q, k, v, training=None, mask=None): + batch_size = tf.shape(q)[0] + + q = self.fc1_q(q) + q = self.split_heads(q, batch_size) + q = tf.reduce_mean(q, axis=2, keepdims=True) # MEAN query + + k = self.fc1_k(k) + k = self.split_heads(k, batch_size) + + # Repeat n_head times + v = tf.expand_dims(v, axis=1) + v = tf.tile(v, (1, self.n_head, 1, 1)) + + output, attn = scaled_dot_product_attention(q, k, v, mask) + + output = tf.squeeze(output, axis=2) + + # Concat heads + output = tf.reshape(output, (batch_size, -1)) + + return output + +class TemporalAttentionEncoder(tf.keras.layers.Layer): + def __init__(self, n_head=4, d_k=32, d_model=None, n_neurons=[512, 128, 128], dropout=0.2, + T=1000, len_max_seq=24, positions=None): + super().__init__() + + + self.positions = positions + if self.positions is None: + self.positions = len_max_seq + 1 + + self.d_model = d_model + self.T = T + + self.in_layer_norm = tf.keras.layers.LayerNormalization(name='in_layer_norm') + + self.inconv = None + if d_model is not None: + self.inconv = tf.keras.Sequential([ + L.Conv1D(d_model, 1, name='inconv'), + L.LayerNormalization(name='conv_layer_norm') + ]) + + self.out_layer_norm = tf.keras.layers.LayerNormalization(name='out_layer_norm') + + self.attention_heads = MultiHeadAttention(n_head, d_k, name='attention_heads') + + mlp_layers = [LinearLayer(out_dim) for out_dim in n_neurons] + self.mlp = tf.keras.Sequential(mlp_layers, name='mlp') + + self.dropout = L.Dropout(dropout) + + def build(self, input_shape): + d_in = input_shape[-1] if self.d_model is None else self.d_model + self.position_enc = positional_encoding(self.positions, d_in, T=self.T) + + def call(self, x, training=None, mask=None): + seq_len = tf.shape(x)[1] + + x = self.in_layer_norm(x, training=training) + + if self.inconv is not None: + x = self.inconv(x, training=training) + + pos_encoding = self.position_enc[:, :seq_len, :] + if self.positions is None: + pos_encoding = self.position_enc[:, 1:seq_len+1, :] + + enc_output = x + pos_encoding + + enc_output = self.attention_heads(enc_output, enc_output, enc_output, training=training, mask=mask) + + enc_output = self.mlp(enc_output, training=training) + enc_output = self.dropout(enc_output, training=training) + enc_output = self.out_layer_norm(enc_output, training=training) + + return enc_output + +def LinearLayer(out_dim, batch_norm=True, activation=True): + """ Linear layer. """ + + layers = [L.Dense(out_dim)] + + if batch_norm: + layers.append(L.BatchNormalization()) + + if activation: + layers.append(L.ReLU()) + + return tf.keras.Sequential(layers) + +class SetPooling(tf.keras.layers.Layer): + """ Pooling over the Set dimension using a specified pooling method. """ + def __init__(self, pooling_method): + super().__init__() + + self.pooling_method = pooling_methods[pooling_method] + + def call(self, x, training=None, mask=None): + return self.pooling_method(x, axis=1) + +class SummaryConcatenate(tf.keras.layers.Layer): + """ Runs multiple summary layers on a single input and concatenates them. """ + def __init__(self, layers, axis=-1): + super().__init__() + + self.layers = layers + self.axis = axis + + def call(self, x, training=None, mask=None): + layer_outputs = [layer(x, training=training, mask=mask) for layer in self.layers] + return L.concatenate(layer_outputs, axis=self.axis) diff --git a/eo-flow/eoflow/models/segmentation_task/__init__.py b/eo-flow/eoflow/models/segmentation_task/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/eo-flow/eoflow/models/segmentation_task/segmentation_base.py b/eo-flow/eoflow/models/segmentation_task/segmentation_base.py new file mode 100644 index 0000000..8e4a825 --- /dev/null +++ b/eo-flow/eoflow/models/segmentation_task/segmentation_base.py @@ -0,0 +1,164 @@ +import os +import logging + +import numpy as np +import tensorflow as tf +from marshmallow import Schema, fields +from marshmallow.validate import OneOf, ContainsOnly + +from eoflow.base import BaseModelTraining + +from eoflow.models.losses import CategoricalCrossEntropy, CategoricalFocalLoss, JaccardDistanceLoss, TanimotoDistanceLoss +from eoflow.models.losses import cropped_loss +from eoflow.models.metrics import MeanIoU, InitializableMetric, CroppedMetric, MCCMetric +from eoflow.models.callbacks import VisualizationCallback + +logging.basicConfig(level=logging.INFO, + format='%(asctime)s %(levelname)s %(message)s') + + +# Available losses. Add keys with new losses here. +segmentation_losses = { + 'cross_entropy': CategoricalCrossEntropy, + 'focal_loss': CategoricalFocalLoss, + 'jaccard_loss': JaccardDistanceLoss, + 'tanimoto_loss': TanimotoDistanceLoss +} + + +# Available metrics. Add keys with new metrics here. +segmentation_metrics = { + 'accuracy': lambda: tf.keras.metrics.CategoricalAccuracy(name='accuracy'), + 'iou': lambda: MeanIoU(default_max_classes=32), + 'precision': tf.keras.metrics.Precision, + 'recall': tf.keras.metrics.Recall, + 'mcc': MCCMetric +} + + +class BaseSegmentationModel(BaseModelTraining): + """ Base for segmentation models. """ + + class _Schema(Schema): + n_classes = fields.Int(required=True, description='Number of classes', example=2) + learning_rate = fields.Float(missing=None, description='Learning rate used in training.', example=0.01) + loss = fields.String(missing='cross_entropy', description='Loss function used for training.', + validate=OneOf(segmentation_losses.keys())) + metrics = fields.List(fields.String, missing=['accuracy', 'iou'], + description='List of metrics used for evaluation.', + validate=ContainsOnly(segmentation_metrics.keys())) + + class_weights = fields.Dict(missing=None, description='Dictionary mapping class id with weight. ' + 'If key for some labels is not specified, 1 is used.') + + prediction_visualization = fields.Bool(missing=False, description='Record prediction visualization summaries.') + prediction_visualization_num = fields.Int(missing=5, + description='Number of images used for prediction visualization.') + + def _prepare_class_weights(self): + """ Utility function to parse class weights """ + if self.config.class_weights is None: + return np.ones(self.config.n_classes) + return np.array([self.config.class_weights[iclass] if iclass in self.config.class_weights else 1.0 + for iclass in range(self.config.n_classes)]) + + def prepare(self, optimizer=None, loss=None, metrics=None, **kwargs): + """ Prepares the model. Optimizer, loss and metrics are read using the following protocol: + * If an argument is None, the default value is used from the configuration of the model. + * If an argument is a key contained in segmentation specific losses/metrics, those are used. + * Otherwise the argument is passed to `compile` as is. + + """ + # Read defaults if None + if optimizer is None: + optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate) + + if loss is None: + loss = self.config.loss + + if metrics is None: + metrics = self.config.metric + + class_weights = self._prepare_class_weights() + + # Wrap loss function + # TODO: pass kwargs to loss from config + if loss in segmentation_losses: + loss = segmentation_losses[loss](from_logits=False, class_weights=class_weights) + wrapped_loss = cropped_loss(loss) + + # Wrap metrics + wrapped_metrics = [] + for metric in metrics: + + if metric in segmentation_metrics: + if metric in ['precision', 'recall']: + wrapped_metrics += [CroppedMetric(segmentation_metrics[metric](top_k=1, + class_id=class_id, + name=f'{metric}_{class_id}')) + for class_id in range(self.config.n_classes)] + continue + else: + metric = segmentation_metrics[metric]() + + # Initialize initializable metrics + if isinstance(metric, InitializableMetric): + metric.init_from_config(self.config) + + wrapped_metric = CroppedMetric(metric) + wrapped_metrics.append(wrapped_metric) + + self.compile(optimizer=optimizer, loss=wrapped_loss, metrics=wrapped_metrics, **kwargs) + + def _get_visualization_callback(self, dataset, log_dir): + ds = dataset.unbatch().batch(self.config.prediction_visualization_num).take(1) + data = next(iter(ds)) + + visualization_callback = VisualizationCallback(data, log_dir) + return visualization_callback + + # Override default method to add prediction visualization + def train(self, dataset, + num_epochs, + model_directory, + iterations_per_epoch=None, + class_weights=None, + callbacks=[], + save_steps='epoch', + summary_steps=1, **kwargs): + + custom_callbacks = [] + + if self.config.prediction_visualization: + log_dir = os.path.join(model_directory, 'logs', 'predictions') + visualization_callback = self._get_visualization_callback(dataset, log_dir) + custom_callbacks.append(visualization_callback) + + super().train(dataset, num_epochs, model_directory, iterations_per_epoch, + callbacks=callbacks + custom_callbacks, save_steps=save_steps, + summary_steps=summary_steps, **kwargs) + + # Override default method to add prediction visualization + def train_and_evaluate(self, + train_dataset, + val_dataset, + num_epochs, + iterations_per_epoch, + model_directory, + class_weights=None, + save_steps=100, + summary_steps=10, + callbacks=[], **kwargs): + + custom_callbacks = [] + + if self.config.prediction_visualization: + log_dir = os.path.join(model_directory, 'logs', 'predictions') + visualization_callback = self._get_visualization_callback(val_dataset, log_dir) + custom_callbacks.append(visualization_callback) + + super().train_and_evaluate(train_dataset, val_dataset, + num_epochs, iterations_per_epoch, + model_directory, + save_steps=save_steps, summary_steps=summary_steps, + callbacks=callbacks + custom_callbacks, **kwargs) diff --git a/eo-flow/eoflow/models/segmentation_task/segmentation_unets.py b/eo-flow/eoflow/models/segmentation_task/segmentation_unets.py new file mode 100644 index 0000000..e653e35 --- /dev/null +++ b/eo-flow/eoflow/models/segmentation_task/segmentation_unets.py @@ -0,0 +1,651 @@ +import logging +import tensorflow as tf +from marshmallow import fields + +from eoflow.models.layers import Conv2D, Deconv2D, CropAndConcat, Conv3D, MaxPool3D, Reduce3DTo2D, ResConv2D, PyramidPoolingModule +from .segmentation_base import BaseSegmentationModel + +logging.basicConfig(level=logging.INFO, + format='%(asctime)s %(levelname)s %(message)s') + + +class FCNModel(BaseSegmentationModel): + """ Implementation of a vanilla Fully-Convolutional-Network (aka U-net) """ + + class FCNModelSchema(BaseSegmentationModel._Schema): + n_layers = fields.Int(required=True, description='Number of layers of the FCN model', example=10) + keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) + features_root = fields.Int(required=True, description='Number of features at the root level.', example=32) + + conv_size = fields.Int(missing=3, description='Size of the convolution kernels.') + deconv_size = fields.Int(missing=2, description='Size of the deconvolution kernels.') + conv_stride = fields.Int(missing=1, description='Stride used in convolutions.') + dilation_rate = fields.List(fields.Int, missing=1, description='Dilation rate used in convolutions.') + add_dropout = fields.Bool(missing=False, description='Add dropout to layers.') + add_batch_norm = fields.Bool(missing=True, description='Add batch normalization to layers.') + bias_init = fields.Float(missing=0.0, description='Bias initialization value.') + use_bias = fields.Bool(missing=True, description='Add bias parameters to convolutional layer.') + padding = fields.String(missing='VALID', description='Padding type used in convolutions.') + + pool_size = fields.Int(missing=2, description='Kernel size used in max pooling.') + pool_stride = fields.Int(missing=2, description='Stride used in max pooling.') + + class_weights = fields.List(fields.Float, missing=None, description='Class weights used in training.') + + def build(self, inputs_shape): + """Builds the net for input x.""" + + x = tf.keras.layers.Input(inputs_shape[1:]) + dropout_rate = 1 - self.config.keep_prob + + # Encoding path + # the number of features of the convolutional kernels is proportional to the square of the level + # for instance, starting with 32 features at the first level (layer=0), there will be 64 features at layer=1 and + # 128 features at layer=2 + net = x + connection_outputs = [] + for layer in range(self.config.n_layers): + # compute number of features as a function of network depth level + features = 2 ** layer * self.config.features_root + + # bank of two convolutional filters + conv = Conv2D( + filters=features, + kernel_size=self.config.conv_size, + strides=self.config.conv_stride, + dilation=self.config.dilation_rate, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + use_bias=self.config.use_bias, + num_repetitions=2)(net) + + connection_outputs.append(conv) + + # max pooling operation + net = tf.keras.layers.MaxPool2D( + pool_size=self.config.pool_size, + strides=self.config.pool_stride, + padding='SAME')(conv) + + # bank of 2 convolutional filters at bottom of U-net. + bottom = Conv2D( + filters=2 ** self.config.n_layers * self.config.features_root, + kernel_size=self.config.conv_size, + strides=self.config.conv_stride, + dilation=self.config.dilation_rate, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + use_bias=self.config.use_bias, + num_repetitions=2, + padding=self.config.padding)(net) + + net = bottom + # Decoding path + # the decoding path mirrors the encoding path in terms of number of features per convolutional filter + for layer in range(self.config.n_layers): + # find corresponding level in decoding branch + conterpart_layer = self.config.n_layers - 1 - layer + # get same number of features as counterpart layer + features = 2 ** conterpart_layer * self.config.features_root + + deconv = Deconv2D( + filters=features, + kernel_size=self.config.deconv_size, + batch_normalization=self.config.add_batch_norm)(net) + + # # skip connections to concatenate features from encoding path + cc = CropAndConcat()(connection_outputs[conterpart_layer], + deconv) + + # bank of 2 convolutional filters + net = Conv2D( + filters=features, + kernel_size=self.config.conv_size, + strides=self.config.conv_stride, + dilation=self.config.dilation_rate, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + use_bias=self.config.use_bias, + num_repetitions=2, + padding=self.config.padding)(cc) + + # final 1x1 convolution corresponding to pixel-wise linear combination of feature channels + logits = tf.keras.layers.Conv2D( + filters=self.config.n_classes, + kernel_size=1)(net) + + logits = tf.keras.layers.Softmax()(logits) + + self.net = tf.keras.Model(inputs=x, outputs=logits) + + def call(self, inputs, training=None): + return self.net(inputs, training) + + +class TFCNModel(BaseSegmentationModel): + """ Implementation of a Temporal Fully-Convolutional-Network """ + + class TFCNModelSchema(BaseSegmentationModel._Schema): + n_layers = fields.Int(required=True, description='Number of layers of the FCN model', example=10) + keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) + features_root = fields.Int(required=True, description='Number of features at the root level.', example=32) + + conv_size = fields.Int(missing=3, description='Size of the convolution kernels.') + deconv_size = fields.Int(missing=2, description='Size of the deconvolution kernels.') + conv_size_reduce = fields.Int(missing=3, description='Size of the kernel for time reduction.') + conv_stride = fields.Int(missing=1, description='Stride used in convolutions.') + add_dropout = fields.Bool(missing=False, description='Add dropout to layers.') + add_batch_norm = fields.Bool(missing=True, description='Add batch normalization to layers.') + bias_init = fields.Float(missing=0.0, description='Bias initialization value.') + use_bias = fields.Bool(missing=True, description='Add bias parameters to convolutional layer.') + padding = fields.String(missing='VALID', description='Padding type used in convolutions.') + single_encoding_conv = fields.Bool(missing=False, description="Whether to apply 1 or 2 banks of conv filters.") + + pool_size = fields.Int(missing=2, description='Kernel size used in max pooling.') + pool_stride = fields.Int(missing=2, description='Stride used in max pooling.') + pool_time = fields.Bool(missing=False, description='Operate pooling over time dimension.') + + class_weights = fields.List(fields.Float, missing=None, description='Class weights used in training.') + + def build(self, inputs_shape): + + x = tf.keras.layers.Input(inputs_shape[1:]) + dropout_rate = 1 - self.config.keep_prob + + num_repetitions = 1 if self.config.single_encoding_conv else 2 + + # encoding path + net = x + connection_outputs = [] + for layer in range(self.config.n_layers): + # compute number of features as a function of network depth level + features = 2 ** layer * self.config.features_root + # bank of one 3d convolutional filter; convolution is done along the temporal as well as spatial directions + conv = Conv3D( + features, + kernel_size=self.config.conv_size, + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + num_repetitions=num_repetitions, + use_bias=self.config.use_bias, + padding=self.config.padding)(net) + + connection_outputs.append(conv) + # max pooling operation + net = MaxPool3D( + kernel_size=self.config.pool_size, + strides=self.config.pool_stride, + pool_time=self.config.pool_time)(conv) + + # Bank of 1 3d convolutional filter at bottom of FCN + bottom = Conv3D( + 2 ** self.config.n_layers * self.config.features_root, + kernel_size=self.config.conv_size, + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + num_repetitions=num_repetitions, + padding=self.config.padding, + use_bias=self.config.use_bias, + convolve_time=(not self.config.pool_time))(net) + + # Reduce temporal dimension + bottom = Reduce3DTo2D( + 2 ** self.config.n_layers * self.config.features_root, + kernel_size=self.config.conv_size_reduce, + stride=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate)(bottom) + + net = bottom + # decoding path + for layer in range(self.config.n_layers): + # find corresponding level in decoding branch + conterpart_layer = self.config.n_layers - 1 - layer + # get same number of features as counterpart layer + features = 2 ** conterpart_layer * self.config.features_root + + # transposed convolution to upsample tensors + deconv = Deconv2D( + filters=features, + kernel_size=self.config.deconv_size, + batch_normalization=self.config.add_batch_norm)(net) + + # skip connection with linear combination along time + reduced = Reduce3DTo2D( + features, + kernel_size=self.config.conv_size_reduce, + stride=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate)(connection_outputs[conterpart_layer]) + + # crop and concatenate + cc = CropAndConcat()(reduced, deconv) + + # bank of 2 convolutional layers as in standard FCN + net = Conv2D( + features, + kernel_size=self.config.conv_size, + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + use_bias=self.config.use_bias, + num_repetitions=2)(cc) + + # final 1x1 convolution corresponding to pixel-wise linear combination of feature channels + logits = tf.keras.layers.Conv2D( + filters=self.config.n_classes, + kernel_size=1)(net) + + logits = tf.keras.layers.Softmax()(logits) + + self.net = tf.keras.Model(inputs=x, outputs=logits) + + def call(self, inputs, training=None): + return self.net(inputs, training) + + +class ResUnetA(FCNModel): + """ + ResUnetA + + https://github.com/feevos/resuneta/tree/145be5519ee4bec9a8cce9e887808b8df011f520/models + + NOTE: The input to this network is a dictionary specifying input features and three output target images. This + might require some modification to the functions used to automate training and evaluation. Get in touch through + issues if this happens. + + TODO: build architecture from parameters as for FCn and TFCN + + """ + + def build(self, inputs_shape): + """Builds the net for input x.""" + x = tf.keras.layers.Input(shape=inputs_shape['features'][1:], name='features') + dropout_rate = 1 - self.config.keep_prob + + # block 1 + initial_conv = Conv2D( + filters=self.config.features_root, + kernel_size=1, # 1x1 kernel + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + use_bias=self.config.use_bias, + batch_normalization=True, + padding=self.config.padding, + num_repetitions=1)(x) + + # block 2 + resconv_1 = ResConv2D( + filters=self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1, 3, 15, 31], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + use_bias=self.config.use_bias, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=4)(initial_conv) + + # block 3 + pool_1 = Conv2D( + filters=2 * self.config.features_root, + kernel_size=self.config.pool_size, + strides=self.config.pool_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding='SAME', + num_repetitions=1)(resconv_1) + + # block 4 + resconv_2 = ResConv2D( + filters=2 * self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1, 3, 15, 31], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=4)(pool_1) + + # block 5 + pool_2 = Conv2D( + filters=4 * self.config.features_root, + kernel_size=self.config.pool_size, + strides=self.config.pool_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding='SAME', + num_repetitions=1)(resconv_2) + + # block 6 + resconv_3 = ResConv2D( + filters=4 * self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1, 3, 15], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=3)(pool_2) + + # block 7 + pool_3 = Conv2D( + filters=8 * self.config.features_root, + kernel_size=self.config.pool_size, + strides=self.config.pool_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding='SAME', + num_repetitions=1)(resconv_3) + + # block 8 + resconv_4 = ResConv2D( + filters=8 * self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1, 3, 15], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=3)(pool_3) + + # block 9 + pool_4 = Conv2D( + filters=16 * self.config.features_root, + kernel_size=self.config.pool_size, + strides=self.config.pool_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding='SAME', + num_repetitions=1)(resconv_4) + + # block 10 + resconv_5 = ResConv2D( + filters=16 * self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=1)(pool_4) + + # block 11 + pool_5 = Conv2D( + filters=32 * self.config.features_root, + kernel_size=self.config.pool_size, + strides=self.config.pool_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding='SAME', + num_repetitions=1)(resconv_5) + + # block 12 + resconv_6 = ResConv2D( + filters=32 * self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=1)(pool_5) + + # block 13 + ppm1 = PyramidPoolingModule(filters=32 * self.config.features_root, + batch_normalization=True)(resconv_6) + + # block 14 + deconv_1 = Deconv2D( + filters=32 * self.config.features_root, + kernel_size=self.config.deconv_size, + batch_normalization=self.config.add_batch_norm)(ppm1) + + # block 15 + concat_1 = CropAndConcat()(resconv_5, deconv_1) + concat_1 = Conv2D( + filters=16 * self.config.features_root, + kernel_size=1, # 1x1 kernel + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=True, # maybe + padding=self.config.padding, + num_repetitions=1)(concat_1) + + # block 16 + resconv_7 = ResConv2D( + filters=16 * self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=1)(concat_1) + + # block 17 + deconv_2 = Deconv2D( + filters=16 * self.config.features_root, + kernel_size=self.config.deconv_size, + batch_normalization=self.config.add_batch_norm)(resconv_7) + + # block 18 + concat_2 = CropAndConcat()(resconv_4, deconv_2) + concat_2 = Conv2D( + filters=8 * self.config.features_root, + kernel_size=1, # 1x1 kernel + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=True, # maybe + padding=self.config.padding, + num_repetitions=1)(concat_2) + + # block 19 + resconv_8 = ResConv2D( + filters=8 * self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1, 3, 15], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=3)(concat_2) + + # block 20 + deconv_3 = Deconv2D( + filters=8 * self.config.features_root, + kernel_size=self.config.deconv_size, + batch_normalization=self.config.add_batch_norm)(resconv_8) + + # block 21 + concat_3 = CropAndConcat()(resconv_3, deconv_3) + concat_3 = Conv2D( + filters=4 * self.config.features_root, + kernel_size=1, # 1x1 kernel + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=True, + padding=self.config.padding, + num_repetitions=1)(concat_3) + + # block 22 + resconv_9 = ResConv2D( + filters=4 * self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1, 3, 15], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=3)(concat_3) + + # block 23 + deconv_4 = Deconv2D( + filters=4 * self.config.features_root, + kernel_size=self.config.deconv_size, + batch_normalization=self.config.add_batch_norm)(resconv_9) + + # block 24 + concat_4 = CropAndConcat()(resconv_2, deconv_4) + concat_4 = Conv2D( + filters=2 * self.config.features_root, + kernel_size=1, # 1x1 kernel + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=True, + padding=self.config.padding, + num_repetitions=1)(concat_4) + + # block 25 + resconv_10 = ResConv2D( + filters=2 * self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1, 3, 15, 31], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=4)(concat_4) + + # block 26 + deconv_5 = Deconv2D( + filters=2 * self.config.features_root, + kernel_size=self.config.deconv_size, + batch_normalization=self.config.add_batch_norm)(resconv_10) + + # block 27 + concat_5 = CropAndConcat()(resconv_1, deconv_5) + concat_5 = Conv2D( + filters=self.config.features_root, + kernel_size=1, # 1x1 kernel + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=True, + padding=self.config.padding, + num_repetitions=1)(concat_5) + + # block 28 + resconv_11 = ResConv2D( + filters=self.config.features_root, + kernel_size=self.config.conv_size, + dilation=[1, 3, 15, 31], + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + padding=self.config.padding, + num_parallel=4)(concat_5) + + # block 29 + concat_6 = CropAndConcat()(initial_conv, resconv_11) + concat_6 = Conv2D( + filters=self.config.features_root, + kernel_size=1, # 1x1 kernel + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + use_bias=self.config.use_bias, + dropout_rate=dropout_rate, + batch_normalization=True, + padding=self.config.padding, + num_repetitions=1)(concat_6) + + # block 30 + ppm2 = PyramidPoolingModule(filters=self.config.features_root, + batch_normalization=True)(concat_6) + + # comditioned multi-tasking + # first get distance + distance_conv = Conv2D( + filters=self.config.features_root, + kernel_size=self.config.conv_size, + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + num_repetitions=2, + padding=self.config.padding)(concat_6) # in last layer we take the combined features + logits_distance = tf.keras.layers.Conv2D(filters=self.config.n_classes, kernel_size=1)(distance_conv) + logits_distance = tf.keras.layers.Softmax(name='distance')(logits_distance) + + # concatenate distance logits to features + dcc = CropAndConcat()(ppm2, logits_distance) + boundary_conv = Conv2D( + filters=self.config.features_root, + kernel_size=self.config.conv_size, + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + num_repetitions=1, + padding=self.config.padding)(dcc) + logits_boundary = tf.keras.layers.Conv2D(filters=self.config.n_classes, kernel_size=1)(boundary_conv) + logits_boundary = tf.keras.layers.Softmax(name='boundary')(logits_boundary) + + bdcc = CropAndConcat()(dcc, logits_boundary) + extent_conv = Conv2D( + filters=self.config.features_root, + kernel_size=self.config.conv_size, + strides=self.config.conv_stride, + add_dropout=self.config.add_dropout, + dropout_rate=dropout_rate, + batch_normalization=self.config.add_batch_norm, + num_repetitions=2, + padding=self.config.padding)(bdcc) + logits_extent = tf.keras.layers.Conv2D(filters=self.config.n_classes, kernel_size=1)(extent_conv) + logits_extent = tf.keras.layers.Softmax(name='extent')(logits_extent) + + self.net = tf.keras.Model(inputs=x, outputs=[logits_extent, logits_boundary, logits_distance]) + + def call(self, inputs, training=True): + return self.net(inputs, training) diff --git a/eo-flow/eoflow/models/tempnets_task/__init__.py b/eo-flow/eoflow/models/tempnets_task/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/eo-flow/eoflow/models/tempnets_task/cnn_tempnets.py b/eo-flow/eoflow/models/tempnets_task/cnn_tempnets.py new file mode 100644 index 0000000..163a55f --- /dev/null +++ b/eo-flow/eoflow/models/tempnets_task/cnn_tempnets.py @@ -0,0 +1,349 @@ +import logging +import tensorflow as tf +from marshmallow import fields +from marshmallow.validate import OneOf + +from keras.layers import TimeDistributed +from tensorflow.keras.layers import SimpleRNN, LSTM, GRU, Dense +from tensorflow.python.keras.utils.layer_utils import print_summary + +from eoflow.models.layers import ResidualBlock +from eoflow.models.tempnets_task.tempnets_base import BaseTempnetsModel + +from eoflow.models import transformer_encoder_layers +from eoflow.models import pse_tae_layers + + +logging.basicConfig(level=logging.INFO, + format='%(asctime)s %(levelname)s %(message)s') + + +class TCNModel(BaseTempnetsModel): + """ Implementation of the TCN network taken form the keras-TCN implementation + + https://github.com/philipperemy/keras-tcn + """ + + class TCNModelSchema(BaseTempnetsModel._Schema): + keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) + + kernel_size = fields.Int(missing=2, description='Size of the convolution kernels.') + nb_filters = fields.Int(missing=64, description='Number of convolutional filters.') + nb_conv_stacks = fields.Int(missing=1) + dilations = fields.List(fields.Int, missing=[1, 2, 4, 8, 16, 32], description='Size of dilations used in the ' + 'covolutional layers') + padding = fields.String(missing='CAUSAL', validate=OneOf(['CAUSAL', 'SAME']), + description='Padding type used in convolutions.') + use_skip_connections = fields.Bool(missing=True, description='Flag to whether to use skip connections.') + return_sequences = fields.Bool(missing=False, description='Flag to whether return sequences or not.') + activation = fields.Str(missing='linear', description='Activation function used in final filters.') + kernel_initializer = fields.Str(missing='he_normal', description='method to initialise kernel parameters.') + kernel_regularizer = fields.Float(missing=0, description='L2 regularization parameter.') + + batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') + layer_norm = fields.Bool(missing=False, description='Whether to use layer normalisation.') + + def _cnn_layer(self, net): + + dropout_rate = 1 - self.config.keep_prob + + layer = tf.keras.layers.Conv1D(filters= self.config.nb_filters, + kernel_size=self.config.kernel_size, + padding=self.config.padding, + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + if self.config.batch_norm: + layer = tf.keras.layers.BatchNormalization(axis=-1)(layer) + + layer = tf.keras.layers.Dropout(dropout_rate)(layer) + layer = tf.keras.layers.Activation(self.config.activation)(layer) + return layer + + def build(self, inputs_shape): + """ Build TCN architecture + + The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of + time-frames, and `D` the number of channels + """ + x = tf.keras.layers.Input(inputs_shape[1:]) + + dropout_rate = 1 - self.config.keep_prob + + net = x + + net = self._cnn_layer(net) + + # list to hold all the member ResidualBlocks + residual_blocks = [] + skip_connections = [] + + total_num_blocks = self.config.nb_conv_stacks * len(self.config.dilations) + if not self.config.use_skip_connections: + total_num_blocks += 1 # cheap way to do a false case for below + + for _ in range(self.config.nb_conv_stacks): + for d in self.config.dilations: + net, skip_out = ResidualBlock(dilation_rate=d, + nb_filters=self.config.nb_filters, + kernel_size=self.config.kernel_size, + padding=self.config.padding, + activation=self.config.activation, + dropout_rate=dropout_rate, + use_batch_norm=self.config.batch_norm, + use_layer_norm=self.config.layer_norm, + kernel_initializer=self.config.kernel_initializer, + last_block=len(residual_blocks) + 1 == total_num_blocks, + name=f'residual_block_{len(residual_blocks)}')(net) + residual_blocks.append(net) + skip_connections.append(skip_out) + + + # Author: @karolbadowski. + output_slice_index = int(net.shape.as_list()[1] / 2) \ + if self.config.padding.lower() == 'same' else -1 + lambda_layer = tf.keras.layers.Lambda(lambda tt: tt[:, output_slice_index, :]) + + if self.config.use_skip_connections: + net = tf.keras.layers.add(skip_connections) + + if not self.config.return_sequences: + net = lambda_layer(net) + + net = tf.keras.layers.Dense(1, activation='linear')(net) + + self.net = tf.keras.Model(inputs=x, outputs=net) + + #print_summary(self.net) + + def call(self, inputs, training=None): + return self.net(inputs, training) + + + +class TempCNNModel(BaseTempnetsModel): + """ Implementation of the TempCNN network taken from the temporalCNN implementation + + https://github.com/charlotte-pel/temporalCNN + """ + + class TempCNNModelSchema(BaseTempnetsModel._Schema): + keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) + kernel_size = fields.Int(missing=5, description='Size of the convolution kernels.') + nb_conv_filters = fields.Int(missing=16, description='Number of convolutional filters.') + nb_conv_stacks = fields.Int(missing=3, description='Number of convolutional blocks.') + nb_conv_strides = fields.Int(missing=1, description='Value of convolutional strides.') + nb_fc_neurons = fields.Int(missing=256, description='Number of Fully Connect neurons.') + nb_fc_stacks = fields.Int(missing=1, description='Number of fully connected layers.') + final_layer = fields.String(missing='Flatten', validate=OneOf(['Flatten','GlobalAveragePooling1D', 'GlobalMaxPooling1D']), + description='Final layer after the convolutions.') + padding = fields.String(missing='SAME', validate=OneOf(['SAME','VALID', 'CAUSAL']), + description='Padding type used in convolutions.') + activation = fields.Str(missing='relu', description='Activation function used in final filters.') + fc_activation = fields.Str(missing=None, description='Activation function used in final FC layers.') + kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') + kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') + enumerate = fields.Bool(missing=False, description='Increase number of filters across convolution') + batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') + + def _cnn_layer(self, net, i = 0): + + dropout_rate = 1 - self.config.keep_prob + filters = self.config.nb_conv_filters + kernel_size = self.config.kernel_size + + if self.config.enumerate: + filters = filters * (2**i) + kernel_size = kernel_size * (i+1) + + layer = tf.keras.layers.Conv1D(filters=filters, + kernel_size=kernel_size, + strides=self.config.nb_conv_strides, + padding=self.config.padding, + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + if self.config.batch_norm: + layer = tf.keras.layers.BatchNormalization(axis=-1)(layer) + + layer = tf.keras.layers.Dropout(dropout_rate)(layer) + layer = tf.keras.layers.Activation(self.config.activation)(layer) + + + return layer + + def _embeddings(self,net): + + name = "embedding" + if self.config.final_layer == 'Flatten': + net = tf.keras.layers.Flatten(name=name)(net) + elif self.config.final_layer == 'GlobalAveragePooling1D': + net = tf.keras.layers.GlobalAveragePooling1D(name=name)(net) + elif self.config.final_layer == 'GlobalMaxPooling1D': + net = tf.keras.layers.GlobalMaxPooling1D(name=name)(net) + + return net + + def _fcn_layer(self, net): + dropout_rate = 1 - self.config.keep_prob + layer_fcn = Dense(units=self.config.nb_fc_neurons, + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + if self.config.batch_norm: + layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) + + layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) + if self.config.fc_activation: + layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) + + return layer_fcn + + + def build(self, inputs_shape): + """ Build TCN architecture + + The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of + time-frames, and `D` the number of channels + """ + x = tf.keras.layers.Input(inputs_shape[1:]) + + net = x + for i, _ in enumerate(range(self.config.nb_conv_stacks)): + net = self._cnn_layer(net, i) + + net = self._embeddings(net) + self.backbone = tf.keras.Model(inputs=x, outputs=net) + + for _ in range(self.config.nb_fc_stacks): + net = self._fcn_layer(net) + + net = Dense(units = 1, + activation = 'linear', + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + + self.net = tf.keras.Model(inputs=x, outputs=net) + + print_summary(self.net) + + def call(self, inputs, training=None): + return self.net(inputs, training) + + def get_feature_map(self, inputs, training=None): + return self.backbone(inputs, training) + + + +class HistogramCNNModel(BaseTempnetsModel): + """ Implementation of the CNN2D with histogram time series + + https://cs.stanford.edu/~ermon/papers/cropyield_AAAI17.pdf + """ + + class HistogramCNNModel(BaseTempnetsModel._Schema): + keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) + kernel_size = fields.List(fields.Int, missing=2, description='Size of the convolution kernels.') + nb_conv_filters = fields.Int(missing=16, description='Number of convolutional filters.') + nb_conv_stacks = fields.Int(missing=3, description='Number of convolutional blocks.') + nb_conv_strides = fields.List(fields.Int, missing=2, description='Value of convolutional strides.') + nb_fc_neurons = fields.Int(missing=256, description='Number of Fully Connect neurons.') + nb_fc_stacks = fields.Int(missing=1, description='Number of fully connected layers.') + final_layer = fields.String(missing='Flatten', validate=OneOf(['Flatten','GlobalAveragePooling2D', 'GlobalMaxPooling2D']), + description='Final layer after the convolutions.') + padding = fields.String(missing='SAME', validate=OneOf(['SAME','VALID', 'CAUSAL']), + description='Padding type used in convolutions.') + activation = fields.Str(missing='relu', description='Activation function used in final filters.') + kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') + kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') + enumerate = fields.Bool(missing=False, description='Increase number of filters across convolution') + batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') + + def _cnn_layer(self, net, i = 1, last = False): + + dropout_rate = 1 - self.config.keep_prob + filters = self.config.nb_conv_filters + s_i, s_j = self.config.nb_conv_strides.copy() + + if self.config.enumerate: + filters = filters * (2**i) + if last: + strides = self.config.nb_conv_strides.copy() + else: + strides = (s_i * (i + 1), s_i * (i + 1)) + + print(strides) + + layer = tf.keras.layers.Conv2D(filters=filters, + kernel_size=self.config.kernel_size, + strides=strides, + padding=self.config.padding, + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + if self.config.batch_norm: + layer = tf.keras.layers.BatchNormalization(axis=-1)(layer) + + #if self.config.enumerate: layer = tf.keras.layers.MaxPool1D()(layer) + + layer = tf.keras.layers.Dropout(dropout_rate)(layer) + layer = tf.keras.layers.Activation(self.config.activation)(layer) + return layer + + def _embeddings(self,net): + + name = "embedding" + if self.config.final_layer == 'Flatten': + net = tf.keras.layers.Flatten(name=name)(net) + elif self.config.final_layer == 'GlobalAveragePooling2D': + net = tf.keras.layers.GlobalAveragePooling2D(name=name)(net) + elif self.config.final_layer == 'GlobalMaxPooling2D': + net = tf.keras.layers.GlobalMaxPooling2D(name=name)(net) + + return net + + def _fcn_layer(self, net): + dropout_rate = 1 - self.config.keep_prob + layer_fcn = Dense(units=self.config.nb_fc_neurons, + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + if self.config.batch_norm: + layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) + + layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) + layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) + + return layer_fcn + + + def build(self, inputs_shape): + """ Build TCN architecture + + The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of + time-frames, and `D` the number of channels + """ + x = tf.keras.layers.Input(inputs_shape[1:]) + + net = x + for i, _ in enumerate(range(self.config.nb_conv_stacks)): + net = self._cnn_layer(net, i) + print(net.shape) + net = self._cnn_layer(net, i, True) + print(net.shape) + + net = self._embeddings(net) + self.backbone = tf.keras.Model(inputs=x, outputs=net) + + for _ in range(self.config.nb_fc_stacks): + net = self._fcn_layer(net) + + net = Dense(units = 1, + activation = 'linear', + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + + self.net = tf.keras.Model(inputs=x, outputs=net) + + #print_summary(self.net) + + def call(self, inputs, training=None): + return self.net(inputs, training) + + def get_feature_map(self, inputs, training=None): + return self.backbone(inputs, training) diff --git a/eo-flow/eoflow/models/tempnets_task/mlp_tempnets.py b/eo-flow/eoflow/models/tempnets_task/mlp_tempnets.py new file mode 100644 index 0000000..82bd350 --- /dev/null +++ b/eo-flow/eoflow/models/tempnets_task/mlp_tempnets.py @@ -0,0 +1,182 @@ +import logging +import tensorflow as tf +from marshmallow import fields +from marshmallow.validate import OneOf + +from keras.layers import TimeDistributed +from tensorflow.keras.layers import SimpleRNN, LSTM, GRU, Dense +from tensorflow.python.keras.utils.layer_utils import print_summary + +from eoflow.models.layers import ResidualBlock +from eoflow.models.tempnets_task.tempnets_base import BaseTempnetsModel + +from eoflow.models import transformer_encoder_layers +from eoflow.models import pse_tae_layers + +logging.basicConfig(level=logging.INFO, + format='%(asctime)s %(levelname)s %(message)s') + + +class MLP(BaseTempnetsModel): + """ + Implementation of the mlp network + """ + + class MLPSchema(BaseTempnetsModel._Schema): + keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) + nb_fc_neurons = fields.Int(missing=256, description='Number of Fully Connect neurons.') + nb_fc_stacks = fields.Int(missing=1, description='Number of fully connected layers.') + activation = fields.Str(missing='relu', description='Activation function used in final filters.') + kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') + kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') + batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') + + def _fcn_layer(self, net): + dropout_rate = 1 - self.config.keep_prob + layer_fcn = Dense(units=self.config.nb_fc_neurons, + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + if self.config.batch_norm: + layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) + layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) + layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) + + return layer_fcn + + def build(self, inputs_shape): + """ Build TCN architecture + + The `inputs_shape` argument is a `(N, T*D)` tuple where `N` denotes the number of samples, `T` the number of + time-frames, and `D` the number of channels + """ + x = tf.keras.layers.Input(inputs_shape[1:]) + net = x + + for _ in range(self.config.nb_fc_stacks): + net = self._fcn_layer(net) + + net = tf.keras.layers.Dense(units = 1, + activation = 'linear', + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + + self.net = tf.keras.Model(inputs=x, outputs=net) + + print_summary(self.net) + + def call(self, inputs, training=None): + return self.net(inputs, training) + + + + +class TransformerEncoder(BaseTempnetsModel): + """ Implementation of a self-attention classifier + Code is based on the Pytorch implementation of Marc Russwurm https://github.com/MarcCoru/crop-type-mapping + """ + + class TransformerEncoderSchema(BaseTempnetsModel._Schema): + keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) + + num_heads = fields.Int(missing=8, description='Number of Attention heads.') + num_layers = fields.Int(missing=4, description='Number of encoder layers.') + num_dff = fields.Int(missing=512, description='Number of feed-forward neurons in point-wise MLP.') + d_model = fields.Int(missing=128, description='Depth of model.') + max_pos_enc = fields.Int(missing=24, description='Maximum length of positional encoding.') + layer_norm = fields.Bool(missing=True, description='Whether to apply layer normalization in the encoder.') + + activation = fields.Str(missing='linear', description='Activation function used in final dense filters.') + + def init_model(self): + + self.encoder = transformer_encoder_layers.Encoder( + num_layers=self.config.num_layers, + d_model=self.config.d_model, + num_heads=self.config.num_heads, + dff=self.config.num_dff, + maximum_position_encoding=self.config.max_pos_enc, + layer_norm=self.config.layer_norm) + + self.dense = tf.keras.layers.Dense(units=self.config.n_classes, + activation=self.config.activation) + + def build(self, inputs_shape): + """ Build Transformer encoder architecture + The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of + time-frames, and `D` the number of channels + """ + seq_len = inputs_shape[1] + + self.net = tf.keras.Sequential([ + self.encoder, + self.dense, + tf.keras.layers.MaxPool1D(pool_size=seq_len), + tf.keras.layers.Lambda(lambda x: tf.keras.backend.squeeze(x, axis=-2), name='squeeze'), + tf.keras.layers.Softmax() + ]) + # Build the model, so we can print the summary + self.net.build(inputs_shape) + + print_summary(self.net) + + def call(self, inputs, training=None, mask=None): + return self.net(inputs, training, mask) + + + + + +######################################################################################################################################################## + +class PseTae(BaseTempnetsModel): + """ Implementation of the Pixel-Set encoder + Temporal Attention Encoder sequence classifier + + Code is based on the Pytorch implementation of V. Sainte Fare Garnot et al. https://github.com/VSainteuf/pytorch-psetae + """ + + class PseTaeSchema(BaseTempnetsModel._Schema): + mlp1 = fields.List(fields.Int, missing=[10, 32, 64], description='Number of units for each layer in mlp1.') + pooling = fields.Str(missing='mean_std', description='Methods used for pooling. Seperated by underscore. (mean, std, max, min)') + mlp2 = fields.List(fields.Int, missing=[132, 128], description='Number of units for each layer in mlp2.') + + num_heads = fields.Int(missing=4, description='Number of Attention heads.') + num_dff = fields.Int(missing=32, description='Number of feed-forward neurons in point-wise MLP.') + d_model = fields.Int(missing=None, description='Depth of model.') + mlp3 = fields.List(fields.Int, missing=[512, 128, 128], description='Number of units for each layer in mlp3.') + dropout = fields.Float(missing=0.2, description='Dropout rate for attention encoder.') + T = fields.Float(missing=1000, description='Number of features for attention.') + len_max_seq = fields.Int(missing=24, description='Number of features for attention.') + mlp4 = fields.List(fields.Int, missing=[128, 64, 32], description='Number of units for each layer in mlp4. ') + + def init_model(self): + # TODO: missing features from original PseTae: + # * spatial encoder extra features (hand-made) + # * spatial encoder masking + + self.spatial_encoder = pse_tae_layers.PixelSetEncoder( + mlp1=self.config.mlp1, + mlp2=self.config.mlp2, + pooling=self.config.pooling) + + self.temporal_encoder = pse_tae_layers.TemporalAttentionEncoder( + n_head=self.config.num_heads, + d_k=self.config.num_dff, + d_model=self.config.d_model, + n_neurons=self.config.mlp3, + dropout=self.config.dropout, + T=self.config.T, + len_max_seq=self.config.len_max_seq) + + mlp4_layers = [pse_tae_layers.LinearLayer(out_dim) for out_dim in self.config.mlp4] + # Final layer (logits) + mlp4_layers.append(pse_tae_layers.LinearLayer(1, batch_norm=False, activation='linear')) + + self.mlp4 = tf.keras.Sequential(mlp4_layers) + + def call(self, inputs, training=None, mask=None): + + out = self.spatial_encoder(inputs, training=training, mask=mask) + out = self.temporal_encoder(out, training=training, mask=mask) + out = self.mlp4(out, training=training, mask=mask) + + return out diff --git a/eo-flow/eoflow/models/tempnets_task/rnn_tempnets.py b/eo-flow/eoflow/models/tempnets_task/rnn_tempnets.py new file mode 100644 index 0000000..aadcfe9 --- /dev/null +++ b/eo-flow/eoflow/models/tempnets_task/rnn_tempnets.py @@ -0,0 +1,232 @@ +import logging +import tensorflow as tf +from marshmallow import fields +from marshmallow.validate import OneOf + +from keras.layers import TimeDistributed +from tensorflow.keras.layers import SimpleRNN, LSTM, GRU, Dense +from tensorflow.python.keras.utils.layer_utils import print_summary + +from eoflow.models.layers import ResidualBlock +from eoflow.models.tempnets_task.tempnets_base import BaseTempnetsModel + +from eoflow.models import transformer_encoder_layers +from eoflow.models import pse_tae_layers + +logging.basicConfig(level=logging.INFO, + format='%(asctime)s %(levelname)s %(message)s') + +rnn_layers = dict(rnn=SimpleRNN, gru=GRU, lstm=LSTM) + + +class BiRNN(BaseTempnetsModel): + """ Implementation of a Bidirectional Recurrent Neural Network + + This implementation allows users to define which RNN layer to use, e.g. SimpleRNN, GRU or LSTM + """ + + class BiRNNModelSchema(BaseTempnetsModel._Schema): + rnn_layer = fields.String(required=True, validate=OneOf(['rnn', 'lstm', 'gru']), + description='Type of RNN layer to use') + + keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) + + rnn_units = fields.Int(missing=64, description='Size of the convolution kernels.') + rnn_blocks = fields.Int(missing=1, description='Number of LSTM blocks') + bidirectional = fields.Bool(missing=True, description='Whether to use a bidirectional layer') + + activation = fields.Str(missing='relu', description='Activation function for fully connected layers') + kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') + kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') + nb_fc_stacks = fields.Int(missing=0, description='Number of fully connected layers.') + nb_fc_neurons = fields.Int(missing=0, description='Number of fully connected neurons.') + + layer_norm = fields.Bool(missing=True, description='Whether to apply layer normalization in the encoder.') + batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') + + def _rnn_layer(self, net, last=False): + """ Returns a RNN layer for current configuration. Use `last=True` for the last RNN layer. """ + RNNLayer = rnn_layers[self.config.rnn_layer] + dropout_rate = 1 - self.config.keep_prob + + layer = RNNLayer( + units=self.config.rnn_units, + dropout=dropout_rate, + return_sequences=not last, + ) + + # Use bidirectional if specified + if self.config.bidirectional: + layer = tf.keras.layers.Bidirectional(layer) + + return layer(net) + + + def _fcn_layer(self, net): + dropout_rate = 1 - self.config.keep_prob + layer_fcn = Dense(units=self.config.nb_fc_neurons, + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + if self.config.batch_norm: + layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) + layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) + layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) + + return layer_fcn + + def build(self, inputs_shape): + """ Creates the RNN model architecture. """ + + x = tf.keras.layers.Input(inputs_shape[1:]) + net = x + + if self.config.layer_norm: + net = tf.keras.layers.LayerNormalization(axis=-1)(net) + + for _ in range(self.config.rnn_blocks -1): + net = self._rnn_layer(net) + net = self._rnn_layer(net, last=True) + + if self.config.layer_norm: + net = tf.keras.layers.LayerNormalization(axis=-1)(net) + + for _ in range(self.config.nb_fc_stacks): + net = self._fcn_layer(net) + + net = tf.keras.layers.Dense(units=1, + activation='linear', + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + + self.net = tf.keras.Model(inputs=x, outputs=net) + + print_summary(self.net) + + def call(self, inputs, training=None): + return self.net(inputs, training) + + + +#https://www.sciencedirect.com/science/article/pii/S0034425721003205 + + +class ConvLSTM(BaseTempnetsModel): + """ Implementation of a Bidirectional Recurrent Neural Network + + This implementation allows users to define which RNN layer to use, e.g. SimpleRNN, GRU or LSTM + """ + + + class ConvLSTMShema(BaseTempnetsModel._Schema): + keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) + kernel_size = fields.Int(missing=5, description='Size of the convolution kernels.') + nb_conv_filters = fields.Int(missing=16, description='Number of convolutional filters.') + nb_conv_stacks = fields.Int(missing=3, description='Number of convolutional blocks.') + nb_conv_strides = fields.Int(missing=1, description='Value of convolutional strides.') + nb_fc_neurons = fields.Int(missing=256, description='Number of Fully Connect neurons.') + nb_fc_stacks = fields.Int(missing=1, description='Number of fully connected layers.') + + padding = fields.String(missing='SAME', validate=OneOf(['SAME','VALID', 'CAUSAL']), + description='Padding type used in convolutions.') + activation = fields.Str(missing='relu', description='Activation function used in final filters.') + kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') + kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') + enumerate = fields.Bool(missing=False, description='Increase number of filters across convolution') + batch_norm = fields.Bool(missing=True, description='Whether to use batch normalisation.') + + rnn_layer = fields.String(required=True, validate=OneOf(['rnn', 'lstm', 'gru']), + description='Type of RNN layer to use') + rnn_units = fields.Int(missing=64, description='Size of the convolution kernels.') + rnn_blocks = fields.Int(missing=1, description='Number of LSTM blocks') + bidirectional = fields.Bool(missing=False, description='Whether to use a bidirectional layer') + layer_norm = fields.Bool(missing=True, description='Whether to apply layer normalization in the encoder.') + + def _cnn_layer(self, net, i = 0): + + dropout_rate = 1 - self.config.keep_prob + filters = self.config.nb_conv_filters + kernel_size = self.config.kernel_size + + if self.config.enumerate: + filters = filters * (2**i) + kernel_size = kernel_size * (i+1) + + layer = tf.keras.layers.Conv1D(filters=filters, + kernel_size=kernel_size, + strides=self.config.nb_conv_strides, + padding=self.config.padding, + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + if self.config.batch_norm: + layer = tf.keras.layers.BatchNormalization(axis=-1)(layer) + + layer = tf.keras.layers.Dropout(dropout_rate)(layer) + layer = tf.keras.layers.Activation(self.config.activation)(layer) + + return layer + + def _rnn_layer(self, net, last=False): + """ Returns a RNN layer for current configuration. Use `last=True` for the last RNN layer. """ + RNNLayer = rnn_layers[self.config.rnn_layer] + dropout_rate = 1 - self.config.keep_prob + + layer = RNNLayer( + units=self.config.rnn_units, + dropout=dropout_rate, + return_sequences=not last, + ) + + # Use bidirectional if specified + if self.config.bidirectional: + layer = tf.keras.layers.Bidirectional(layer) + + return layer(net) + + def _fcn_layer(self, net): + dropout_rate = 1 - self.config.keep_prob + layer_fcn = Dense(units=self.config.nb_fc_neurons, + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + if self.config.batch_norm: + layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) + + layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) + layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) + + + return layer_fcn + + def build(self, inputs_shape): + """ Build TCN architecture + + The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of + time-frames, and `D` the number of channels + """ + x = tf.keras.layers.Input(shape = inputs_shape[1:]) + print(x.shape) + net = x + for i, _ in enumerate(range(self.config.nb_conv_stacks)): + net = self._cnn_layer(net, i) + + for i, _ in range(self.config.rnn_blocks-1): + net = self._rnn_layer(net) + net = self._rnn_layer(net, last=True) + + for _ in range(self.config.nb_fc_stacks): + net = self._fcn_layer(net) + + net = Dense(units = 1, + activation = 'linear', + kernel_initializer=self.config.kernel_initializer, + kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) + + self.net = tf.keras.Model(inputs=x, outputs=net) + + print_summary(self.net) + + def call(self, inputs, training=None): + return self.net(inputs, training) + + def get_feature_map(self, inputs, training=None): + return self.backbone(inputs, training) + diff --git a/eo-flow/eoflow/models/tempnets_task/tempnets_base.py b/eo-flow/eoflow/models/tempnets_task/tempnets_base.py new file mode 100644 index 0000000..fbfa446 --- /dev/null +++ b/eo-flow/eoflow/models/tempnets_task/tempnets_base.py @@ -0,0 +1,173 @@ +import logging + +import tensorflow as tf + +from marshmallow import Schema, fields +from marshmallow.validate import OneOf, ContainsOnly + +from eoflow.base import BaseModelTraining, BaseModelCustomTraining +import tensorflow as tensorflow + +from eoflow.models.losses import CategoricalCrossEntropy, CategoricalFocalLoss +from eoflow.models.metrics import InitializableMetric, RSquared + + +logging.basicConfig(level=logging.INFO, + format='%(asctime)s %(levelname)s %(message)s') + + +# Available losses. Add keys with new losses here. +dictionary_losses = { + 'mse': tensorflow.keras.losses.MeanSquaredError, + 'huber': tensorflow.keras.losses.Huber, + 'mae': tensorflow.keras.losses.MeanAbsoluteError, + 'cross_entropy': CategoricalCrossEntropy, + 'focal_loss': CategoricalFocalLoss +} + +# Available metrics. Add keys with new metrics here. +dictionary_metrics = { + 'mse': tf.keras.metrics.MeanSquaredError, + 'mape': tf.keras.metrics.MeanAbsolutePercentageError, + 'mae': tf.keras.metrics.MeanAbsoluteError, + 'accuracy': tf.keras.metrics.CategoricalAccuracy(name='accuracy'), + 'precision': tf.keras.metrics.Precision, + 'recall': tf.keras.metrics.Recall, + 'r_square' : RSquared +} + + + +class BaseTempnetsModel(BaseModelTraining): + """ Base for pixel-wise classification models. """ + + class _Schema(Schema): + #n_outputs = fields.Int(required=True, description='Number of output layers', example=1) + learning_rate = fields.Float(missing=None, description='Learning rate used in training.', example=0.001) + loss = fields.String(missing='mse', description='Loss function used for training.', + validate=OneOf(dictionary_losses.keys())) + metrics = fields.List(fields.String, missing=['mse'], + description='List of metrics used for evaluation.', + validate=ContainsOnly(dictionary_metrics.keys())) + + def prepare(self, optimizer=None, loss=None, metrics=None, **kwargs): + """ Prepares the model. Optimizer, loss and metrics are read using the following protocol: + * If an argument is None, the default value is used from the configuration of the model. + * If an argument is a key contained in segmentation specific losses/metrics, those are used. + * Otherwise the argument is passed to `compile` as is. + + """ + # Read defaults if None + if optimizer is None: + optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate) + + if loss is None: + loss = self.config.loss + + if metrics is None: + metrics = self.config.metric + + loss = dictionary_losses[loss](**kwargs) + + reported_metrics = [] + for metric in metrics: + + if metric in dictionary_metrics: + metric = dictionary_metrics[metric](**kwargs) + + # Initialize initializable metrics + if isinstance(metric, InitializableMetric): + metric.init_from_config(self.config) + + reported_metrics.append(metric) + + self.compile(optimizer=optimizer, loss=loss, metrics=reported_metrics, **kwargs) + + # Override default method to add prediction visualization + def train(self, + dataset, + num_epochs, + model_directory, + iterations_per_epoch=None, + callbacks=[], + save_steps='epoch', + summary_steps=1, **kwargs): + + super().train(dataset, num_epochs, model_directory, iterations_per_epoch, + callbacks=callbacks, save_steps=save_steps, + summary_steps=summary_steps, **kwargs) + + # Override default method to add prediction visualization + def train_and_evaluate(self, + train_dataset, + val_dataset, + num_epochs, + iterations_per_epoch, + model_directory, + save_steps=100, + summary_steps=10, + callbacks=[], **kwargs): + + super().train_and_evaluate(train_dataset, val_dataset, + num_epochs, iterations_per_epoch, + model_directory, + save_steps=save_steps, summary_steps=summary_steps, + callbacks=callbacks, **kwargs) + + + +''' +class BaseTempnetsModel(BaseModelCustomTraining): + """ Base for pixel-wise classification models. """ + + class _Schema(Schema): + #n_outputs = fields.Int(required=True, description='Number of output layers', example=1) + learning_rate = fields.Float(missing=None, description='Learning rate used in training.', example=0.001) + loss = fields.String(missing='mse', description='Loss function used for training.', + validate=OneOf(dictionary_losses.keys())) + metrics = fields.String(missing='mse', + description='List of metrics used for evaluation.', + validate=OneOf(dictionary_metrics.keys())) + + def prepare(self, optimizer=None, loss=None, metrics=None, + loss_metric = tf.keras.metrics.Mean(), + **kwargs): + """ Prepares the model. Optimizer, loss and metrics are read using the following protocol: + * If an argument is None, the default value is used from the configuration of the model. + * If an argument is a key contained in segmentation specific losses/metrics, those are used. + * Otherwise the argument is passed to `compile` as is. + + """ + # Read defaults if None + if optimizer is None: + optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate) + + if loss is None: + loss = self.config.loss + loss = dictionary_losses[loss](**kwargs) + self.loss_metric = loss_metric + + if metrics is None: + metrics = self.config.metrics + self.metric = dictionary_metrics[metrics](**kwargs) + + if isinstance(self.metric, InitializableMetric): + self.metric.init_from_config(self.config) + + self.compile(optimizer=optimizer, loss=loss, metrics=self.metric, **kwargs) + + # Override default method to add prediction visualization + def train_and_evaluate(self, + train_dataset, + val_dataset, + num_epochs, + iterations_per_epoch, + model_directory, + **kwargs): + + super().train_and_evaluate(train_dataset, val_dataset, + num_epochs, iterations_per_epoch, + model_directory, + **kwargs) + +''' \ No newline at end of file diff --git a/eo-flow/eoflow/models/transformer_encoder_layers.py b/eo-flow/eoflow/models/transformer_encoder_layers.py new file mode 100644 index 0000000..08b86d6 --- /dev/null +++ b/eo-flow/eoflow/models/transformer_encoder_layers.py @@ -0,0 +1,193 @@ +import tensorflow as tf +import numpy as np + +from tensorflow.keras.layers import Conv1D, LayerNormalization + +# This code is taken from the TF tutorial on transformers +# https://www.tensorflow.org/tutorials/text/transformer +def scaled_dot_product_attention(q, k, v, mask=None): + """ Calculate the attention weights. + q, k, v must have matching leading dimensions. + k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v. + The mask has different shapes depending on its type(padding or look ahead) + but it must be broadcastable for addition. + + Args: + q: query shape == (..., seq_len_q, depth) + k: key shape == (..., seq_len_k, depth) + v: value shape == (..., seq_len_v, depth_v) + mask: Float tensor with shape broadcastable + to (..., seq_len_q, seq_len_k). Defaults to None. + + Returns: + output, attention_weights + """ + + matmul_qk = tf.matmul(q, k, transpose_b=True) # (..., seq_len_q, seq_len_k) + + # scale matmul_qk + dk = tf.cast(tf.shape(k)[-1], tf.float32) + scaled_attention_logits = matmul_qk / tf.math.sqrt(dk) + + # add the mask to the scaled tensor. + if mask is not None: + scaled_attention_logits += (mask * -1e9) + + # softmax is normalized on the last axis (seq_len_k) so that the scores + # add up to 1. + attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1) # (..., seq_len_q, seq_len_k) + + output = tf.matmul(attention_weights, v) # (..., seq_len_q, depth_v) + + return output, attention_weights + + +class MultiHeadAttention(tf.keras.layers.Layer): + def __init__(self, d_model, num_heads): + super(MultiHeadAttention, self).__init__() + self.num_heads = num_heads + self.d_model = d_model + + assert d_model % self.num_heads == 0 + + self.depth = d_model // self.num_heads + + self.wq = tf.keras.layers.Dense(d_model) + self.wk = tf.keras.layers.Dense(d_model) + self.wv = tf.keras.layers.Dense(d_model) + + self.dense = tf.keras.layers.Dense(d_model) + + def split_heads(self, x, batch_size): + """Split the last dimension into (num_heads, depth). + Transpose the result such that the shape is (batch_size, num_heads, seq_len, depth) + """ + x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth)) + return tf.transpose(x, perm=[0, 2, 1, 3]) + + def call(self, v, k, q, mask=None): + batch_size = tf.shape(q)[0] + + q = self.wq(q) # (batch_size, seq_len, d_model) + k = self.wk(k) # (batch_size, seq_len, d_model) + v = self.wv(v) # (batch_size, seq_len, d_model) + + q = self.split_heads(q, batch_size) # (batch_size, num_heads, seq_len_q, depth) + k = self.split_heads(k, batch_size) # (batch_size, num_heads, seq_len_k, depth) + v = self.split_heads(v, batch_size) # (batch_size, num_heads, seq_len_v, depth) + + # scaled_attention.shape == (batch_size, num_heads, seq_len_q, depth) + # attention_weights.shape == (batch_size, num_heads, seq_len_q, seq_len_k) + scaled_attention, attention_weights = scaled_dot_product_attention(q, k, v, mask) + + # (batch_size, seq_len_q, num_heads, depth) + scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3]) + + # (batch_size, seq_len_q, d_model) + concat_attention = tf.reshape(scaled_attention, (batch_size, -1, self.d_model)) + + # (batch_size, seq_len_q, d_model) + output = self.dense(concat_attention) + + return output, attention_weights + + +def point_wise_feed_forward_network(d_model, dff): + return tf.keras.Sequential([ + tf.keras.layers.Dense(dff, activation='relu'), # (batch_size, seq_len, dff) + tf.keras.layers.Dense(d_model) # (batch_size, seq_len, d_model) + ]) + + +def positional_encoding(positions, d_model, T=10000): + + if isinstance(positions, int): + positions = np.arange(positions) + else: + positions = np.array(positions) + + def _get_angles(pos, i, d_model): + angle_rates = 1 / np.power(T, (2 * (i//2)) / np.float32(d_model)) + return pos * angle_rates + + depths = np.arange(d_model) + + angle_rads = _get_angles(positions[:, np.newaxis], + depths[np.newaxis, :], + d_model) + + # apply sin to even indices in the array; 2i + angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2]) + + # apply cos to odd indices in the array; 2i+1 + angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2]) + + pos_encoding = angle_rads[np.newaxis, ...] + + return tf.cast(pos_encoding, dtype=tf.float32) + + +class EncoderLayer(tf.keras.layers.Layer): + def __init__(self, d_model, num_heads, dff, rate=0.1): + super(EncoderLayer, self).__init__() + + self.mha = MultiHeadAttention(d_model, num_heads) + self.ffn = point_wise_feed_forward_network(d_model, dff) + + self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6) + self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6) + + self.dropout1 = tf.keras.layers.Dropout(rate) + self.dropout2 = tf.keras.layers.Dropout(rate) + + def call(self, x, training=None, mask=None): + attn_output, _ = self.mha(x, x, x, mask) # (batch_size, input_seq_len, d_model) + attn_output = self.dropout1(attn_output, training=training) + out1 = self.layernorm1(x + attn_output) # (batch_size, input_seq_len, d_model) + + ffn_output = self.ffn(out1) # (batch_size, input_seq_len, d_model) + ffn_output = self.dropout2(ffn_output, training=training) + return self.layernorm2(out1 + ffn_output) + + +class Encoder(tf.keras.layers.Layer): + def __init__(self, num_layers, d_model, num_heads, dff, maximum_position_encoding, rate=0.1, layer_norm=False, T=10000): + super(Encoder, self).__init__() + + self.d_model = d_model + self.num_layers = num_layers + + self.lnorm_in = tf.keras.layers.LayerNormalization() if layer_norm else None + self.lnorm_conv = tf.keras.layers.LayerNormalization() if layer_norm else None + + # replace embedding with 1d convolution + self.conv_in = Conv1D(d_model, 1) + # self.embedding = tf.keras.layers.Embedding(input_vocab_size, d_model) + self.pos_encoding = positional_encoding(maximum_position_encoding, self.d_model, T=T) + + encoder_layers = [EncoderLayer(d_model, num_heads, dff, rate) + for _ in range(num_layers)] + self.encoder = tf.keras.Sequential(encoder_layers) + + self.dropout = tf.keras.layers.Dropout(rate) + + + def call(self, x, training=None, mask=None): + seq_len = tf.shape(x)[1] + + if self.lnorm_in: + x = self.lnorm_in(x) + + # adding embedding and position encoding. + x = self.conv_in(x, training=training) # (batch_size, input_seq_len, d_model) + if self.lnorm_conv: + x = self.lnorm_conv(x) + + x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32)) + x += self.pos_encoding[:, :seq_len, :] + + x = self.dropout(x, training=training) + + x = self.encoder(x, training=training, mask=mask) + + return x # (batch_size, input_seq_len, d_model) diff --git a/eo-flow/eoflow/tasks/__init__.py b/eo-flow/eoflow/tasks/__init__.py new file mode 100644 index 0000000..6f0263f --- /dev/null +++ b/eo-flow/eoflow/tasks/__init__.py @@ -0,0 +1,3 @@ +from .train import TrainTask, TrainAndEvaluateTask +from .predict import PredictTask +from .evaluate import EvaluateTask diff --git a/eo-flow/eoflow/tasks/evaluate.py b/eo-flow/eoflow/tasks/evaluate.py new file mode 100644 index 0000000..51197d5 --- /dev/null +++ b/eo-flow/eoflow/tasks/evaluate.py @@ -0,0 +1,28 @@ +from marshmallow import Schema, fields + +from ..base import BaseTask +from ..base.configuration import ObjectConfiguration + + +class EvaluateTask(BaseTask): + class EvaluateTaskConfig(Schema): + model_directory = fields.String(required=True, description='Directory of the model', example='/tmp/model/') + + input_config = fields.Nested(nested=ObjectConfiguration, required=True, + description="Input type and configuration.") + + def run(self): + dataset = self.parse_input(self.config.input_config) + + self.model.prepare() + self.model.load_latest(self.config.model_directory) + + values = self.model.evaluate(dataset) + names = self.model.metrics_names + + metrics = {name:value for name,value in zip(names, values)} + + # Display metrics + print("Evaluation results:") + for metric_name in metrics: + print("{}: {}".format(metric_name, metrics[metric_name])) diff --git a/eo-flow/eoflow/tasks/predict.py b/eo-flow/eoflow/tasks/predict.py new file mode 100644 index 0000000..456049b --- /dev/null +++ b/eo-flow/eoflow/tasks/predict.py @@ -0,0 +1,21 @@ +from marshmallow import Schema, fields + +from ..base import BaseTask +from ..base.configuration import ObjectConfiguration + + +class PredictTask(BaseTask): + class PredictTaskConfig(Schema): + model_directory = fields.String(required=True, description='Directory of the model', example='/tmp/model/') + + input_config = fields.Nested(nested=ObjectConfiguration, required=True, + description="Input type and configuration.") + + def run(self): + dataset_fn = self.parse_input(self.config.input_config) + + self.model.prepare() # TODO: find a way to initialize without compiling the model + self.model.load_latest(self.config.model_directory) + + predictions_list = self.model.predict(dataset_fn) + # TODO: something with predictions diff --git a/eo-flow/eoflow/tasks/train.py b/eo-flow/eoflow/tasks/train.py new file mode 100644 index 0000000..2cd59d7 --- /dev/null +++ b/eo-flow/eoflow/tasks/train.py @@ -0,0 +1,61 @@ +from marshmallow import Schema, fields + +from ..base import BaseTask +from ..base.configuration import ObjectConfiguration +#https://github.com/sghoshjr/Domain-Adversarial-Neural-Network/blob/master/DANN.py + +class TrainTask(BaseTask): + class TrainTaskConfig(Schema): + num_epochs = fields.Int(required=True, description='Number of epochs used in training', example=50) + iterations_per_epoch = fields.Int(required=True, description='Number of training steps per epoch', example=100) + model_directory = fields.String(required=True, description='Directory of the model output', example='/tmp/model/') + + input_config = fields.Nested(nested=ObjectConfiguration, required=True, description="Input type and configuration.") + + save_steps = fields.Int(missing=100, description="Number of training steps between model checkpoints.") + summary_steps = fields.Int(missing='epoch', description="Number of training steps between recording summaries.") + + def run(self): + dataset = self.parse_input(self.config.input_config) + + self.model.prepare() + + self.model.train( + dataset, + num_epochs=self.config.num_epochs, + iterations_per_epoch=self.config.iterations_per_epoch, + model_directory=self.config.model_directory, + save_steps=self.config.save_steps, + summary_steps=self.config.summary_steps + ) + + +class TrainAndEvaluateTask(BaseTask): + class TrainAndEvaluateTask(Schema): + num_epochs = fields.Int(required=True, description='Number of epochs used in training', example=50) + iterations_per_epoch = fields.Int(required=True, description='Number of training steps per epoch', example=100) + model_directory = fields.String(required=True, description='Directory of the model output', + example='/tmp/model/') + + train_input_config = fields.Nested(nested=ObjectConfiguration, required=True, + description="Input type and configuration for training.") + val_input_config = fields.Nested(nested=ObjectConfiguration, required=True, + description="Input type and configuration for validation.") + + save_steps = fields.Int(missing=100, description="Number of training steps between model checkpoints.") + summary_steps = fields.Int(missing='epoch', description="Number of training steps between recording summaries.") + + def run(self): + train_dataset = self.parse_input(self.config.train_input_config) + val_dataset = self.parse_input(self.config.val_input_config) + + self.model.prepare() + + self.model.train_and_evaluate( + train_dataset, val_dataset, + num_epochs=self.config.num_epochs, + iterations_per_epoch=self.config.iterations_per_epoch, + model_directory=self.config.model_directory, + save_steps=self.config.save_steps, + summary_steps=self.config.summary_steps + ) diff --git a/eo-flow/eoflow/utils/__init__.py b/eo-flow/eoflow/utils/__init__.py new file mode 100644 index 0000000..d663b85 --- /dev/null +++ b/eo-flow/eoflow/utils/__init__.py @@ -0,0 +1,2 @@ +from .utils import create_dirs, parse_classname, get_common_shape + diff --git a/eo-flow/eoflow/utils/tf_utils.py b/eo-flow/eoflow/utils/tf_utils.py new file mode 100644 index 0000000..b9f3c14 --- /dev/null +++ b/eo-flow/eoflow/utils/tf_utils.py @@ -0,0 +1,21 @@ +import tensorflow as tf +import io +import matplotlib.pyplot as plt + + +def plot_to_image(figure): + """ Converts the matplotlib plot specified by 'figure' to a PNG image and + returns it. The supplied figure is closed and inaccessible after this call. """ + + # Save the plot to a PNG in memory. + buf = io.BytesIO() + plt.savefig(buf, format='png') + # Closing the figure prevents it from being displayed directly inside + # the notebook. + plt.close(figure) + buf.seek(0) + # Convert PNG buffer to TF image + image = tf.image.decode_png(buf.getvalue(), channels=4) + # Add the batch dimension + image = tf.expand_dims(image, 0) + return image diff --git a/eo-flow/eoflow/utils/utils.py b/eo-flow/eoflow/utils/utils.py new file mode 100644 index 0000000..749c31a --- /dev/null +++ b/eo-flow/eoflow/utils/utils.py @@ -0,0 +1,34 @@ +import os +from pydoc import locate + + +def parse_classname(classname): + return locate(classname) + + +def create_dirs(dirs): + """ + dirs - a list of directories to create if these directories are not found + :param dirs: + :return exit_code: 0:success -1:failed + """ + try: + for dir_ in dirs: + if not os.path.exists(dir_): + os.makedirs(dir_) + return 0 + except Exception as err: + print("Creating directories error: {0}".format(err)) + exit(-1) + + +def get_common_shape(shape1, shape2): + """ Get a common shape that fits both shapes. Dimensions that differ in size are set to None. + Example: [None, 20, 100, 50], [None, 20, 200, 50] -> [None, 20, None, 50] + """ + if len(shape1) != len(shape2): + raise ValueError("Can't compute common shape. Ndims is different.") + + common_shape = [dim1 if dim1==dim2 else None for dim1, dim2 in zip(shape1, shape2)] + + return common_shape diff --git a/eo-flow/examples/exporting_data.ipynb b/eo-flow/examples/exporting_data.ipynb new file mode 100644 index 0000000..018ecdb --- /dev/null +++ b/eo-flow/examples/exporting_data.ipynb @@ -0,0 +1,196 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exporting data with numpy and h5py\n", + "\n", + "This notebook shows different ways to export the data for eoflow using numpy or h5py." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np\n", + "import h5py" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create temp dir\n", + "os.makedirs('temp')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Method 1: saving arrays using numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's create some numpy arrays to represent our features and labels." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "features = np.random.random(size=(1024, 32, 32, 13))\n", + "labels = np.random.randint(10, size=(1024,))\n", + "\n", + "features.shape, labels.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For numpy use the `np.savez` function to save multiple arrays into a single `.npz` file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.savez('temp/data.npz', features=features, labels=labels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Numpy reads and writes the whole file at the same time. Therefore the file size should be small to reduce the overhead.\n", + "\n", + "If the dataset size is large (can't fit into memory) it is better to split the dataset into multiple .npz files, or use the hdf5 format." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Method 2: saving arrays using h5py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's save the same data using the h5py library." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with h5py.File('temp/data.hdf5', 'w') as file:\n", + " file.create_dataset('features', data=features)\n", + " file.create_dataset('labels', data=labels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The h5py allows us to create seperate datasets (and groups of datasets) and save the data to it. The format also allows for sequential reading. This means that only part of the data that is needed can be loaded. Therefore the spliting of the dataset into smaller pieces is not needed anymore.\n", + "\n", + "However, if the dataset we want to export is too big to fit into memory we cannot use this method to export the data. That's where the **Method 3** comes in." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Method 3: saving arrays iteratively using h5py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The h5py allows us to write the data in parts (e.g. row by row). The datasets we create can be indexed and written to similarly to numpy arrays. Let's export a dataset produced from a generator." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def _generate_data(num_examples):\n", + " \"\"\" Generates specified number of examples (example by example).\"\"\"\n", + " \n", + " for i in range(num_examples):\n", + " features = np.random.random(size=(32, 32, 13))\n", + " labels = np.random.randint(10, size=())\n", + " \n", + " yield features, labels" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with h5py.File('temp/data_gen.hdf5', 'w') as file:\n", + " num_examples = 1024\n", + " \n", + " # Define datasets (total shape)\n", + " features_ds = file.create_dataset('features', (num_examples, 32, 32, 13), dtype=np.float32)\n", + " labels_ds = file.create_dataset('labels', (num_examples,), dtype=np.int32)\n", + " \n", + " # Store the generated data into the datasets\n", + " for i, (features, labels) in enumerate(_generate_data(num_examples)):\n", + " features_ds[i] = features\n", + " labels_ds[i] = labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**NOTE**: the `data_gen.hdf5` size is smaller, because we specified the dtype of the features to be float32, while the original dtype of the array is float64." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tf2", + "language": "python", + "name": "tf2" + }, + "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.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/eo-flow/examples/input.py b/eo-flow/examples/input.py new file mode 100644 index 0000000..6b4f429 --- /dev/null +++ b/eo-flow/examples/input.py @@ -0,0 +1,122 @@ +import json + +import numpy as np +import tensorflow as tf +from marshmallow import fields, Schema + +from eolearn.core import FeatureType +from eoflow.base import BaseInput +from eoflow.input.eopatch import eopatch_dataset, EOPatchSegmentationInput +from eoflow.input.operations import extract_subpatches, augment_data, cache_dataset + +_valid_types = [t.value for t in FeatureType] + + +class ExampleInput(BaseInput): + """ A simple example of an Input class. Produces random data. """ + + class _Schema(Schema): + input_shape = fields.List(fields.Int, description="Shape of a single input example.", required=True, example=[784]) + num_classes = fields.Int(description="Number of classes.", required=True, example=10) + + batch_size = fields.Int(description="Number of examples in a batch.", required=True, example=20) + batches_per_epoch = fields.Int(required=True, description='Number of batches in epoch', example=20) + + def _generate_batch(self): + """ Generator that returns random features and labels. """ + + for i in range(self.config.batches_per_epoch): + input_shape = [self.config.batch_size] + self.config.input_shape + input_data = np.random.rand(*input_shape) + + onehot = np.eye(self.config.num_classes) + output_shape = [self.config.batch_size] + classes = np.random.randint(self.config.num_classes, size=output_shape) + labels = onehot[classes] + + yield input_data, labels + + def get_dataset(self): + input_shape = [self.config.batch_size] + self.config.input_shape + output_shape = [self.config.batch_size, self.config.num_classes] + + # Create a tf dataset from a np.array generator + dataset = tf.data.Dataset.from_generator( + self._generate_batch, + (tf.float32, tf.float32), + (tf.TensorShape(input_shape), tf.TensorShape(output_shape)) + ) + + return dataset + + +class EOPatchInputExample(BaseInput): + """ An example input method for EOPatches. Shows feature reading, subpatch extraction, data augmentation, + caching, batching, etc. """ + + # Configuration schema (extended from EOPatchSegmentationInput) + class _Schema(EOPatchSegmentationInput._Schema): + # New fields + patch_size = fields.List(fields.Int, description="Width and height of extracted patches.", required=True, example=[1,2]) + num_subpatches = fields.Int(required=True, description="Number of subpatches extracted by random sampling.", example=5) + + interleave_size = fields.Int(description="Number of eopatches to interleave the subpatches from.", required=True, example=5) + data_augmentation = fields.Bool(missing=False, description="Use data augmentation on images.") + + cache_file = fields.String( + missing=None, description="A path to the file where the dataset will be cached. No caching if not provided.", example='/tmp/data') + + @staticmethod + def _parse_shape(shape): + shape = [None if s < 0 else s for s in shape] + return shape + + def get_dataset(self): + cfg = self.config + print(json.dumps(cfg, indent=4)) + + # Create a tf.data.Dataset from EOPatches + features_data = [ + (cfg.input_feature_type, cfg.input_feature_name, 'features', np.float32, self._parse_shape(cfg.input_feature_shape)), + (cfg.labels_feature_type, cfg.labels_feature_name, 'labels', np.int64, self._parse_shape(cfg.labels_feature_shape)) + ] + dataset = eopatch_dataset(self.config.data_dir, features_data, fill_na=-2) + + # Extract random subpatches + extract_fn = extract_subpatches( + self.config.patch_size, + [('features', self.config.input_feature_axis), + ('labels', self.config.labels_feature_axis)], + random_sampling=True, + num_random_samples=self.config.num_subpatches + ) + # Interleave patches extracted from multiple EOPatches + dataset = dataset.interleave(extract_fn, self.config.interleave_size) + + # Cache the dataset so the patch extraction is done only once + if self.config.cache_file is not None: + dataset = cache_dataset(dataset, self.config.cache_file) + + # Data augmentation + if cfg.data_augmentation: + feature_augmentation = [ + ('features', ['flip_left_right', 'rotate', 'brightness']), + ('labels', ['flip_left_right', 'rotate']) + ] + dataset = dataset.map(augment_data(feature_augmentation)) + + # One-hot encode labels and return tuple + def _prepare_data(data): + features = data['features'] + labels = data['labels'][..., 0] + + labels_oh = tf.one_hot(labels, depth=self.config.num_classes) + + return features, labels_oh + + dataset = dataset.map(_prepare_data) + + # Create batches + dataset = dataset.batch(self.config.batch_size) + + return dataset diff --git a/eo-flow/examples/models.py b/eo-flow/examples/models.py new file mode 100644 index 0000000..2d4d347 --- /dev/null +++ b/eo-flow/examples/models.py @@ -0,0 +1,39 @@ +from eoflow.base import BaseModelTraining +import tensorflow as tf + +from marshmallow import Schema, fields + + +class ExampleModel(BaseModelTraining): + """ Example implementation of a model. Builds a fully connected net with a single hidden layer. """ + + class _Schema(Schema): + output_size = fields.Int(required=True, description='Output size of the model', example=10) + hidden_units = fields.Int(missing=512, description='Number of hidden units', example=512) + learning_rate = fields.Float(missing=0.01, description='Learning rate for Adam optimizer', example=0.01) + + def init_model(self): + l1 = tf.keras.layers.Dense(self.config.hidden_units, activation='relu') + l2 = tf.keras.layers.Dense(self.config.output_size, activation='softmax') + + self.net = tf.keras.Sequential([l1, l2]) + + def call(self, inputs, training=False): + x = self.net(inputs) + + return x + + def prepare(self, optimizer=None, loss=None, metrics=None, **kwargs): + """ Prepares the model. Optimizer, loss and metrics are read using the following protocol: + * If an argument is None, the default value is used from the configuration of the model. + * If an argument is a key contained in segmentation specific losses/metrics, those are used. + * Otherwise the argument is passed to `compile` as is. + + """ + optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate) + + loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True) + + metrics = tf.keras.metric.CategoricalAccuracy(name='accuracy') + + self.compile(optimizer=optimizer, loss=loss, metrics=[metrics], **kwargs) diff --git a/eo-flow/examples/notebook_classification.ipynb b/eo-flow/examples/notebook_classification.ipynb new file mode 100644 index 0000000..8f3c83c --- /dev/null +++ b/eo-flow/examples/notebook_classification.ipynb @@ -0,0 +1,662 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training and evaluation in `eo-flow`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set up paths to data and check few EOPatches, and get some stats on label distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "from eolearn.core import EOPatch, FeatureType\n", + "import numpy as np\n", + "%pylab inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Path to your `EOPatch` folders, split into `train` and `test` sub-folders" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "root_dir = 'path-to-eopatches'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check an EOPatch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eop = EOPatch.load(os.path.join(root_dir, 'train', 'eopatch-17x11'))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "EOPatch(\n", + " data: {\n", + " FEATURES: numpy.ndarray(shape=(23, 1010, 999, 9), dtype=float32)\n", + " }\n", + " mask: {}\n", + " scalar: {}\n", + " label: {}\n", + " vector: {}\n", + " data_timeless: {}\n", + " mask_timeless: {\n", + " LULC_RABA: numpy.ndarray(shape=(1010, 999, 1), dtype=uint8)\n", + " }\n", + " scalar_timeless: {}\n", + " label_timeless: {}\n", + " vector_timeless: {}\n", + " meta_info: {}\n", + " bbox: BBox(((540141.9938823571, 5135790.459732607), (550136.7861024287, 5145887.882684642)), crs=EPSG:32633)\n", + " timestamp: [datetime.datetime(2017, 1, 1, 0, 0), ..., datetime.datetime(2017, 12, 19, 0, 0)], length=23\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eop" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Patches are too big for training. We will have to split them into smaller subpatches." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,10))\n", + "plt.imshow(eop.data['FEATURES'][12][...,[0,1,2]] * 2.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,10))\n", + "plt.imshow(eop.mask_timeless['LULC_RABA'].squeeze(), vmin=0, vmax=8)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.00723397, 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. ])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check for NaN values in each timeslice\n", + "np.mean(np.isnan(eop.data['FEATURES']), axis=(1,2,3))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eop.mask_timeless['LULC_RABA'].max()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "train_data_path = os.path.join(root_dir, 'train')\n", + "val_data_path = os.path.join(root_dir, 'test')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import `eo-flow` modules" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import json\n", + "\n", + "from eoflow.models import TFCNModel\n", + "from eoflow.input.eopatch import eopatch_dataset\n", + "from eoflow.input.operations import augment_data, cache_dataset, extract_subpatches\n", + "from eoflow.utils import create_dirs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prepare the input data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create the input pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "n_classes = 10\n", + "model_directory = \"./tfcn_experiment/\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def build_dataset(dataset_dir, is_train, batch_size=1):\n", + " \"\"\" Creates a tensorflow dataset from EOPatches in a given directory. \"\"\"\n", + " \n", + " # Read features and labels into a tf dataset object using the `eopatch_dataset` method\n", + " features_data = [\n", + " # (feature_type, feature_name, out_feature_name, dtype, feature_shape)\n", + " (FeatureType.DATA, 'FEATURES', 'features', np.float32, [23, None, None, 9]),\n", + " (FeatureType.MASK_TIMELESS, 'LULC_RABA', 'labels', np.int64, [None, None, 1])\n", + " ]\n", + " dataset = eopatch_dataset(dataset_dir, features_data, fill_na=-2)\n", + " \n", + " # Extract random subpatches\n", + " patch_size = (128, 128)\n", + " features_to_extract = [\n", + " # (feature_name, height_and_width_axis)\n", + " ('features', [1,2]),\n", + " ('labels', [0,1])\n", + " ]\n", + " extract_fn = extract_subpatches(\n", + " patch_size,\n", + " features_to_extract,\n", + " random_sampling=True,\n", + " num_random_samples=10\n", + " )\n", + " # Interleave patches extracted from multiple EOPatches\n", + " dataset = dataset.interleave(extract_fn, 5)\n", + " \n", + " # Dataset caching. The sampling is performed only in the first iteration, and the samples cached\n", + " cache_file = os.path.join(model_directory, \"data_train\" if is_train else \"data_val\")\n", + " dataset = dataset.cache()\n", + " \n", + " # Shuffle and data augmentation (if training)\n", + " # For augmentation use flipping (vertical and horizontal) and brightness for the input image\n", + " if is_train:\n", + " # Shuffle samples\n", + " dataset = dataset.shuffle(buffer_size=50)\n", + " \n", + " # Randomly augment the data\n", + " feature_augmentation_cfg = [\n", + " # (feature_name, augmentations_list)\n", + " # Possible augmentations: flip_left_right, flip_up_down, rotate, brightness, contrast\n", + " ('features', ['flip_left_right', 'flip_up_down', 'brightness']),\n", + " ('labels', ['flip_left_right', 'flip_up_down'])\n", + " ]\n", + " dataset = dataset.map(augment_data(feature_augmentation_cfg))\n", + " \n", + " # Prepare the data and return features and labels seperately\n", + " def _prepare_data(data):\n", + " features = data['features']\n", + " labels = data['labels'][...,0]\n", + "\n", + " # One-hot encode the labels\n", + " labels_oh = tf.one_hot(labels, depth=n_classes)\n", + "\n", + " return features, labels_oh\n", + "\n", + " dataset = dataset.map(_prepare_data)\n", + "\n", + " # Create batches\n", + " dataset = dataset.batch(batch_size)\n", + " \n", + " return dataset\n", + " \n", + "# Training dataset\n", + "train_input = build_dataset(train_data_path, True, batch_size=5)\n", + "\n", + "# Validation dataset_fn\n", + "val_input = build_dataset(val_data_path, False, batch_size=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize the model with configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Model configuration\n", + "model_cfg = {\n", + " \"learning_rate\": 0.0001,\n", + " \"n_layers\": 3,\n", + " \"n_classes\": n_classes,\n", + " \"keep_prob\": 0.8,\n", + " \"features_root\": 16,\n", + " \"conv_size\": 3,\n", + " \"conv_stride\": 1,\n", + " \"deconv_size\": 2,\n", + " \"add_dropout\": True,\n", + " \"add_batch_norm\": False,\n", + " \"bias_init\": 0.0,\n", + " \"padding\": \"VALID\",\n", + " \"pool_size\": 2,\n", + " \"pool_stride\": 2,\n", + " \"pool_time\": False,\n", + " \"single_encoding_conv\": True,\n", + " \"conv_size_reduce\": 3,\n", + " \"loss\": \"focal_loss\",\n", + " \"metrics\": [\"accuracy\", \"iou\"],\n", + " \"prediction_visualization\": True\n", + "}\n", + " \n", + "# Initialize model with configuration\n", + "model = TFCNModel(model_cfg)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Prepare the model (must be run before training)\n", + "model.prepare()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Train the model. We can interrupt the training early using the interrupt command (stop button)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train for 100 steps\n", + "Epoch 1/10\n", + "100/100 [==============================] - 1141s 11s/step - loss: 1.9883 - accuracy: 0.3747 - mean_iou: 0.0742 - val_loss: 1.4648 - val_accuracy: 0.7144 - val_mean_iou: 0.1793\n", + "Epoch 2/10\n", + "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1063s 11s/step - loss: 1.3959 - accuracy: 0.5477 - mean_iou: 0.1661 - val_loss: 1.0487 - val_accuracy: 0.7133 - val_mean_iou: 0.1790\n", + "Epoch 3/10\n", + "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1065s 11s/step - loss: 1.3004 - accuracy: 0.5893 - mean_iou: 0.2026 - val_loss: 0.9034 - val_accuracy: 0.7193 - val_mean_iou: 0.1884\n", + "Epoch 4/10\n", + "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1062s 11s/step - loss: 1.0737 - accuracy: 0.6093 - mean_iou: 0.2241 - val_loss: 0.8370 - val_accuracy: 0.7399 - val_mean_iou: 0.2314\n", + "Epoch 5/10\n", + "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1069s 11s/step - loss: 1.1915 - accuracy: 0.6359 - mean_iou: 0.2417 - val_loss: 0.7493 - val_accuracy: 0.7463 - val_mean_iou: 0.2429\n", + "Epoch 6/10\n", + "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1067s 11s/step - loss: 0.8633 - accuracy: 0.6667 - mean_iou: 0.2610 - val_loss: 0.6817 - val_accuracy: 0.7784 - val_mean_iou: 0.2881\n", + "Epoch 7/10\n", + "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1067s 11s/step - loss: 0.8731 - accuracy: 0.6838 - mean_iou: 0.2729 - val_loss: 0.7144 - val_accuracy: 0.7676 - val_mean_iou: 0.2992\n", + "Epoch 8/10\n", + "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1069s 11s/step - loss: 0.8290 - accuracy: 0.7005 - mean_iou: 0.2832 - val_loss: 0.6799 - val_accuracy: 0.7781 - val_mean_iou: 0.3094\n", + "Epoch 9/10\n", + "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1069s 11s/step - loss: 0.9021 - accuracy: 0.7144 - mean_iou: 0.2916 - val_loss: 0.6597 - val_accuracy: 0.7797 - val_mean_iou: 0.3091\n", + "Epoch 10/10\n", + "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1068s 11s/step - loss: 0.8910 - accuracy: 0.7182 - mean_iou: 0.2938 - val_loss: 0.6293 - val_accuracy: 0.7955 - val_mean_iou: 0.3188\n" + ] + } + ], + "source": [ + "# Train the model\n", + "model.train_and_evaluate(\n", + " train_dataset=train_input,\n", + " val_dataset=val_input,\n", + " num_epochs=10,\n", + " iterations_per_epoch=100,\n", + " model_directory=model_directory,\n", + " save_steps=50, \n", + " summary_steps='epoch'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Predict with model\n", + "\n", + "Use the `predict` function to run the prediction on a dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "predictions = model.predict(val_input)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(20, 60, 60, 10)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predictions.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(20, 60, 60)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predicted_classes = np.argmax(predictions, axis=3)\n", + "predicted_classes.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "_, (ax1, ax2) = plt.subplots(1,2,figsize=(15,15))\n", + "ax1.imshow(predictions[0][...,2])\n", + "ax2.imshow(predicted_classes[0], vmin=0, vmax=7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate the model\n", + "\n", + "For the evaluation use the `evaluate` function. The metrics used for evaluation are defined in the model." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4/4 [==============================] - 3s 638ms/step - loss: 0.6293 - accuracy: 0.7955 - mean_iou: 0.3188\n" + ] + } + ], + "source": [ + "metrics = model.evaluate(val_input)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'loss': 0.6293014883995056, 'accuracy': 0.7954583, 'mean_iou': 0.31882656}" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{metric_name:metric for metric, metric_name in zip(metrics, model.metrics_names)}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Other methods\n", + "\n", + "EOFlow model inherits from `tf.keras.Model`. All the methods from the Keras models can be called on the model. Above we used the `predict` and `evaluate` methods. Behind the scenes the `train_and_evaluate` methods calls the keras `fit` method. Custom callbacks can be provided to this method." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Other data loaders\n", + "\n", + "This notebook showed how data can be read directly from eopatches. In the `examples` directory, code to create datasets from numpy arrays can be found. Numpy arrays can be used directly for training and testing as per the `Keras` API." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/eo-flow/examples/pretraining.py b/eo-flow/examples/pretraining.py new file mode 100644 index 0000000..e69de29 diff --git a/eo-flow/examples/remove_file.py b/eo-flow/examples/remove_file.py new file mode 100644 index 0000000..90184be --- /dev/null +++ b/eo-flow/examples/remove_file.py @@ -0,0 +1,11 @@ +import os +import numpy as np +import shutil +path = '/media/DATA/johann/in_season_yield/data/Sentinel2/EOPatch_V2/training/2020/fold_2' +import shutil +files = [os.path.join(path, k) for k in os.listdir(path) if np.any([x in k for x in ['checkpoint']])] +for f in files: + try: + os.remove(f) + except: + pass \ No newline at end of file diff --git a/eo-flow/examples/test_cnns.py b/eo-flow/examples/test_cnns.py new file mode 100644 index 0000000..e23813b --- /dev/null +++ b/eo-flow/examples/test_cnns.py @@ -0,0 +1,105 @@ +import eoflow.models.tempnets_task.cnn_tempnets as cnn_tempnets +import tensorflow as tf + +# Model configuration CNNLSTM +import numpy as np +import os +import tensorflow_addons as tfa +######################################################################################################################## +######################################################################################################################## + + +path = '/home/johann/Documents/Syngenta/2020/fold_5/' +x_train = np.load(os.path.join(path, 'training_x_bands.npy')) +y_train = np.load(os.path.join(path, 'training_y.npy')) +x_train = x_train.reshape(756, 27, 10) +x_val = np.load(os.path.join(path, 'val_x_bands.npy')) +x_val = x_val.reshape(190, 27, 10) +y_val = np.load(os.path.join(path, 'val_y.npy')) + + + +# Model configuration CNN +model_cfg_cnn = { + "learning_rate": 10e-5, + "keep_prob" : 0.5, + "nb_conv_filters": 16, + "nb_conv_stacks": 3, # Nb Conv layers + "nb_fc_neurons" : 2048, + "nb_fc_stacks": 1, #Nb FCN layers + "kernel_size" : 1, + "nb_conv_strides" :1, + "kernel_initializer" : 'he_normal', + "batch_norm": True, + "padding": "VALID",#"VALID", CAUSAL works great?! + "kernel_regularizer" : 1e-6, + "final_layer" : 'Flatten', + "loss": "huber", + "enumerate" : True, + "metrics": "r_square" +} + + +model_cnn = cnn_tempnets.TempCNNModel(model_cfg_cnn) +# Prepare the model (must be run before training) +model_cnn.prepare() + +# Train the model +model_cnn.train_and_evaluate( + train_dataset=(x_train, y_train), + val_dataset=(x_val, y_val), + num_epochs=500, + iterations_per_epoch=5, + batch_size = 8, + model_directory='/home/johann/Documents/model' +) + +model_cnn.load_weights('./') +t = model_cnn.predict(x_val) +import matplotlib.pyplot as plt +plt.scatter(t, y_val) +plt.show() +######################################################################################################################## +######################################################################################################################## + +# Model configuration CNN +model_cfg_cnn2d = { + "learning_rate": 10e-5, + "keep_prob" : 0.5, + "nb_conv_filters": 128, + "nb_conv_stacks": 3, # Nb Conv layers + "nb_fc_neurons" : 2048, + "nb_fc_stacks": 1, #Nb FCN layers + "kernel_size" : [1,1], + "nb_conv_strides" : [1,1], + "kernel_initializer" : 'he_normal', + "batch_norm": True, + "padding": "VALID",#"VALID", CAUSAL works great?! + "kernel_regularizer" : 1e-6, + "final_layer" : 'Flatten', + "loss": "huber", + "enumerate" : True, + "metrics": ["mse", "mae"] +} + + + +model_cnn = cnn_tempnets.HistogramCNNModel(model_cfg_cnn2d) +# Prepare the model (must be run before training) +model_cnn.prepare() +model_cnn.build((None, 30, 32, 9)) +model_cnn.summary() +output_file_name_cnnlstm, checkpoint = utils.define_callbacks(path_DL, model_cfg_cnnlstm, prefix = 'cnnlstm_') + + +# Train the model +model_cnn.train_and_evaluate( + train_dataset=train_ds, + val_dataset=val_ds, + num_epochs=500, + iterations_per_epoch=iterations_per_epoch, + model_directory=os.path.join(path_DL, os.path.join(output_file_name_cnnlstm, "model")), + save_steps=10, + summary_steps='epoch', + callbacks=[checkpoint] +) diff --git a/eo-flow/figures/fcn-architecture.png b/eo-flow/figures/fcn-architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..843d4cfcc17fcc2a8e3bc3c6958c5bedd072243e GIT binary patch literal 148643 zcmeFY^;cX?(=I%N4#C|*ut9#yi_$s`?xMJ`PE#c2> z6|?PUdu!wNS{-nz!{*A(#aVC0#mJDuwgySdX!8X>oVfV6)#dzjAEHiIh6#HtY*-t& zGjG0F3OXhw-=hx>rf-yv!hi<TsF9ew3v8l1KdkFrsKlE9mRhLc@Gf6-Vp)1ig z83+K1Mse(*&(*!cwkI#{_+(Uw`*-(YEu?^uXJv{7jh_SB#Gm_dpAgy3M_e4wIN_G| z-y5=maf`0yfxj^OS`pG*w>$VE(7Ib;dd~e{y~e&tMSgQi4EICtBEo;RFtH~T9t#IH zA-4Zch{4n4LO|#pbVYwq5Us2JCcxwP4D+)bY^3Db#pqz9Aj3ysr|WsNvA?T%a2Dm? zp|dn7{0%)H?mPm_n!gomm)sQZkT>4c_+o^@l=(-nBjA6|(N5Ej_R13D6_PC~;C+@#8R{revcVR^BJS;w_ z8^Io+saT(BKzXtt#3H)0K~o(S!HjTNu1<)*ieuR>Nh($0?5=`p>uKu>xQVVfXtE`B&alAzGbd z=rIAJdk9=pgbES^?DJk9voyb18d&NN{nEnoD;2wTG5UecFPc9Iy zO-(jvKos}=gk8nFe2jUTzqtPz34p!l8ocXA3ojk&i1p92@JO$BavlNgK>!MhH}@Ut zwkP3s(y*l+%=|EzsK-Z6qJUPRJr1vwNqFWMlUQ`IoTVy#-sIG|_W5JbZe2|fmc;I1 zm}8t3oCrrjGa)jDm>XV}{5aekUBwDiq9Q~4XEPUXo1s^E3S9%fDSCQYw=XsxZZEM%l~)69YYN4{CR_~{9r4pU(tRz5Su z$&3nloB9_o5{0DEfW5DUfH*(JZ7Ed5NB%PHQGo!DcesKroqR&XJk3w^ zza<&+I@n5ZR%o15KHAvs*suYX0BBtRfWt?v-;+@h;eoM9`dZJqJqIUcC5Zw)h17!H z$~o{^iuLR3aZ_9)+Pp=zdWkLPasE|j8{}|oR1^09$U^xu!`tH2%l7aaA%3IHgfm5e zwEJI0zpM^-Sl?YQSA4^9E(7>3hDEK56hG5s)Ok6lsKpc)DBUXxWn{6noC^C5NjNG? zjEV>doSr#q=+`9cUuhk)YAAH|nq$)v=Cxi10SfDlF4IMe@XS+W+)+V&qJGxg@~2?B z=Ti%9ZS$OOIUPIa?&>2tLY zMjM>nIR1*;UVk$8QnSI-raiSo-Qm1B?}Xd_OgxFAn32iWAI%kA`_a5;uO^pm@?#4h zTw(Q`Z;cVDiOE8rt9))En#GPhZryaG-V8F_?feQmrjlLW8*SOH>J+ScMaKF>aw0|X z3&>-QvohsCuo%1QTrQA{NFkD_Bof1DgEkVpH*z$!MX9Pq+#6 z-=iY%smkHRM$4mjzw$~&9uOH9Lzm9)%~@ysFiqy$+G;~M|Jz8JmNi}Zp&OoOSe_&? zhLW7u`yFI3qGiF$SNLE|QgNq}Ae{K-aX|hD=jPAYF8mYug(k1$r_IW22yl#=Y|*Jt zON0Hs;U^|PFLU`X9akKj$@yAa`&54COZn3aqU+~vQdzp6Z@AJvCRE^t&;h8yBGT!t ztO=W)o-W*at{0=H67)kr4knxx6bXqD|F9Av(yGXNQ4$Kkp4@jTN(2)b;l7VLo|4l+ zQqCufBx`n-ry8NZ!#oVP@}x*URec@tVyEQNMS%AmikL3#^=N8Z{;uOXQ`i0L7rH}| zI;0?J&f@OSDltG}8@6p*C(Gw+>44W^!mj@cNCHnHQG?I?IY$2ASUL(HQP|ZxUBD>E z*k!Qy4*B}<9v>Q$KF4G~P(KmhYCj{NjmyshqEw1Y-*ffx(0;zYh9`un1_hKQ51OU06L!--*zD1pKd|vJck>B?(xf%Me>)+&6jYK zdU!((aI1rqs<&eF)JIiSLwuaY5MnbK5q$~}C9sGI2xq5JiYgFtnc5YES)J0!b~zWi zclQoeO5^%uS-C#nbdVhIIz-rYrfGbNV@I%MbL3$HU-fA*v?_~2fNpeQx{>Q)_t~o) zZkO~P>z`na{v$Yc=1+^`g_!>9gOD5VeZ=Z1B*@o~Up%ZrZ@Qzp%HhXGn!!Ie&AhKF zYeM5c|HMxlbeb(S%c1+7@BJ%#$>Vgk|DtyiOG&k+(QJDW!qWIu_NUrGgc6}jGKEq0 zp0t8#Pl-fVz~OjOb~HIT2ttp)Ft1&Qceqsf!~=+s;ua@i8hw=Ne_Cdjj4=)+UQbWm zUBda%?v32olmhbH40I5!_wvg`J#-8`Yn1 z#3AWIO{SyE-|{^?yRvL;!cJq=rdt0zt{VTe|1Oj6?rSPT-Koo)x&8BJGI{BBUXJ&E zfZa>!5Z?6)Nvo|FJDsU@_6GA@WK?|}Xq$&G^8xQY!w;&pyrp&-;?{i%I5R{7A1vge z(%q|Bf|kaUK9@0^CIK8HfivdZ2&SjdFP{XS1<~KclO+LnqoH{L25P4MqLlQJ6f!t+ zRcN78yn>WmTR{)bN9$xgYa3aFlNSx^ElP4$m1DoBe8sH`lt1j=ab}8`827{FX!ym#y!Qn7nt0Jg1R(BiyG9tl zXn%uF%~<>s72QB{f|6$9{QQm9ujew@6mVJJ^W5a+h|XMVUZ)6N#b;tfBF)V2 zO#19zGDv)q4x}N%oP;O}A0sWsV05NA;7t3e+{)^*IOEZEICKW(JPEr*4GWf0d9P@* zl6kOBoavV)D0s%pCA-B;t?5vs_$o;UeTl-}odn1P$q-cZ;lQ<0SO-GEvSW_$RbYea zgzcl-TVw9V*Kh7y64F?y+mr+vArSB0+PE9hOr-}U1XlqSJX5VFKbjw-O-{O5;H#Gn z$!M?%0bavGT`k`0eG3oxLxz9QpQAwkYt@z0b(k^6(+_*Q=wPX z?Tzw&4v*LgpFAx_Lwh6E!Txx}y&D3jhfJbhN7cX$Y!JVbOH?5rA#PIL-`49*1!W_9 zA&QS202BaNMp&7qPgFE|A-t?ruRzofZ^AGT%7%7nLE_hl5jyueK05Kq@F7BtTRGU? ztlG=jYqFDdxWR3hhBePzrYdZxljn-5@#KJdt09Km`Hl!WuY(~ydFwhF}foo?GH^e=JhIY zy^s&5rDSQ*teSzB2_9nhxW4CAyn1W{eotZnJ2`rF4Gt%hGgme(#=q{X$`PY7{k*gp zuWsv}v$*!XX;WBJIWjHz#0IjIHccW1^~Ovu&l?FiJM_dNvQ&tLW4hFWNhsqt8)=(p^#BYJT{1 z^L^wnVmgkyZM4pm4esA?X%{;^#d9zWfA~gDt73LqAMU|ZlUj0sY@x2W|05u=f7!b? ze%rK&@8->bhmXgD&p~7BiI!0w>Zh-gae_`=Ey+7uc=3AEI%D`J0WgDmw4fR1h}AdO zW2&$3JqnL{F(|3Kyn{`MIc3zpJ3C%f{i1gG;5||Qpkg~zr&y z&w}z%f#<#?{d0%RAzRlZZrLmR6JblQfCs{tQ$C*|uEyqd|IeHS$?w|!Si6+K15z5^ zd};KJ%%sKwty%26MSzDX7!oClzatqE8WAPDX!I&-;8?zuS+dcy8o~;aE-6iZ!KEzf zv~9s9ZT_{;J;!hPw7lt&w6@N*D{gdA>lp!coyDs8xo}3wsp%VS?`=_ktc0az-a-@6 zBSJtJ(dy|xv<7`+7*nd!P5TfjB%&=khX+7k6tcfnw|e4z!ye(7w(rs`qk7staOZZF z9omLLamKKb8)`=bE=k}lx3qM->SjzrRY+MdDYj0ioHnZbgQ;dcLtVVkQg5cVQ8n%q zQ@(pqkjgQtGspHs&|{Ryt5G?=`Vb;Omn&SyA9HrULwI}>K87ug_5P@mY6Bb5scktt zt2Ah|#TFxgan#xUXf{0-oy%dKG`Iut4?7_nz;bi<%m=0O6adGI2BOTctinh*uY1&UsU?KqLnddnEvX$qb zR87+Tmk-*t0EUNSEK&n z>-wdSpCS-5Hp@OH-{&UKAksZF~Y(b7ET*P)TIVv!2{0hZ7|x7$RUd~ zG;5FOX4(1mRsCsiq1$^SXR1BNM6ci7*bgsPHJB^mrwff#?D4l{sVxSkqN1Hi21@W5 zL7^`sNE8Sr@D+*7yBEk5C_qXX5QvNopc*ws2PBa2jYM2j<3Iym-q*NExty3}56*sK zD>M9!s_p=bJm$Vghk7(&B$rAY#4ck6o+gZI&EuwO0LODr4A1-DXaa(ioS;pt6 zSutifBhyz}J?}Pud`r2^VhIH5_hIS+8i5+BxQkW9Aw?8eXdPHMen}X*L~LMSH8?{C z&NdW<7onsGZVKytsipnd9x*wY)xxl3d}W6gr}N^Cn&4?baVyOEQZnlzh;{rmbJ;CR zOYBZF3?wvpxi$$7ll$mX)!SM~U(yp1CAOcMT<{L(&d1XM-8uqq|B2}u*(8*|SecDJ z+;=W;=k*P!s><+7fqc6UJs;1_+uCQDSosw^+BRe_-ldZNI(|DlZojJzxG#?pCH$F? zRB30vT$BXO^5 zp0pi4subok4OCl~P}jtyfIiMNW%}#_0ANLHsmGy~iXR`4GKt=&twLMqpxqm~!I(}R zn=@l^>CkR&Qtsz10j=L{CXc9EsUXfQV3uzA+jgrEH`rN})Z5baZ>v8**?=p-h7O%H9Xhgm9MZ zMPXgJ(Rfu2les#p-r(9&?Pt{XDBt-LCksay*w2r*Z59$!o_dzjr<_QMV;BnWTOg~SB&8=uP zp7~m(C8JVC>gpIl7N$Q{Kz6QI;NApbt;?m4yV7*Y?m_+#ap3`R^ZyAD>%T+;37 z$940zc^q6+Tw_|8zgE^Zvu}EtWsV;@!?*Os86E|H?69u zF+Q2x)7n$#(>e4o(p0AWdy|Rhl`JgyDJCvxXy~^VF_JWcnWobI)F8}OBxtB)w&vSU zvEoSCz+N!M$}0 zaJ{(VQ6_?jd}?l5Im>lRto`Bagl9chb7KRLLgvg^lh4`N7OK6yZnC9MRpQ8S5Q(E{ zVKCp>=28EnKr%Mk1!Hj>nPaCajiu-wAQC*e-IvscIMjd)L$%lMiiV}{eP3C$S0=+n z!ZSE>A&3FxJP@nSWY!-rV=k~c`;|D!h{@;-KOO}{b~V^EIfE3W7$%s!a}uxTW3E3*#|DNkGVwD3umOPWw1aGD@F8Fk94HgQ z>p+AUSm24^mlQE_Ea-TBi*;%h=@0G65&lV25E9lcenJX53CRkT9vxoc%)gudzUPMc z%{lVB1B_PUlGD!DV8TT{qUeguqDMETlh;(?Ghd!^A!$LY$})Q1U#JdYC{71Nawqiu zV_>sHVl?%1pKcemr%n6LYo@MRiIOJ+*hAIUw(6E8ew4o;yDwpow%Q$Zp3f^wD8kh{ z+S~E=TGx)2r0`zE6(u?#nX*TPFIk3a-bcQ|>GT+z) z3?mJDnyh&k@WG!Z467XGdw5yWr9_xOyWBd6bh!ZpLUX*LUmY_}0qzByX@b1|SToqI-YONw+jC5k`0J9?!tuGpZ0|AV(%Yo*PV4#BUFS_<5 z42Lz5S%mXh!gt|Icr}>D$I)Vjg}X6~3WkH!ye8LKxyrOQe&%#M&@uMEdxsjb=uzt# z>*5OOwF0;!9T{{%!^3lQ}-48M^)RGRVzpNLY?4QSp zkbFqJ`NiVldbEhHWRoL}=oI_ez)2)KR98>b{v5rwjAEFI0|FKh0INCew2M0S<`LOsHW%jXU$6{e_PYU|IM4NX%Mk#A$7U3wC8Kl#ceqj z{8b2*^uSvNx36=$$prYZKS-+brT#bNM|OIr6}Vsj55MSWqoW787$UW8&2P2*E*9M3 zGs|0=0fMwWA?Fl`n1HX^*z8Sg8{KAF#qP)t7a!DhXKv8lp_Q`zEDTTE=r^`nk$hFw zN;`hXuB;}S{njh3;ifXI3IoKN_cf+2f)xcBMs_>fFdAxzKvoh)L!~~|WeqL~F}hJW z`MY%}zU+bA8@T}O`{9Ll9(b2=2h!dW5@V%nj$*f5V$+!^Feo;S(nF>Y%cuAdHRla? zod)nMwcqvT!A>iDuy;&@(#qPUK5yy;$(;DnaD7gyVLOX2f6n3i0<)w}g)!$z_g{;b z8h(?H0lJ`NdrG>m&_cs9#>SXUG)(Z>&~CYyQ;6aL64GPn@PUTygcGZLDl2>jySwNX zY>aS$2nljHoLx{VZ~{ItWfyeNh`TBE+MMcX8AbTk=)MQh%9i{@p15&sn~q9 zrDN}Gh`j3CZ;HQg$lZCPiamxFbL8SXA*Fx&;kI^+EMxH-Ae(Cq# zZ$J2jbceaPAdwU7&>?d{Sjn_Uqd^uSfonFTDVW!4C@uISY3_n)gCuV$OM^)zaNYG! z+f}(qzFDm1^Gw^zEF%W>Dg1*b$epQR0i{9}Ew=8gDlnaa3^3}_Y z9R*m2 zNF9vZNFEu^u^`PR^KK{_K>`GlX;0lds6;Whe^Ct8p>;8AkTP1&|T@IyM`{Q)D(_96nqeWNqtR`=VxPdZpe0vox8W zMHk4TaNf`5y#PQ61DnTMe)`wF!5PCZnCi`u@N1mOWhA>+4r{B7x$mE=b)*A*yWT3m zsLiA?Wc4dUgzE*vD@1IcW2v+?+alFJ_ zHord>Pc<|yko%eWvnrU?p%jVvYGUw||B`-(*X5rE#SFBim@*F1pUkj?7QXm0{2BP7;p*H!}^Nx%7@7ldQW)o?i(2=<=^URF27u zSAmxo1}~+%XWfujv^!zdUK^i-+DCnyiPBsV2i0h@Yu6@gZc4Sm@1L2n>&7uv=!peS z-u4N=o&9LSnuP?tokNE7i0noS4`iO=zLR>%1*Eq1`I0VSJ;<}sJ=mQ-n1W(|XFIjR z>0+!{+tV>RY)o{Ao;+6-yYwjv3uT=jn~JFZ9Nc$)Ax8nt>~qUjbQdb|zrv%;7 zBat)~Y#G87SQ9{aB`{D`jUosw;S!4zAfg+D1kVeg2F;>zfaL?rrNk-}zhVDbJvjcR zKe-l!M21v?;jxU)2+_b=7U2P)DZif>Iuo%glROhj19v2oQyOKlMVHwVUY>%L#>eN0vE-AM{Qrj$kArV+p za(F`ZcBk!7^r0jBDI%T*#icair=Y#u-Ui?ul2GStWI|l6^T7I+11f{0lnD!rWK1VW zPjNrkL=4@*4=)Vs+hNc14*A64@r)zo`PeD_I=vH}8TS>_3lN}J4L@m4YjB}n#pdw5 z!^nkL)p--L*hUDN@2Y8ZiUF3&A_87V;bbClhFO2`v`tQ9J{x;_=lt@X%mpc}Q%@iM z7Yn`=E-Zxf`odh3pjOt(DGj+u5;t96I6m`4hN5W-+tahTsnXjsfHnQ7WR!AGZyZ5L zocJU0TYb&ta7xHRodrCN&3WD%u{1oA*2_IG34c=7({_3J0~#3~yvOGHgMQ*RXhYf znUTD=-$kY3Km+6YITNb`3NJctFNeN<{g`?yvr3lY+WRVsF&omEFYDg>k{tHIrZ?{S z+F5(cpmn7f+bLHeHp56;fxDw z#Ni3M+CD#>E;hgT^nUBNuB2iYpw9L3urk`o{8kPJlHklZ=(|_1Qt2JCZ?X3-H_&Xo zy&o5j^WEH0O<16LtxugX$0-bWyP^^`S&x_qN%MR1g8xmvSdr{u2hK%G%GnTsAZwM< zjp<|=+OPN8nWX=oZg?j;tvF$XXIP53B|kcub>Oec z-)_X>f@Rd)aBwJPK5Z|Pl|CP<(D{(>xl)OP&CMWR8jm89rKYB&bnBMG9!0NqTU+kP z7POX814NIaB7**I$F93M_rf+Olg@q5+;CmDtk@sNav@Pr&L;kPxcW+aFal%r`r=ar z>+oQOS4B2;o9Rt!9q>}0&h!@B(hU)lRjbY3)XhnEQ#~IjEjNnw{J+wbKOFhR5H>RXn>zgD*>7jWlOP#BQ3DUE1|DWTt;MP;7+QMw`Yv>H^S>Q^igbeGT- z_iosJwRho1D_=Y0rbwc9Y9}mYuR2LJluK5P26j$F{UO-9fk5>8#0gp`B>+TWu?r1z z2xn-zha2M(#u1jDp%{dg9e}>@nhZnx!5wRC9UJec`)$OcCy|ne5yWN;qrv`Y88hW; z8W3_kF~3YJB`)H?;b+O)V9sE1ExnGGYV~EUbWK!qZCAC&3h?jRVED&DYdiuB09k3N@?KVtq4X^k<_$Vir-moWD$$YHmbb& zz@3kpO<3N^2x$p=qyK_=>7L@uU*&EnA>R{R4h$Z+8#DNXXS!eCKWST<$i-7t^F?sO zomsZ%?_k_=y7~*Vc&aZ1`Tw|@R7W9bWmLqL`)T(=PmBtxe7Jg5xFMV;{@Pc%Yw9!e z=wc`(g2Kz$WT+xnoiE;C`dI3^)CiN%c^=0{PHL2{_3TU^5YR8+n{) zELtq+9~75g=UW_`xVwRaqf8bCA^Bt5qLMyqAb>#y(NN83!)Q}!02+~<&8n|8*^Z=F?xnMzAq)}pQ-NaEB^F~e}1%rE3H^`S!sQ1#% z84xFpj4ctn7=6ylRodX?>4_)M@6oy#{f<6hz7w=BIu{-3#_X4~1?R?bygJn2%8T&}F2 zJbWw21b!5aI44)Hwt+NY5J9VW5Iz+6`=E|NRUql=BelN>7hYUINemT2lkgNN)IzcQ z-Frg0?aO6Auk_{eU`(n=(CvWZ^+#Z0%W&*%5U@zQ7_lITa0Z7eis6%WNsPK_!7Ve;=%r3%-F*49vtWYpC zPYegHBQo$f4Ir9?0gnU=`+bzY8ATg%p=ii4d{R;I(a@S-4Q?-Nc#{)1Bj*kyX0DW7 z*ah^znsIM0f7RB#4qgw!mRRBYCO5!DbQW+|JfluyY9h%S=N+ERFJGD};1e);po_Jq zk)^rkp9JH16d!1B!Gm0H3sWkb4>v7W;6^u08H-AqO<|qU_4_;GkK!}!ht4}cl4eiK z0nPDE@}~C7>vJ{P`r^0S;45l#6Sv9PeieN<(i`0vWn9wM_eHkn-=ZR@wd$LfNohxP zD+)@?j6Un16z?#1_>fPY%`o$^T0IUs9Hdr%VK`P&b$X--B4GZTcQT zPi4)oM}S2cin7D~b3}U@fiREbePE-^$1_S#-(8Zd#+75TwTL_tg(SamK~4UCVeI_l zokLe{-A@+<;S^24BHzcL%m9bd?IBx}6+3Z1$Qt^$fErxjQ2RiLPW%K!No{&a3LB2FXt}yJ|pH=}4Nl zDZ2!4>vER3WWv%sSZtjBXir1aNZ>iB=BG?jBooc{F{i$0zt#+l%z<4FKhPct=aTU5 z5V<@LEct7Z1Z-pVA9+LG=p}+6%6rdAMma33$OcM(10BrCfITg-I(1b1loMTjEp)FD z9T#VkgNjVHjaDwXP$7Z+0V#RXP2xvvH$(p9+~>*nFTY_`V%Z1I=Mo^9&XnXCaC}%Q z4E!xh_u_`*;NXPpZ*wp4_*@T6DU3-)>&?*angILXBBemMGqzU z9j6B=epfE}aVyqRUk{du3V;=FoJ2UXRWi`zXBhqt`B}%wq~~q^F3W=^l^I{|N^cidy!}Tem!2Z(lH^_Oru-h~L$DRsd0jts{)M*A&Kn`h zHCM`B)Rizc#%3s|@F37b^V8qOb9o$x8)tdi>dnlW6sPbShr@EKuVHGE&BbbxXBw}W z-a3Eu@T#lfv!xHYoGv#23dzCfLI~dK&7{4{sDETbuwxnrdfd=$Wi|)U(He!uA!M{Qn zszT5N6_~e9A7J|9t|DQ*vZw$7HKVcrINd&o!eWu#Xnz$!^5(O%Iz_cSa zZJY!wdFCiGq8r0jlOKPp3t>>uO`M@s9Yz;@*SEITi($yhAs*hc>*+CGYvk+Qj92x< z_uRa!E-}s<@ix4#NWL zbiCn^%01yr-mshD^uUyascKDxJ$m(Oyy<^{wP*bp+vLFEtVeJaK&d>NQ06eYs{kRECd^ z&F6zcqBG$zJZzG;T4q{JOSqFG5WLos#nt90der4$s~3ZJ89hgyfr9jvYbYZwEbD)W2KY zBPJ0C?CKEsxpbr{BKd5;|0vzNV!5=74%F>9oyiddE^q^7P+uP9o)ZaETby<$n6d2l z&i2*0SDdfLF~Wjh5Q-B7i|33g%}Ka{OJD;oaDqRKobRAD(eOu*kY3y55wD-i1vtWw z8D#L_`6H2qFj431?V`d^8g$agmkFWqn>T_JSs?cFkX#5tC{@>&PZY9i_sfw0N}#(^ zkVLdWrRF#;n&>1teYBskt^igb6b(h8_yAqJ!;O^oT(;;-8y4z6@o7wj-BRkts{tti z42q(YT0M9bk)B;Tg0eP;Ukk}FKTxJ&zlC5qFhROamy=f(;>a|fQ{ukfg$ikN2>HS- z2J-!#JQEv{%6+l0y0NOB(_D0%3ELM19_>;rQG;XVgO3d6L*4|Qa*tUIMRbDoc2B7s z%(bUQehqacWSU%7Z~ppwB_sFy-Tu(H(oqJcPrwXE(QxC(U%y#(_5(F-B*tx$lLw|7~O4_VNVq{8U_-}1U@_V_#=%n+HgKbq7 zOR2_2rvE2^{#%x(yHj;UWHW8xtSt})`JUWk;Ou?8!+x! z`=dCp(K&Bs}EXXVYgUKYP@nH{2Y@HHah*t4bY&$r=o|!7(xQo zz+oma9&pO(9Yygw(Lkh_H+n3#9ED0b91s3bp`6T7LO86EM^|07l--L=Ry0c%5zLk$O}ZtJ-EqrtIT=DaH_%V}*6Cz(6|M|AldF=}>Zo34~(HAq1k7f)VVn*8W+ zjN)s7lqFa>s}&p8?3+DTq>r9o_mk!rAxj!OJhj`~g&*9$&V0xHV8d5?^y=0V_AZ8E ziIoNPouSRX2X~$4@Jf8yN?*kxK-6J!OtYRm5_keZGa)?oT`5`ZVkdsTR+BksDpEJ; zY0K9p(WBk=A$&5w)2WTrtf#{)-rn;U%1<9lsq;*hdK=_Q4}I+CDc+4m=g#es$(M`V zbRDZjb;c~0&cm|X9e=E<f!32W886Xf?O(pW-qW4Rj;inO62+}m6uuAMhfONNIxzzViNlx!D)W)Mr8BQt<0 zOgo{fu`_bbKJ!(i#*MbR^~IM<5RO3%V&%%n+pO2D0TnNtmq%AL5)Z(f>%e=kC z6U0~+a_Pw_992k~xxBm3_+*y&zRps`)AOSx7%tQ(qUbG0T4J-E%(S_FAH!?IB1;{+ zcsh3W+PDDh@eC4ep(`uY8A!_IT;L8tGFj+Jy~}aI{P!DJeZoO=(mCNYOG?tqoY$6l zUSIK!qNaXya)0AsI-6q3-0fo+J`bVSb-?D3wdL>VWVJ0kLLPC7vIL{*xrrjP5x3@& z#$$&;!(O?xZDJLnEfhc@;jCl*d93P;Km)917p{709+tPji;oR!-U~f_(tk$jh@3vT z{p0_B(MM&&Upe5z4`Ww>4(`Sh_le(ygSKG}(E?q+m@H-7MEkZ+OHMsPaC7H9ZbNjo8#H^`56HZAW znkEhw)nhLpgW9vok!URZbOi|kt?PXq&LY4-`Li?-MT8l_hr-`Ah!~ax`6UDzCilmI z1Cx!Jw%aOa!mn-CfjijHQjSrCKOtBX;G2cQG3RuY2mQ!AKw9J`h3mlL*Q3L$4ioed z=63AzuR|epG4jm|jxgHjY~N11YEp)=*dlk zKjOQ%`Q`bj0?5onXEh79SIHNs+0X2apVvJ`U9K2pVYzy}*wkcj6ZhkptZQSZgNqcV zE_>U#35N@E?XSH{JaJ*=5qsxuGQ^q|mP;rvYZ$TH*FuB?vWjsE zPFH3=&G{`Y`7SV1?9nN0evY&C%Jv@r*IOt58I|7* zQZifq@ku;B>}EULuor+(3M~uCN*8eWFv;D~Q>^rUHa)X&*!;1+Ie@Pbx-_CV##MqrZ^Tr%d_+VcL1Z(q-Yek1eGY5@a89y2iiZ`ph zzv4i~m%Y^Yd1M;n-kj-{rfJRn6M&AUb<#Ba1h$}rrzBcaNMg%icm>vMH{;Ic!4n=M_X8(0kez)O5^SwIa`hiEED5=T zz2m|ET?P=@05LCaJJ{@hA>4Bt-H!Vs?RG_My+DFl9kk6g| z5A5~2KrLtcx%FJq6A#YvoWra^h>3)VnW6IWbFJ=t=5_50$-u3Vgo2FB2Y*}1 zde#r30azurU)G`++0jHt?b6GK*fWXjFl_2=ra8OOjezXmdcX8az=M4(4E=L$9zlB) z-7^D~__6_2M&mhwC__FxQRh>~-0p7+O8acmhegxs0{XCDaAd$lyr+ z=o?vF_8zNg*;uvuhT|4iuhdXBiX%#qUk~0ekkVd%*5&hIk3H)NiQ2F_Ze2@5K9L(4 zYPE=-F{!0s=PF$_@K{*Oez*O+}>!R+WKI1e9nQ}TpB&~l1_bDgza+xpZ zX89o2T0-M)k}c+=BLSI%w9Nx zq&UOJiwn^U7JYsgIj-z-lV5DdFjb#Z$f2LwaLLXZSG{Kvp5D=Cl;d!mi<-F=fT#`R zba6>935LvPA*;!y)Ug#%V*>%Nb#;gXO|#C+P2WI@idzr3LC4The>YU2#OBrKF~0EZ zZ=t9*UB&4CQww0Ik>{hVc6}C@ROHEcRZh45;Vi8uJ$LCw_%`+T&~pFx(^snEXEj#& z2Uf)ne9iSg1n+lC*|I<7`&8^UtmGFS@|Km-LlPvA2~G5zUXznmT+W2%NmaYhM;}|{ z2R4PObl0S0g+&+5H%*!UVSnqjtiFdSMBqSY|H%}BY0gtOHnEs;xL-BV+9=7hy0(V> z!L+{%f|;JM?UZk|9aV5V#%M8`}5`nbW{;je3(A{8I(3`VEbW$Rb zC}n3vP4%vea@`LA(vq9*!q3LNIm50t+g&ZjHns(A_)#uf6O;hcr6qFh^>XB_=x^(v zeK@SLW7~Jg-uzKP>29RpegGt?U5kl9;fBTd;&{5M7}yiagB+~6ijdx}>CJ@|vkQWT z%aF?B+m%8FYv3!#JqB2hX(G}l#b*j!>}|iPD#mI)kurOBgXqjLPpB)5gENdW;HY=p zNC|#3u?No~jVBuu(G$V>eqsZ-QiX2fRav0-`D{xdm2_uhs=}v&JEL}13!VMdvVlZ% zZQ5YKXf*}GSZGxcPi_^c3}1r&J;CSb07wg11dPB$sdUB<_VrU`8{0)t!p^{HKX0xM zRb1^Ecr0l}7NxEiOk}CM>%WxLhzs!1sJB|4lBL9#2v`98a&$>=g!Z;aeJ5w~e*R&v zV7sJcH$yec_n~8XZmw;0-&EC0{)z=a1~I^o;O|}>icC$&f?# z;m6{GtedpPW|Wo^tW@ks|1;cYw-;2_mFcnrvu3#a!u{f6qpFd#c`!)yTP~jkbwRIO zddt^k+%}RgC0O`40%I*;Iy&&lK+n~#m(*iJM&E85>+KXOhiDeEv(*us!^ZZ}H@}IG zv8H;GqAwYIdM77aNHVeaxO+ua4&w8$H6)aJbT zCPnLAaT^ftK0KeYfq#mMa?{uJwZEvk>Mt43L44wbA&q-vP4I{We>xh<@PCS6{C`}XV_2qN)b_J&yUDgS)l`#h+qOB` zP1fYewr$%@w%v36pW}VLyq`Lbj=H<=uD$nK>pXvJZJ4RDu-N?smL7P9N9kk;?n34j zO!ZSJBQCbx)F<>t-k+~0!5oJ^LhgO1r^Y)0y~NZP$u~jh;IXVbFyNvfOV@nU%omy) z6Nq5V!lsH@=D#0*+KR%MwA(|${Q{+`D_w37PNaUnSafJ?7W0*%qmb@pLGZ{49RcB| zn;tKqST8men$a?egFewByDC(sk`H5qSpSghOBc%(wyte{)Uqdtg$cA>FL(QnaZwK(&toF=leqNc1tfOZlq7E0)O$v( zvMS#6r!sgPzL@(4i^T{U{lJ0hRb&Y)dTAvZ#L5ztN{roJ`D)` zEb?s48RSXNG}PYC_r0GDhb`672`Zu2xHX)MUd?7@MudqwKqBT9-TNRgC~3P}MkIxB z{0Q!JmZAM%`iEgRpzC79#&32#!4oGqpRc<-i9;{X5AR$T498aO8`o~pVJErq`=FcN z>k|2i&)Wl!;kJ$d`m3ggU@iQ??~xzCX%9 za>L{Ur?Jc!MA(D>znl`U?X`{7NkaN*=#765&AfxkLf?h1@T;=yF5Peu1E<^hNkG?5 za!T*01Bc(Fk2|TY4&CW}DzqQ287ze*8nExP@LunxsBvuLzDZKzWvg1aDCG|^ygPEz}b!$?nNU+EouAm8f=+}B(|MWQFyP8&%o;x|MKYk=P( zAdQC+Uss`3f|H)ngFp{!$JptCrN?uroRL9$CrCEXK&s>=%u0rPZsYD*mHXvYi3Ar5 zDF#C^BHAp6FLz(d0|`@e`JWapjEK|1IKj(kBbT*%CM^CpAF}G>tWX+Kh$)eeTJLeS=wEOlEYr-i zMPT`$TZYTGQ5Cl`6@M>TR%M_6Omsdajly5qEW5IGD8c6D?ab_*Ph^bk73^c3=F0Bi zqp`Xz)luo;GyABNeDG&&Y~a$)eR`%%6WiI@G-zrMWWo?<@ZV&IcE9SD)>7@+Ag1o` z5THa?;&U3gsE{m-#da5Z#EP55=f1uCecySXE3d3cK)10nKWarkV({?W6M)b5-q&Jg zCIbi)1HPs|v9Yly`)1p3djQU(J3?sFVUvJ=YM-45v1`{9+CeT~33HF1Wz`jw$|af- zuq;XN+YHVyk~nM8d`E8+;v^4#%y08%7v`(L%R_~;x3Uc~dJ3tHOb8?P&2uVot_o9o zis?KLlU4oIaoRsXx&kA&@$id6!t$ymRJ9%j14I(`K3Oym?Yne-2^z(SIKB8U(LZ$p zQre(0qE+Ue-~m4H+E2||{XV+`3h>>Sm zTSXTwR}q>w+t}9>+vbY(u;YlnozCsAsG*LJ!|K){V>7p+4)UB{tKSr6bpMCOzJ$@M zbbR|F7=4%*SzhWRN~;oy*?icGIdXUZTUTb&abRf`C$qzW#c=*8y1rV)V&LJq1~G7+ zvEg#tEU-DJ3UNr;UdFpLMK%U&w+#m;x!JOX2QP)WR?Bi(b<%g!PKV&h=dnBH+c3xk&t0 zDr!h4|L{c+9Nm{ut}jC=3+EX`a`f;(8)&dmZ{Or=OB6(O=!AWPrj!QL+1bzmbswhp z@Ez$b`VPOGfkoW_wt`M5w2Z3m&-IzYM9g{gb^=r3+fFH;>DgVFWE_yk39}Fq(6`eW z!zrM}s6q4QH4aJhuYanJn?d14%%VM&(n(P|6~%!bydYkn7naguPNvj)sVCOFm$@#E zn?>Uf%-n+;jwp!~h;VNW1cFRn3N_qWW`g>1h|E7%>c7@d{cL$qy_rgIRu+Y}yvlS0 z?qJ7@eRk@z&8L|_zo9Ey<0Y(=;*3~HZIx`TUP-WC#cWSlh^j~-kH>3I&NPzky3OL> z5cGC;qpxCDwJ0h$ulMW0VMuj3q7QVN_C2p~1iX~{zO3O~B75maAXJ^m5EEzp=G@jL zlG%2!dz_D6(h=HjF!6f4Z#Oi*Eo8Tm^&`TP1?K$U!C6Fjb<;jPeIngC0XY5V7o zfjR;+CVyTULC?Ok8bpx>vHPHzQd`TWHU>?Zq=$-TrNa; zA^)HL7M?~9Cil*pn`t>?bl&939sSAOe~~ODzEcG=uH{L(I>2Obz6Q^tIH*EQ*b=Pt zvsMUG$K(DBO(K8Yy(Q5v?KnfZCWb$AG2=~Gp2I2)r3&w#*c&goKG4~6F8giNyg>rT7JIcRvr)&z5g821+Fl3@) zc`DR-^U5lmma{VjY4sh5;tV3D_KrJkknkmSXV|&C#<3hj^Gh=p8IM`djz`$TZZ?hO zHC{GHoCGT!TUIv^okW>xKEM56?ti6$E@&~-octF>t$zoMpWM?IGo!@AJhsEic z#dfWtT?PjBCmv1dZ!wY0nd~l3&B8hp`MP;cL@16=&Nk;nmUR2;+;+U>umXz>q_GqH zkpFezUW9y@-!``EVOEk@04yuvV8Tg@WJ!Lw~=l;3X zB&xXRx9qYTZ(3=plIw(|5`JtRlTt_3FunkFYUa0_5~_h%sn1THS2LNA0fZdBhd|T2 z%?{t6cH{laaeo-R97HVcd&G6J@4q+1K{H0;4*HVy`VO#RO)=xe>(qb^X z{1-K&ClLGg4T0@7=THqXlFsVv-pe;mzG2q-9&v36>x}44{K>|kfs^Z3f!=yyB_m{Z zm*V`K)q@w@=8dO?c80hVMrI|^3e=AuAXk`U_BAe9hY&B4F*LKnt9u~2WrPt}Fq*{y zUv%9KZbss;EJvo=m+|LT2)x?S0YO?n(7+e!P^#C&-1{KMbfC6dCpgQIH+lx*3_>Rj zDqyy!kcjM~LJX5bLW7uh5DaOkA*5JWGDg6-SUTiL-#pJK;Y13;$WrT`xQ0=vVc!3^r}hMr zv0%FXzyy;(?XrV>?0=t%VoN*-YE)dGn_GjXrayl=Eh}$&F*Q&Ky-nIyba5+WC7GrK zh-;>g@cToVLVAw0IV{n#JlSh)J9%wi#zDpmVZn1O=nFdDKj8~{K9v_;NV?!5`e}9J z6_ykm_X)r|TC9I#U(k4Lt)ZqvUsw0NQFe4Y#6Rv7zsuSmlJjuBUr5h>RO=%A2&X8O zl#}+In%(RiU&7>!*dI95YRVHZ0E>6|gAb z;1bR1cp6=z+tFb(xoGxZuyn>@<$Nh>jT1^*(A2+L&u?-MP*>vZ5^&f$_U;4sU41Kw z^|TR=uus(FovmkH1yha5(k_dVIo>Yw_7AQ*EntGyCh5^=xr(p{Z%_Ep98Y(FGKQ zdSa|+YEl1!acuOZ$4aDKc&l;TfBXJLQj#tbt`bYRWY(a6_$r^7uHT9!s*bhR_8+!4 zTpjDDbz>gqfUo}0`;dTwp`$jvY={UJDzyp^95t1S$nH8=aY~-u8q-rhh8Ajvp5JCs z6Qmbpcp?b4jx!Png=YKG0eAku7WBf17pR<`ptImJ`{HxuwX4vDoA)r$sN;@kP0PGFinj#3RpKdEJiEH_pA%j2((+LJ5V@o8qXSf(0-P9 zij%exUp5u2LrQ5(Y5xa&EFvZCqRYKnF($j`=gyzjFcoi{e&HZe9a^I@N!8KEzvEzumo=UE|%9>5$gS9z(=9xfHYsGd5aYBCY{#vQ` zLo78(pR~2LrtA8;-;5roit9w^DY&Y{CxxX+(#yVEnJ3qr>bOKHdlEnqr1vzc7DBQM z7@(5(;rK|P8v5-`KsBY00Sp3p$MV``xgj+k?q)wrpi1K2dN=0e_nhkn{hd|0A_*)> z0Fro^iVpt-K2)TX~;rc0;YHjT6J9$-{N{zMPJt`$Nna+yoRW zx}6-%3faEC@AHe;XHW0XEX634F08zLxX(0b2!d*_uSFu#ZB4iM+#ZjE(9_MWko;FV zz(*^7_T$yEe<0#+drp#kPAL?t_ju~SO8Zw!?jP&JZEql!oMsRvxA6Ahr$N1lwm!Tn z#keo;AaDrUm;EZA;aBP=WMP*7Heg%Ra6QTV7%TJx!@_b=qy)29%4vy{MI#C&xMvav zPFyMSu^_<-8kPbs0L9_^)C3eIRK7M=0VUXv?^Ae3xMJU0NJREPQ;}Wr5tVm|O@&42Q=&Q-U9lf4`bOHv&KG!MSY{Km-DIj*st8 zWQg?64==1AjYZ*7;GBuPd0l@fjoD9by2+DMlX;yc4r zoUE$@r~i$FB)0k=CU1J*o|$~)-<^(UqVTL$AKObzf&wZTX~wlAF|Li=bsx|a)9J{1 zWdkee&I*Z1q32OY^jLSdH~lr$69XHLuoBzKTB=c8YPLLXx6)I&hGGvn4Qq$GRDK&T zgSFY~^i`tfIZ5&+(;gN)@1ml${)PX}1TM5X%P;3@#lAotdiQ!K0`g|h1={VO%)^_t zyFS&{*L+@s<4Bl0gdS~mtWV-s?mkY3?!u8f!Fzc9N;oAJxJxi?{nacXsPE{x7L~-b z@GVhAaG)+1WfdeB@;yf?(b3ZJ*%f1?-PBw+2MX2}L5sTQ3r|+PT8c4uBprQ9UUwJu z&t4BtEuz*cv{asBrHQ&j>eZpINl+fVB0>V@$Ajw6SA93TzW=H7cVF*jAu#~?k%xk4 z#Vt0&=;s_}4brcimhVMreEkLmN+E%@jEMja6`+^wPQ5{x?4WduA|Bah#(<~&U?7|~ z4+DIoblFOTCr@N1@QC}E0yTauctq;-04g)7>D*PiH=t)ru5*6Q*t$X`70dU1KjX`G zyvt#Vtj}s_b)K4TL~JiP{h}H%^EX_!L@>N0k`|fCy2&f2jR|Wf_}X7*^RK$yLicHo zrS#?Ej-pynU`hA4Xx=#(L!lYsMCUp)O%bgGj~VUPH$;=}pVPFNZ)Vsono{PbH}2+y z%8T9}2n~Ou)TVzM6Jie{%oH?l^;ejomKi(-^+3vIepw80L}yTw9pa)6$!2!%z3uq~ z_ZqMDirXDU|KzlJr-)KDc|t-k`Zn2VFXf=3QdeYj53EzQV1(S{$2eRWVp)=CQ=%lE z9LeKk$Y+-)+`_Ay2M0>|iR=!G=e!!1D3`G|?r7$EK)Y-4@G?A2G=(P*LpW({jN#|! zCmWv3_{h8#am3;)!c1Y_F#LWRjh)Re(9eL`FRh|4=y_ihlj|363;TvDP4oCyJ0_4^ zq954C0a-tp89#^!-VMPsPA7AjwbV5Oqc5y)o|92`c=i)-#ijb%E8H=N`JGQxK@N3i zG>C#3PL8k|DFOFkc-JHMZ(6K2bU0PpJHtu$HK+n35K0Y@mqd_Fdn*SYy|6i~HvU=G%0i^6 z2ydN{N#`yX?(l%=rV~ce2J?Vu#XV-9b(4DkW-PSzaZC^Z)i-qJ3e`gw+jepc z1ZB0_nVVyCJMArars8Simv8`XL)xtVqRa_|} z6NmK#{91yIeWj9Z$?EDs63Rt|oBffzV;*V+Y0 z0gd~U_mV_$&B-|P5_=2jf`Ae52_CTeF4_*82$bbt^fU&IELLMKS1Yso`oo)!4P9}9 zUJMD2H%~=OzD8a3?So4kARyH}1`D3ZJ+tGU65C0sIA@8RWS5vAU07$oF(c%2o|iST zYR=lyS6Ga7!;1cN6{uBAs;U2h&X1MNxt|L0d9J? z7ToBz>|BM1&RP9JzvpGxOY+YV!9gJk1XlY>vty;E{DYEI-)%mjuB4H% zl02@t2=!&(uZ>-n^)QJBMK9LF`qTTcpQIw)2*qxK?y9OV#?n-WA)rR zcx)6l5^<3Q5-*R9JQ*@fc_w_{(+3Rqsn+jnU#|nju;jgW5_nRvYCv98M*d0?5p(z` zt#upp8!t%`yR%s}wr$VAmUR;|`-G@+%0tU%grdR#syd_nbS zHo2#g=J|ioSVpC43;@Lw4C!yLuesmPuu0niF|o@RIQ&i%S7t(wDq}HH?5Uzkep;Hq-f@mfo7^sCoFZbO2{u!fSO-Sy~2>}_^!BLw)U zALkFbtBD!4Tj(hiHXo<;w{#_O!0@tV8$|6i=ObjI=c`K&{Y>4Lj?J}=5`AW)usBxl z4+d$Prs~&@Js=SQwtOdT2IoKpQ;XmcR-S`PnXSlPAVG+UIw**awbmNEbOs^RjJI<9 zH_h8!d_oZ%I4NK6n5tC=r|#aDH0M9&#^5~)IyY>7+Zysb?3M?T{ku2itMAlXWTA`< zWIn^uQomfC9K3{);TSkHQWW4isYMC`q{-?c5Q9yB^)`hB;f(1i^;<((qvIr2(Da~z zh2?#0Yl?!j)=-pE=rju%9)z0DNkd;A{@02d&Q!QbDr zE`o?TEj(D82NY45Sp~k>t-8_X2iyN12!@g)wkZMUQ{Z#D|Q|t;Qy)pqWSV~e)tP&J^Lr0=tQ^I&4X;N zpT~yETSD6yT-HV>IF0kAxFqh65R_<{+^E0sM+)(tlYf4jBb}onUp*Vz`pQmvCE=a+ zQfFt8N&L)t)%jZSsKAtQdAR*n7Dc3if+yfm-e{zSms0OMa%{<_A00_-_rBEdtHsOH zcWmm)Xk3eB^4HiPCAH(&f{=y`pl>RZ&ZqM8Gx;d!Y+IHKzSamlqn6EY=K!K7 zjx{6&Lhvze)XisAy?g1rGabeajI5}cWRIG^D|8~qHK-{OM6vjt-I4u zmSj#2E*qI+>wj-t&|9h=^3K!{?)%E-^)dkC55qk#NtSQt{H+E4h|WXHn;8GON) z9VMBT9O~>_*fIsa94dkw5R4aXKt{~1|>+2%+FZ^LWaakqx@X3eJe*w?F6^nqA1(UZD z>uAzK#>?p{?v{jpmJqe=5(##%;8(Gx#tFdi-fDt*P)Uz_Rn>DOZb%3PZ)?%jx8N zZVjUSSPMcG)4d%2C@KsbBuwqjqjbuhkG>|~4t6)w@M1w5Ck&X%VH?STu)2wmm#U$# zit!fq*D@er%&2+S-qwxUHhtTueVc10)qD~!Qcp=ifvkCm8KhLl0S#k^NAutt0w@eP z<+MmV^*tG6k<%SLse{Vx4i8iaNQ@UKo=8ANu)z1S%C&Exqz#?j7dRolit%}&5F(tk zk|s6Vc%)ZrMcsB_3%CY$!Io#J`8Iy4l&K4=77&?EAG`9yHWdEnzwR zA7^JbWUzrVj~<^+0OjBDsPeX)_Pv3>HMHE1oMSn1lF_`DxkzaO`0qKICL zzG6dv$w<2qv2y-n0(t*Sxc(i3d`Q-V%JoJ}Eq5I%M%syp#d0in(dr?)`{(O%VH}az z#C3vv36r-^WOnf4BR1#=zS(;Zg^iGDhveyq2pU+}V1U znZi+=b1G10Ob1w>%mynXNY!`O4`Mn>bv9|#ZXdP!GiQ!I7wQ_RtS~uML;eUAO+*$O zjt3jzUY(y7X~9qQTGiQt58+oreqTX6=aSzQdoHiKdI4?B;i;=J2?K~n%=VyiSL-pS zb!bV(YN;5;fPhUv)8h8v3W6n_(ujBQ&^%!%WHhn1vGLGcJ}zDJQXd!haNF1__471N zUVt`}`Q3r&K2m=P)1i{3dlM1lx(Fgtbnf!-FOyOr3S4>1$5V5i6sRc+{3<2ppFE6K^M-n3UteBw1Y>3G9pgkYHlpp{xE+J_2TCPgVy^*<2rK= zuOb9FDi409p8Hg4b)vpG4q4Pr*ty-*43Z4YS|TTfn1~eCpH2@-F&LaMOMB>e@e8c% zfN$AdodO~litF@wlhq+y5xev<1|RN-3qc+MdVbX23;Xd5MaHW6a@xr2;7y;(1VjiXph`%aY8^@i0zMuoi*ood_q6lKq)^W54q3zTN}O zO3Z9M|Fv+5Hw;u(gjw9S#j=Fx#Q%AW^=U#Jt7~9b2HaZRCYBTN$)jJO2AbgO05aB3 z@A2|B94pg(l)iI}W9mL|B}4}MMhhEB8;y-Xl*vV7q~+9yUxT{+uSUdC#*F{{_$L+D zlie?&ldVD0TAKYW2!oH&1)unk~yMJv;$<5U9A75!~Z9TRBRS+PX>#yQ)GmxOy$;lPk zi`*Kg&K=(Xw}kmmFqWH_7h+D9O0HuJp8-7!ya(iu6o@58o@#3#96}aT6iKsUt4C*m znKvZFWg0MhNf#c5iL{~48UNc6oTP98!oqj>>fIEWL)ELTJB1ca`I>aq1{m2N4sI@Y zJb!j@3+8_rtV0El6mW`x#2W7WQ7TABUr#J0RSdu*_^#ok+mc#z$eEB1TI96E1%d)s zLvLIoND3HDRIED`n5P`FD3q`vZ zB!#PIMPW5CDA|Mc5?JcEyL#VmZxWz`>C?SQ=UiIKu`R6v5Dh+x4mQ6oz-Qp@uw^UW z>c*hudy^YPfQjiD&2vfcc%+4y?)bVf%fc%>qY-zPv~;PE;){K>=3 zQnnsRPMb{Y@%$>0jD47*j)9qTS>^XT2(YO(qM=i}Stw{)*WtbaKk^I#5sqnQuBMuT zk$qm}hZB|7?SBratlgNo{Q2Gsm>~Zjld-w@A2``heLght`(qKFDa)Du~U5%PXmc z<~7vQ*ew=tzNV@`*%>BRZWrOA({qrj1NPb{^Eo<$Uq{aMMH4=ndRPZpOHHLiT;ve(Gc*+I01s|Urq|5KjoKHo z8*ZQ+H;6XxayJk<&}|I?Qap$d_X~xy&&loPbFKQ@&9?IL6kV&la59U=WxO+dFyEjc zG{8w|yZ3Z)v%Nea4(OY(E~TZBF!;WVB!atiNW7q~=Cf1;<;4RFyF>hJ{=5oNrAbN) z%SiDI3IRi13eKdneL(%-EE*d3f(#+`81Nwl1=wV-mR$-h?7dP+h=&49HU9{H_fF1~ z`hR90&&)xLp(I1RcMNI#aN_`jJL_44eHL{UVtm2x{`CW9aH6FeHAfc|I{X_1QIy0& z|409_kGp4#<`(rt)(s)?=2!QY-D7m8G;C2K_;>^CiY@L+-6qU5S}+%5_sa+CBFQ$<_3d{Sfnfft>V5nE+K zawAPSG_4&#zRp!xJJsSvG`O0+(sg<#0DQFvWo8h_KicCq@;S|vVl#tubC)FB4=)Rs z{o&m^IzRucS$VX>Oi%f6;aGo&*IZCXVi*infj(dSH3XP;CF@2!1C%lT-W%sHBAc5D zHNQp52g=xToSpA#GxQz)Gv++^5|#8a>fg(1JLJT5 zEbfOzO}G27ApB+&nWN|_-zH#(uyyt3+l+O*#Jz^y%b#9$xqxm1MdBwKpP5dxZAdeV zjcEDXb@IY8=*HT@nj1C0|G~9Bm;a+-Err{q!+9?;CmEpsiW)~VF~WkxGFJV_Vg>hJ zst(kv;CSs?I{cQU`GrX&j}Iluw-1-0BzEwr~Anju$2L0n#fQlSJ*3m)-`x+ zdE(&U*m{Tf+{$3-D0lSa2OMcN`~LcuG~?rM$X?r83RT^WdxeaP+oxk|9hIMIhcETI z<=v`T*}pFI{cD@K`R-)zyQcf;>EHPedA#?=gzvN9=3d#z$eeKk7XwUUI3kX6A7QpIx&pUM`C-ffZ>;%JQO?A*x8 zu}c3awXt9zziN=sD<`zC8M5{iD`a_j+V4Slz#(Zn541jJr<%x z6N_Ff&q#wg`g|D?jJr(LLG8Mf+zW@k1yQG&Dxd2;vDC(}uO16n8Vyezv|~g#-&~>45(*x`<#%Ahi`5V@=)qG>QBU@v%)KGU@HwcCxV5#SBq~ARdPaMZI2iDRsRCy>|Gjxhcxi{P!yN$wJyY{ZzCZTVDBl8v z^HRz_zcXvKE$6bw6Dxb;zoPU?28Pkv!r?YYiSvdtc08MxQ{`ysOeBDtlY=(lLAu=P z0xT%J5ah^UQP-pSzoDAA&yPZ1Yv}+54i6ITUvNs8%(1wPQnY6G^SjMEp?VFVa0iPP z^+iZo>LMNQoPz;QAR_@!#7IjB5*HWXV}Cv^39-grtUXc$WHCZtto|>I+%@B{-dy{A<>pK0y^r{auchTN!Vw`h(vfa*9Cp0Z$C1$M zm>UT<^Zhh&yQ`yTbaAo`s;-%on|7#(n~AQE*-Td`colF9HA4J83aO^N4t^~IyH9f) z`vi;I+iQQ~-_K{3%4-)EMr>09jXY&LNAa)yw7R82Xu&5$0^WD7CxNGM)5|VDfj&k$ zl8$aMO+7c0!xy$~psmo|KRQGN&Xi$;$g_1E33MshodllWAvP+VUmdi06 zN+){3=cBjlSKUwHe61IeE7;&51%LC4_j4=@kONP2hcgF|Dh zBgm#Nlm);Q!6C^pazFP&eMiEDGj;(L7NoiE_Wu&tACTt*rmSq2Zt4b;6P)P4X z#mPCHOdQqv&+}3*S|Q}Fv^MfotMma-EHtP8cGZckK3H z^j9?^xW>p)`$hNN{RMl-_nYAzALP`v(nfV{MZh-xK+V#QDINb8j{^nHn9}=@NF-W> zSE)JWG5N)F%q?E>%3?jDZgFEm>VWWr9Nwow;-UW_hwV&e+s=a7*Vm?M)>tAI*Dq+- zqhv0_Y;`!(c&AFKPrfLOu)i;1cels!+Q}h6uTWBeDQ|KjBq(5OhoBD!POUB^Fw!vJ z0QWlD#+pnCE{38&3T1}+be0~@0#)4NJF4_Aa8!*33vE(3jOZZYq8flWgB)kGSUldn zFoL!>_a+#pk#wzxB1`FEhL{WrfQktycvV|q2kwnSPBrhjrq5vK6}I=dw78M+i(b7pAnLj+aK=*^3BMBkf&Z_IFj(b4y7d>QMi$zeP+J@oeWH5r@;^nlN;+ zN)FIH4^G2UizRdfdr&$^TOaCkWWNOA_Jfo zGQI%M781aT>+rZDcvWHvegxTjZ&qrBhP&S+X@;UvGdDCuRF_QEMl{9`!t^9#-2WB5qI>d|sC3%15&QQHTQ(xnf ziP>hsp7Z(XI8W?#UP)@K+&1ZTYK9XgavUH6O6j>ON7=e6UD(^G@o&bs+2ydhU z#daY|MPZq7_8OLYYKE#(qpg>haWo6dD!G*v<#>Q+MgJ`KNDjEDD>svAzuEm!vjp1g zE>4N@!pPT~du9hAtMmw$4ZEH8sPB)SL`Y9|PEH~8i3Ha%yogF)!gvSUd$yby@z> z=<24kiGoRkVz9TbZC8U#Zg@orw$+$Sg7*sEA&A9mYKCW( zdnGS53o}JHDA9sQlSl(Oo~UgFmUOCQUNBwI#-`%>92~85-Mmz0GZ#oegLzT2$jHN9 z7Fr4k9NE1WYT#vTJWh~V>ZWBC%TW$8OQ$S zhh&hIZSgpF2w(naxLj|$lYH!k+=(6)u}xc=xHJE1*qwix+O8UNw{}KHviT(1pF8R! zfCR@)6(2i);qLq@Syy|R;&#ut)NJ?i_7v%bO9Fq?$%3Yec^i*++;9KDxtxRulXUtu zZzgznc}cXn>B|B({LHeiho8z?J4{IWh=^pGWHzC7d3q{P+WzK*j#MjUtdGya(s&f3 zsQ{D7YW+!07Bo0|m;3%;y}5}jlhkA}8v;4q zb$xYt8QzM^V>xDBpDM%?ZRoueM^~+ow|(&PeApvicm;dyL^WC4N!6&0ZBROs?*=l;yw=+_@m@7I4PX_FQ2tH0^joUVnD?tc>#{c4>dsE z{b}%fc~uto?QOBV(8%S8Ux-qqz}Yg1*)#PsRCor4f~k32^6H(V!5vfsJLkq@TUdsb ziOm<%bTQR#emc#w*)S+&(}4XYHKyeAYE`<49|J+Vf>CvLZ^U@&?nRfB}tX4sT*t3Jz^G926j`ZG@aJ z2Wmf`5o4K=68Y(epyz`<&?NS$mNhdv%vQo$~k88vh_n@fDce7nw zrxeyxFFJLnSX~*ato6}8{ZZY06MASDJW6IGDjLLgwR0`yS_qYe;pW4mgCE0S3fzJ#R!E{#|9pTTzys zZifrw+y3vLgT=4f@D-DY58Mr|Nu&SIKn9SpmwCB`O_UJg*#y^mO@vi)EK9H9=H zq-0bzE%Tce`2i{Jo{$lW7d(X``M@MiMO}Se^q-5Yt+=O%wM@Mx9=bRv@Y`mVQPODA zw@!4{*6jv=EHv30F)<-4Cl3L;?E9>bu>?(|b3JXjv^1~1n}ryFK)R0{w01YlF9eGUqQI(;G4Q2@i|(6TTOL zh_&+aJ4{M(v&^KJ$_GP)#!yd~$K#FN6gp3FOdd*(Y`X8pnjx>{W6|pZbnaNvWtzh+ z)O_{jfBxiA#VlWxGSQ7NwZ5#@Raj_g<<0*d-W9K2Ea)KV#tHEJHevT2B_!A!`Qqz% zCpD(oH=f(ufazWf5l!h^2Bn#>2Sgtf(ooLT^2l1htb$ZuFNgkaPKW`-o2QYm1xVQU zu$>BqH#<*X{LIJPxsRH!11>~F22RI<-slBg0oU_?h{WA#MYf$Ehr;Vn5??JI&*5R2 z7z+7Hq@GIx|D}!_jJt60N8yOXo$lZ6&dY>)-RM()7X7Ck0;u3YC(@aHy0h(;n*Z5# zlPuvB_J5D=dbHiWf30Jjf+FAv<{ww;3r{~&1t`)m4$Os00^=LY>T?K?#bNBN_l9P3@8hQAr_^d|;GHKskd38v+vD`shsCkg+4QFQ7;8Gz~;E;Hw5`8-%HJ_nCIw_t&lly{I z`{x&tR0he~>(CNmP(%_#AMyV(+hw7bk>Y2e1sKAfYd~4$1VVsGHiE&DZq=yM&HP;q zP^LEHyc=t-fQNT2j`d|KD(@<;Q_NSO5T`_F{(AYXeE#l6`6~Y1sE7G(5l@MaJ0M_Z zVQVuYni%dd%(xXuSu|d%yK{K_ExwXKXeY21!e*`5)$y&)f&hjq?D-zvj`%O2R^)N> zp(kDHA~>6SdO|`JFz?frk4djrNGnU%0**}ulFi31rLBx}Tzxn*o06yIC@SS}kvKA; z;ce^@V3#{SEWm~!6V09U)o?l69Ho{E;4cX%YAc$-5BmOz4C){cF{BzqApU21>MiuS z@211!cps}KCDEkX={yP4&$M*YnG5kR3FVP+NG$YRo;}x!Tg6?|=t38LgN5NULQD6# zoyy++f45#9)a94eR9&j1Yi;veuDH7Oae>q<%uut%^Npgxie2bXk9T{X^T))Hfc)2E zOf8%FbfdGwfoGA?_2BqXmt9%arR(%h_*9{fT;THH;)?Tgp3pVMrayVN>*aeJvGa(w zA*XeT^_4NQ!O&FS262?dipa;{?{50Bb4g5kgsB&cDft)FlEs|Qq3PvfIbPq)x68(5 zi7VG%-m(gAiA;}F6El5LRPcnTSw?eNX5|j|X2rOhtog{oDe~BIYMb|NM+;@w)haz| z>A9A%a>iXA7BS5Uvp0*w5O9udtc-!|FT5b@XUKQJ9r0W~RrLgTTCH+RyGu;`cG(Bl zqqB0lJyB?+Sf_{g){h^6N%m;36V)J&+`Bb9YQyp&+UIb&BZv|fnD#Yo-Iu#n4}bYD zt=2`_=*?ZkB%aufNB}z36y@MerXnS4&#B}7v-vGfZ{igbQj-)`5m%E|T#XFlkTW1vHltPX;-@gK@ria|13*KAV(KPiUQ(-bBIC*~0`4>tkS z05`UZB%4B|eMr{~lIj!ub(u|o0J%^`T>*VSlc`tKBmqunNCtz5Mb~jG)6hgOUlI|> zMc->I3WBd8D{g9(q;=)wdb0omNB3Fi{U-zlIV+};+s9@pVl%Umic)g0bEL=nYRj9)8Fw*Kut@4uzW z)&P|P#fA4iDtc(Juvmax4GUYUU9I|+|EMpW_{zt1IoGRa404Ynq~*+N zItzSe^GUt6LwEs;h2JZy@M-UrneC=-W`gg}4J`B3-P1tEDM2;;^Fxx$eLM>Wy4l9# zF`P-Lb4Ky;fDnK7%<+Ag@VC>K()o4+QR2$OU>-GGOWO?{KQGIa#cX?d73$ZA+4@@W z5o_0_lfk&6yUkNvw?Lb5g;b_NBj!Hsnwap_>d|k`oMm zpKU|J<@AfODc2ZY!6q-i^Uvy)U|%1WGw{4k>wS<1NN*Imn8;{pE5-tc=>Ra$qQ~jb z`#Ua+Cmj3aWV23v)@rvTciVort1Jfx{v_5+SSdY?X6@4(hc@eU_RHXR>$1j|YuGXr zanK{=FDItw_uUWo#kCGPpBJ3>Lebydpu$oC@TGAe)o*M&H#@5D-{j+vyC=kq6X@C7 z&q*D&EOE!V<;F>GA;5D9z?xmdaA={vn)MU4<$-g49J;-e-0^c0Y37G8Wb$r~T+kj0hy<}(wo zj1f&fj#5J(3{{E5;3d!y1e2fyRGSLxHx?)m4aeVC=u%KhVH8ITQW^w0lzz0#^5H84 zgvKURbxRojxJwo2E$h|K3=l5B$gpC7h=G7ELVL`@D{ACGDTVN+gpS?sRiK66#6T(4 zaY=*(rJkXMaZsZ%ga(sP>X}+aDng8zvA74J+ZOxtD5rCU9MO^KX#9;AyoNq7k#y(3 z`92=)t6~K`DRX$t5Hpb&A-j8GWKe%cTfNGvXZ}?tSkci<0kB#uE;re%{>4tfTBOr| z&t4fz0LGi@ju@0QgoK2i;Ek&)IL)7gKzGx@?2E|oOg*>i)&FsduPc()cYiuPeO<=u zDmz{-00oBBMf8f(p_bHoQ`KF)xviqAt*X84)czuZnwG579j5aKVkZ;~>BrW_K`PDB z)9?m{G;J$s;D_J)4<|O~DL&_`?DV^wCw}>xqM#=ScRsgfNEuJX8%ik*Cp0$J%_Scp z?9DlEQeK)xQ$ku*s}@f$a{E=XXQ^d5dZ580X|{2!XGGAORLSuXDG?m+`2xVyV+ z&;SYU?(PtRgy0a|-QC^Y-C=Qud){01{oLAGJ9}oHneLt*UenX4GeASp_OLOr+VWU9 zI2AFueE#+O2$W9qEUCxj)`iEnVQXLk_#fT8eKecRmOI7%14RD3yqE`pr?EzgFY71H zQ3w=(4TW4tADMuI(MJRyfuYxQxt?9+uQ_f8pNV0ck}2i;oV1T;#bjP-TP*N$vM!+eZHzh+l9TC?6ly>r(9Rxyf{YKbr^f!q z@~!8qEIsb)rWf3zuh0V?s3j4>?rLAoiVhTG!TW9ujTcwN)8~thYAG2FkJN8D>gN6VcXQ~XRaSS7;ko|4RD&D$ z3{`qL9QfoBl&H4r!A*6U=n@!d7JlJUY*ZLzq|USVww|A%Rr>yBgvF;4BMlJDE;2UE zdDolFcFHl9bl5$Rx8jQGOwUuzYiRHc`@Fm?_zp;@bd5CE{`xcB*l(WrIm8$rI#|kR zw}%WJmnd$2*DWBqN+k+11Ja2R94t=B&hor3H>;Avn@%u_2p(1MIyS7UG zubi~VP#;tF*1GIuIbR%HOot+OtR9~;7B8EtJ*=J%#U7_IY@!?R_bA`MwPwl)kod_v ztv5`uhE){J1A!QkgpY3`NWF`^>JRZ-@OFl1&b=CB_!IwxZE}@;sAyN75Jda~MY@M5 zgZFi|R&OxZJPm_-PR(I*-rB{CSI?jvesNi1>+-XmPgWJ_2^CbBNsl4+gpWhWImF?6&Uz$x8TuFbtNaZ`h$k+g*{{kf&lYbFT%78m%ci)r1$fXOI zbx>x|0Bii%I=A)jH;1YGgdPqZF{i0E>gFo>j)DwB9IcOkbxHXe$AV3IP5(q{hoL*t$r0l6;V+(P0 zo%3u=V8t1?+_TL3N5-)26m0#*^#^{k@HjB{2!%5$3>`A0jICEjSKJ`lUtNWWiH}G( zx3)AJhSnKJbTarMMRIUmDiH#L?R&Ve(SI8!PFa&D%2hAUnJ23D*~fH;gErpi+-zC2 zD^Q?}d~GhdMvManbmWsXM-QU2&Jw~FLfs!9bN5bgm|m{2oZdIum7?0-Y?Ha0XtX9W zmb+`#w*HNkbuDCGjz{^4TXtFl)xSS_U>6wPTBi;)JxpJ2kkI7&-iW6)`Ev3_PeDPX z)b)&7pU2Idhyp)7eOV~H&N20IAzz51+0M`XamY6=07GS|#hD`acY>Y|Dc9$8Kabg+ zr#Kx3hKWYYLB6h}8;iz(nSkN9XShb!pFSHk64FCM!G)D=eLSp`n0hJ9;_4=jr74EC zI(1tkEtegCb-roLO-2b;f2eBb6Ih5D@p>#8|W z%D{a;D0(|ja^3x#+RwUl)qI)H+-_#R9x5U!i&5#fV{9Lbv~FWnL~&}xsxu?uUZbtRLBHPV>T9 zE_P8Tm807D)3!_k$d+4U+d)--yu=8d)D$OUgns-;>f+LBktKnwtKSV85&w2YAX62-4 zb@W#mnVA;_4@hgwvWfQ5=|>f~Fw*Lf6wt&pRo9UCJzYlXfCK_PdoD-6rk4S1#6c`B z87OV0U>E3_Va;=;K+Z#zmu)1x*T+??Hk+vbo8gPC8tOt9V9a0 z5}i?lE`^HlXtfbM6oYCwrbK;L(7ralGw+cOE-VWdwuY9-9!<9E@o(`{X8hm;Ui#$I z3JPez{v#wIAeq7_!n*D_o?2T1K?606X@6&ql@{A*p0IJMXb9^tj-+*wWg!O00|atO z%dI;r^@6-Xzg*_W>nIG~A?P~15f~4=4IHc=?sYy|Q#loqigSCmE}p=17KX~jE;d>F zRw&)SriV7$dp)<8a#*NkENds!@CGc4*}s9W(eN>dab|aZ`#w)WNGAl_3V6=97bq8J ztCu>QOhG_P_1AIx2hJ7}%L#oPjYrWcFN7L9esYYi*7l-TyUeuan8(~V^fOM8@XOnDXEFOeE=+JT9Off`p=# zZ?^sV1xR0McyHlFeb`l>(^;LCtd}0IgusI`I$OF;O5O9S$97rcAMUFGSY(Yq!uX<; z9rjlydAWAOkM`8#k}uTN?IE;SGNs}mf=&%gwQ(~$e3x2{Q7EwzbcuzJ=S81^8I||5 zrOXVn2Ikv|AfrYtUHMOPKdje`F8#ChPWCq_Y|2rHlg}&CN(5efYum=`>PWwnAWR|5j1Ec7ZCr@L#UXk!*dlj*p2b{Sec(&)@LdOUN$VUcV8LJJ$at|)texk zt@F=5<97Ql@%tYpa%m(w{&UvLTd6*P6&a&|8fvSa} z!{#9hnAz%1=qH$)^*C#ecU*G#Jk{e()~!V1_^Y=ru3 z8o&}#qp4ikc%y9(<)N0HdVo~*1iPmU2{;+UfhCZm7k>z5^ zI(`s%$(>2!nhgcQb!%$kGlxYi@jIrlahUT8hl(U^Vf)io6wAYZLXY!kaVYIrF=^}c z=hy1jsvX7@O;8i#SeI^4bK9-8i$=bdccq|@i)5quq)+{Fuus|oh1Z(++8=i?_^SW7 z7cN`1)ENBZJ=C(acwo)1t-<=?nS&)KilvuBBQc}0qU820bECC#V!VAhT3#WE0Kn#i zCxVB$G+bM~Ubgh#F<3wAf3p4WwT*^)^%id@cp&Gps9_tU;<7evHI03Ol)oF3Thp&I z&jXm+psj=BkSN-?AoQ7Br-Q0x)`yJF%9VQa{z{PZ(|0>lk_iyZY5wb|wOhLj~2bT`023?F~Ri4ciFSaFT3j{HAotn^5!_X`rlAQ@I;gE55A9o82<#M=V;&>^UC3MWZ z*5x&Qv=66QYYB*ZKt<2(b7XN#Ab3*HL%g}A{MzOL)%FTGl`xNbaQ$`cWpVWeFztE$ zbn!ml^(m~rz%2_SPt6O3aDieME=dw9qZ@RS+KZo-x^zbUN3%Rov%F{3374;dg#T)> z#B%iG+xK(D-FWVwEM6_lnp*jRXHe zfm%&xIAEkEp=_q7Cw>eg4+Gm{Hn7{Z|4Bbo0m)Bzqb9@)Q8B|E_F?N!TYg(p!^`Nu z&dKntK*S$qkcxv(fk|}Yu>nfeZ9{RU{^d9u?iFdESop0qVk2&Zl?xpEboQM!;l@?x zA7x=RcVg}jNlfg6_~73`Mh{gzJ8GdzZ~0qmm447Af_pIeov*l7m8$Bt@UV293F*d<$t5C?}|r>zfzC?V3ntZ zcC1OE*y6@zfI-3;4MZ1Cq^9FpNM(S9mJv;zheW#chZin4BBGApFR|5qD4nfSE$KvC z7|EDB7v1~LEe5Y0D_m>>SQl!ebGsXC7$n^6F{yP59VYTREdJP2Zxx47=04NJMxdO) z#tWcR- z!QuMHs!TQ}ZSW(SnMexjclz^ApU&jT?ZtWJ={mk_J>l<6?~PKgO2JBq9}ah8?V*K+ zUC|Jxw6PZpd0JsWO@sg+C46x!RTGqF>KEnO3gi44)q4H)S&8h!g6Q&xr@kV6{{oFr zj@<=*)miyq@0;VG$z^DLm0p^kfzI8y)}Wi6!3Si^p9(iq;<4516{RfirjSN10fWLs zO1meMTOxr9mDx<+yn$__4f7?-zlJ{b_b<(bXcsHbjLzNS-Q6~6o7%6(VQIR~6Um=N zH`k_PGHZcb1_)KQviWgFzOq!V!`qJXQ^US*{8Lxav7Gm0d{>{9gg(sKXo8L7IXrjR zs0sxH>!?heFup&|MSR4{$k=HH0WrAyH5A$JGY=J26BVSDh4jGC)ql@fx&DmNEj4}K zi+z@hOW&>_sdpt0v6#HjzFA+JL}W>~0o;I>Hok$8Py>{v$~O<w&-fh?_YV##*$gY!96fp`f;u6T=g$T*!e7_LhK1umlrS86x0n78^vn z5@0iu9_m6PdT99ZQZ{EhBpnG8q-oi@&ZpmE&*Yb7s2q;{J7Ix>^hO1>bbL7pj?K{k^9-7FZGuumnMRi)h6FGSh) zLl4kV1|fOF0o*v3T8-zWZ)!Q8?s|!R;xMH(QIn#2x^P+#5{Cc67X?6RjA8}m{t8?i zP7w%Gogm?^uvED<;}?(O&oo6rb&u_UPZJHPd{Ow}v?M4QdC{$#IjX70bCfKdsRZRKI}vM#`Wx>voCvd!tU1g2kLWHU_xfvmjZa@8 zcU1}2?ao!w#}-{fHnL(Yu{+9ccus?lUv>P{MW0k!X~og9tlMmJ*cm(&bjDDMf?2MV z&sLT@F_wTXJp48MmQD0{EIbM`1O$PakLVf(`Xy@w9}ubr!Yu#I**u-pv0(R`6`Dz| zD*{^=-9AyQo-SY)-Z}w3jJn5qpF)*q7}X+)2Om+E{?>DM_lr->s-T1;-YypYqxM8_ zah{3l3@?8*Au&nN+D|sez+4mG7(E8$^&4v1yYq)r5jD~#Q!FTgUPp~~IJC5a8G^9& zV*Cr%WGFpO{!W)+B?U`svW;J1Q%kns+Z#J)qI}($XyfLkYEPZtBnOwvKbKpL_w_h` z7tfxmG(w(k%v<@^J4`r4;kRCkkGr?1edpSmo4wbk+l$JsbeP7Y&pW|rQ5tikv- zuGZm(XJoPvpxB*OPiS1R4)mBLls`)Y5FS=D=}!mc8?LiA-eT9229Dm1u7@ucmB|-& z&Uq72Rc`B%hM%+Ee)_5ny1y@}{BZUJOs+XvP>k_!$pj$uQr?3LFuVTiLaYsLccru@ zGgjU7ez`Hr-dpS64f>=lCb8E~UvMz~ivP9zkEdzkDDB+cRbFo9$+_rAC|~iU!Ow~ltE393{(Ff!_Y2?rl$!4qh!KV4#p`up1iK`n z0<`_LC3qfWK$M_=+Og-}b$FmISIv7(dP59YsT@?%e8luZ6k5m?b8dst#7skB_$}j9 zGUT|xfGh5ubuFK!lnBA`w?Z;Yi&$P8`CgeX?Eb>=DidWjq%3?&WI;`Exos zpHrF_H6!^xpvX^s<#M5y-7%G`khu|y0197H(bQ)3y)xpSN6WxNmQQlU5iR^YxtCgNt@!@COc?`D30SzwY9Bs7rO^3~Vu= z%(atu-$}Jq5CFFlChxO)4vb|7XSTm1XESPoHaKatDu~zGj5fkxXyZ1o6;)KcQ6%st z^Sq#J_6GpeCrq+%a5=B>KL4v$qUn=X7BhE;-6mHfp37lg?#{}uHX0Rn4+0kBf$&{a;Pus|>_u8FG z6=tjB^DV3EWYby?n3DnD-t`wlHBNA7q$y}$Kl$MuUT$3NpG&Ma6I@O8V%12-d`MWe zGbMbjRUJ@Fy)TIBaU^IDML{B9wd~2_fE6oEXnm7XYO*`2W#PXlXtpsH!_rUi>`t;54Mny!;_214n)Zk655N+;QR z`)>05B8P@K@p3ajsBm;j_Z=OFRN1aOxJzw({;+M-tp@LYl=0L!t$O`;4R^1L)k-z} zUhW!cw3s))j@s{^{e%znAG#Pn6s2mV?KUX^yn!1t^;nu6bymQ;Tu#iH0?k+Vxfhu6 z{^3O_j)mhxmXP5bF`-fpktB^kHfxrph1j{8Fv~`S|~K%=g(KB^K^4R%t-$a z=CZw*VGR+3W|W0*`yQAl9hJS92>v@LqP7d7QemCoFO1uLu0}V^9av74P5+n)fw`mH zv$PBKmxfM+vXtGQRGFgj*vHFDE}a|adv&m}WkM8^6~E%DUcz0yuiQeuGz(|VlytGf zP(^`bHbiL8zuLWJ`5KhN51$W@?*$<#^i1|IuRnC|voHKZxV#$@BHEfHJv@sFI03qq zj$&yPPB&S^*bK)#RFnb|F*bx;)(D|kuQGqO2&B@td=o;~xY~_%XqcX~lE9WahFLH{ zK0BdO_$xmhTgyLWXs%UGweTH*21EssJ_N}huxty3L;s3Q$Vwb#3AD(gT}7J0m;sO`p(A4Icd0|`%cnZL-; z^@TXn%5rNh#R$SoxKVUE9K?kec_;7!nYtey^xJyR>4( znvF%}{$Ths?RsLszkl&uj0Qo-8$9WAdN}C?Eqr6u-%1YLmY1~}dNT zDt!YXLgZd!eYk1&fDYAUu_Xx}IjZfQUo|p>tkci_+|8+Qmzg^*KP2U0wQPQv-lw*e zQT^^PS{4%^rcj{<6m73~kl>@bE?gM5$p}%C3VhKe==%fXHu>7jH_{D3to09HoN-%R zPR}{siwiqYBO`y_DZ~Nb4meyr{B;@&?w+giV~U3yzyfygigkE=^jfJ3l`(_Tq;zGB zr)x^_CS30kWe&Oz4Kp)VglO}g6e`2^xpxkZlg!JD^nJE(BTTfQ7pLdu<`U=sF!onH z1``7X_~~ujy`64Y7nlw@w6V-n+JZH=rVc+j644z-zq4fT@m}Gml8uVv`I+Ym3?eJr z^nnIa0_#adC#Mg%w?r+AMNeqm7EgB7(K;jKIyX0u!(7eX#9XsQSI^E`vovGF;!*l2 z+V->MC@m{~nA<`3`s!i9$U%}*CwIHU)oa)}2Zvj~#f@Zz0e9m!%)WPeon>Q`H+o`D zqU&Uqfi48KZpY7hW+d1IG39c2lr>&6E-&!>adw+;F9SBCDPzFU zq0os(-l3Ef@S8(&BN@_pn$Ub&q}EhR3Md3gC99aQ9M8_oyi%7PPgAqKkTCHHo>mc* z_}`RO%{6zKbC`qoxq&~{;~T#RQ{6xCwd`6yru%3A$B@uY){AOBE=~&`RKNqC^e}Ee zY_s%TFDBdFm}vqS^nT*tO(vMUZll31eNI*6w z=i#ChufV5`CWaejwGXG9Ncr3K1zNY9kTe~$LsFn3QELR}Y@$OLVgw{EVl?+7Thr0y z4P!^%6ALodj2t79fwD)Q8e5yG3Les0Jz+N+I~cvlnHV1jil)$CVT(cr(_IEKzXr8g zxALW=lv%^pLfYv2-VIg3_z}U#d2TYdB*~UCpT-|$>0V~qg$~0Jt6PO_)*=v;5osc(m(8{PlaA+!x>8pZ@s%%fxvfr zrsZwM9{N|9>BVWPeX-PVL54|kx@dX?b_1>b+6!dle!uBZO7?x<)R;eb_9#nWOi|I% zja-@|Ew?O{x+hN;d}SNkH*=}fz&3<(^TZ2X6IIMW4}1x|>qk3v^~XCA2)RK`uX?R> zcp&=pyIf|tlo|5B2H_IV=XqODrc7ucdB|lQo&x%9P`)cxW0V5%&I4$`n4M&XQ(a@) zoQ#+2J4al^4i(AG^&7My#m3G>!mpvCQr3R47>&zH# zwvd=F=I>@>rnP}YH?K$1UnOG)e_7%*knqmuo|EBc=96r&xD@D)b96?ZGl%Uq1spGn zkq#4oY1yr}Bm@iTsHRSQi$NiLEp zh>C43XPBh3s~+3y$muVX#4&@Ya6Xn?$Z+ia$<8 zrJZ+mD|{}+E;d1=;OFB?39^x{#4&cooDAD)ZeeP2^-|d0FI)Jqc#I6>0iyX^rLl;|5;)>JnH=F>-iH28k{va22n@7X&1W z-I_n#VxX`-u}T%O@}?)r@jwVAvt3!ZUq*NmbMUS@Gr_;|_1Sr0uo-YE8CfRF8kYBE zT_Z*akFd#+RZgNs9@?g91|6WhzN7iFJ3SWhd9v9^>)s19JN5mM@l=|;a^p?ri&ir6 z9M~KHJeS;iM|Svt;XW!-?Z~8IPq6 z3>nn*9}OLCM}QxpiPstkK*}oKF%^IL4p-IS9=JY(Hu?$fz`xPVVhG**tY{Q%sR6#L zv3pn2)${GN>=%|v?Vy6EMEUfFX8N0CEYV9>rGZC7`;MjEb2K5&rr+4VO@NwO<(&YU z5h?kPb23BA$|hcjp7$85EWP)63n}`1ba&F$g$nV7qXi+8b#CKNk&v;UGlOVh^Eq|< zj|&z}lqC% zGO0RC?Y0~soeHbr6f!rD=89xx*W;OuaiQ^#x~*FoQV`IJfbzod0HKiXx+b8n;m*fA zyheipO^{8xo#{8<_5z}VpmQRZ!eFF0xyRY1LGwH7@xCa=ZEVEv8xQauBYdGd*9UmN z>2Zh+yni@rYpT9lfxN$w85i~oeX0GhG9~r-+Quet^s1DMEf{f3;CIesdL!5?Rq~8X z^5u>6ezSy@pt~%ft^2FLMkz=|I=+lJ*wJHV&T3Ag$qaADGDIj^b6GV|81VR`S7mP{ zV&H=AB|U%cKNF_}R=Oq0uzVa$JsMm4d zscS0p%h5Cl4y15I?kk2c;1i(;5JiHyErVT@Ps+vw)2>X+vtWu(^cPs*ePm;&0~V#N{zZ4m=c2}V){{A zH9+vd{FkR&5;0YNHY$KsqZbx%57t!O1fJn3ERph}b&@Gaz$g%wto1+AJ`jPg>Qa2O z{<(FUW=3!U=0iWMx!(FsrA(Q#_-Zj8LZ8NBSShBf{nDP#kg!Yv`086o1~BMnXkYXZ z^84w1UqXV>9*v2h{a2)wgp}o&#`=!ut^9JkD-NteTV?;Ky6 zN@RjX$ACU!g~6t9<_9^LpE*k)$ch%t)H@t{)>CdLo2`y9o zR{g3~}>r{!O__*Kt648d+%#> z7n;430vckaRL7VmSioaB|Fc8xj2eZ{#4nH&9$;C z)J4vFx8u+NpDgLm3_XLVm6;3+>0}%;LsJ#uLo(CPLZUP_0t)Zp^xU3YY~?u5CB7H(czv0^g#^+!3V*2H@0*2 zqB+7xXqXp6ewUfTwxbioE*=uMI3rg40kl8fAD5wu83!Bb$8#Ayvy)^A)FJx3E;ThP z)|S^jZYiQHSprE~I=WwdmfmKOFE(tn_{sm%(Ly4esYUycDxvi zz232!4P6%+-#R{BJaC1lfR7IEQ6lTGTdy^qr{d7iC|vzArYN!f#J0*1RjEM4z7Mf` z?#Tu%A-P)^CscR7TDR>GRh(P;L$i?}C@qZV6OB!}ZmErP!O3;%EFHHCu`fkVOoJFe zN%bRjEP;F5nwb&mGQwr#t!|Yj{{zS@6F7@^S-S_1BENtE`<~^HM_R`1It$a*{iz%PRPdj zWF;e3fDnVvO8DI*RA^SJu+sy1RcV)UBiDHD*Ya=e^~MHfN`@YYkJ`2(d)bdKSnY4U zJ$9w#TSfR~k0)%tmnS%rsSG0z^-96tAgjS6`RxZYGsgfmEnm)2x4s!~jQ9shRGE}U zd97r~YvaOw@qG9@^vBxTC$v=O54j*(A)_;SEPUM{2uY>NY`H?k9{_Q?utWMs9+LNR zsV(3mdA0qd^KPF{EiC#J<9#vWmnSr<46CoD#4wA;-sWYj+^}S@0bN*bWT1*nl`R;i za93o#pZD#gCgj(a+&nnb1#|G?#{P*{vC@NBJ%tBM^(KO#ym9{ZRmiMsj#W8KGsiN8 z%<@_QutrUKC)NIH%x>;xl@Xc6VkKEu48r~KE~^~6seKV zSN-Nl6RQE5-Sx*5(y{ITC?OC@*-zqW3+%5bgD*lvXk+}WY=;!OibJLOqO~Whd)3*r z(B!QBdoy9^)|sola2qQ_5~AE7;!ixNihRl{v5J>i8538W(q0;K4l^KjH+_ZLU$whO zsytAfo&f>P05iv4@RgCEfVq^Br@rHqp(&&O6cZv*Jz4OV?GS_kzq?xb+ zYl)UWk{EtugD%lkoa-U?&2XhDVR|vcQ4ute&{{R#$=M(S$Rp52x~q}B>n)*Mjl-r=s~t#jY}ws4ew_`wyl4w7%}m2aMCi_vQ<)AgaCbVxZ*`x`42QZ*m}({5v)Rn z*FZ>J+Q(H1otyRatcFVcYZtMM+t4M;665j)a&87#tqBh1VlM!=-9{Ppdu}h?v1U2w zco{Ifw_9#%uI^NmbpVbxYMJ2tnk&(Zgq~5HRV@}jj0|UqE;O?D({n(ORcUp0nW(DI z?}3b%L|9NW@P-|Q$gF;5P=7|V=2I%+3{)c!sZ^5na;8C_*3sDZD`qcj5o2T{Qg`8M zMGP+7&RrzU*kSt%?o{g~Do!Q2LmN*;>`5e48lW9GqfLPg`V8t>Z!ET zUAu$`ZsqTq5L365?A$z5^y}+nqtUUFITea;AN(%EcenIvaK9<5q@)Gyb(+%W@#9OM zJ@l8s>+YAPU3YzIan1J&Vg&?ft1XpgdiVkyil%EFN>tj#GzY6(1u#A!BIn~3Z;NLD z^~eFz;!~weC=3Ln9pz>obSY$y>OFH8!Kc#jd%cK6tmMjfd2;L|XSXC5Bn!x!R z{8B9=6Hu22UFQ#m&`*{6(Hl2nnJM_)6r$xu-AJfQFc^^H?x!4pGMxbjjt2j+c%HRH zU0GEam=SIeDGePcf&mIlc-NvNV(5sG1d7DDR9(>oGoif{`n?u=M48-00vXK01K0Bx zr3~KfU`S#J?a*Q+Z>+9~sQ(1nvzFThD&2rLh@8A>;xa z)1W>Pp^0FERD#D({B?&#tk}KxNfs{+zP6mr0a7UBzwGk@&2}G#P)$~FvRv8G^3t9z zJ-bTz%^n_`$J&1-0N3B0-;;fxzJKpP%|5q9`iAvzdq#0-9z%LLZ-63M_>bXhXv}MQ zVWHo{y=5(uku(A8-a5qYr-oIJXj%CKfOPSio}KL+KM2Vn_PNYyzC=xDzq_x6RHSU7 ztx2UC6x_Yob<$G8pSzyrGVE}6ez=Efd|m}KR2UhFkbqN-dYXLI{M=fdg2z?;-*v0x zcJJ-2ZbjNB2P9$-#*}vFyPhXKbFWEKp5UQiYH?Sko_@7Khf)Lxm91)@ryV~VgU4Rx z6sc9$U=qLpv}EfxBCQ`0B3-}}9s@xJJ|b44`}p@_YRdvg*UeJ3$#830@~iV=xyi{d zfus5eCBd|11Kw)Oa@20I!kyOgFugV<=O3V(p+5m^tx~~jF`+IcW!rh1WLHzs;Css{ z7WQ=HjN7eViZ55o=kw+kQl;~-=Ex*hhlyp@HeU71PFu=0ap@v{FjL+U4tN8!eHg%t9?X z^ZfqDS_QB!%wz?*v(JE_6VAT2_G(?CkSuL;^j+_A-R|8c9Ij5Zm@s8Nh~gZ(%fh24 zr`Yh1JI@?c%4?f)8y|MI|9p{fNSt?64kXkAMT*EArQ#zD*MdT;C^U#aB!2|aubv15 zS&|KIzCkU^w8_Y9Lv(E$e@ArqmG;Z~7`hIXh&TW{*6RAp zOYyOSDqfTp#J?`cBn5vrhxVGkedy|^8sM@7q}JlDuB8V;!4XIDC89h5IQ!I?{^=jd zUp%I=NeT0O342-NLGXdWl)nii-Eg>L10?f6EaAX8W0!{!7zn`9Q>>yPVK{!w& znB2su*anP2abc+O;^>e?iA>rwP@z-+Y}7M?a6^cN297Q}R{(t;?Cy?&zhn0ggN{)C zp@CS14fubRYB02W*I#lyP_%sOkXDR+;TIGfn}1^$E9^|=6fd7Q?isT%+4VASgY7D( zdQK-HBfBwERsAk?>q2F_;oEs6WIof>bZd~|C7BBW=dB~-7=&R^EuVc0&(Z*6RH4s_ShM1~) z&86nei_#!?Fyi{uovc=B)obw^_VvR|D9XxOR^HowU)>>lursLHGHmO0SU)|8bOa2c zj-s#6IT*e?73{+Jub*n#{kgffvfH#JuEoN9J*58BQg;2-Za%?OFPZ5vY~8Z`B6UOG z05)G2s@$N$AzV&j@IOv?#qZ%Sj@9A&&E?0B%cc%R-$6Im9-#|uP6lpf+dlBmIQ}Cn z?6r!AqwFK@bQ5pD7k3}`lFjT#!AE@bzeZ3~pZ>v-I&z^~mpx~((t_QmF>lXs-PMl9 z^s%*RUx6C9ju2EjX6{#V{@9H$gNlnngr?gZstvN6p|QUEL|5`)qqDqP)vr#2ZBfZj zHtV=q|2p?M`JT=ND=rRUJ@dbt2?-dz?loBTI+I_uKX>8c$B}WJ+fCoU&9;1*b*vqP zeeqCqa`?f`PSTR6HtlJ#;@UI1_%R)@TM!+oa6IjCt6&?@y$*$CE|^A`HnVGIzx`+b z6}bpaNo4ign=O`7r@!Hz{2$&1y~&LXPwNV{7ULeQ$$x$S3ffWeVtoj^An@lP-q=U{ z4CbL9ka%xAn_TE`vq%Gs7IPiNndH^5v(N7OQKX)sx7Pe%5(TJ1nCM zv5MygOYAA}wCq^+UO9;?MfNDWu<%nSM_U``xY!YTLBqsF|0c5R$a7av;Zn1x>BvQLBoIt5R6lNF5b%=K>SG-%9QZ8K? zGPb;YHd(H6e~mLl8iZq}%;+|*3<(QuS!IOq3u`-GI071uO62<WyV*=R!KfL#sKJlbV|swwKJCdr*k|RqH6c8@bon zluqDE!(``WQ(Vez59<5FTv?eRnwQaEDT^6LD}>bMJoWzsRXH=wC@vag$YQ3{2!oWA z2EIaHuiZ$#BFx|$uVd0i|9L-p%k(`rj|#z1KWK-c2BG>-uiAI9#r<2zk^Cm>MUIfJBeGc_JbV z{W8+m>eP&gQa`f%I%@rPSL*BkE4YtuWr7D5Cf5PIL($yI=|AC$Od+i{tMeJWDZx(z z@7Ua1BfI*Kn`rN~Zo4aH|NoMwv!CpVFsdcoHQcB&8FD!X0D__mpOxld?o$HHi&mju(5 zEF<#iNo}gBJHYgZuiXE%08!zW(>KG_ae_S8uFma5ViwN5kAvn4(kHVI)2?=}10C)r zNv6zQ+4N{F-%YC8BNP;9p+3oz07DnI;ib=X zrJ<1!oMah+W?=={I;PjI1zxJ=n}%qa*TN~<^TZkHk=?(^h%fMnpWWe{2O*X~Mg;z= zi?7yDk#Id0Wb$aCK6!}WyEyD2UhFv@5Jz4sfQoqpp~OX2{SHe7Tmfa#(U>zeNpi^P zBDH@&o=8ild}|G-yU5Mf(??0^|0jF>9~>z0GZNf<4XeUM0L;#tjpa&^x{1k}KCui+ zPbNf8)xna=og+<2jYN88PJir~bnp@VfyIscRjAu%)hhCeJw(Kybq97H^hESOYjgH2 zDQ3#DugF`l$zsP^P|8M4>;4$O)L*)#`Pci54U{ID9O68in_=9o>ZVGyk2HuqrJhYp z;-rH;PrBtOtpnlfWg(P;aA^t{fB}bYNr@^382r$n$lr{;FqvV!%>L+*QRKqi)!7Nq z47{Z!5o(0Noa{-?2WbR|iV0D@1R!YaMCmFKe=$s>Bxr333{9EfAldlzNNQw?cxuGo z^AM%Ny16 zmg^$a>oyitKNOLuK)T0j(8c;BCEhB-Y2`Z?r~MRrjv+2Q=lOAz2do^)Gxx>;Wn#^p zU^!u8`c6Y!{uZo|dL{x6DI!C?Ukgb_I;f_k9$$;RJfE{5pj)aKVf+v2XlN;^41KZP z?-a*6;BE;rUo0&y!`AL578J9SK*#6bzxlJst;@@kY$EQ`{Zgo0BBelYl9LkFQrvl_=qBx_+ z;+^m=(@HC2H*awOp8g2%lVRT&w)rwF;%AMDlKQ`ADaA+-Y73E!Y@=dIDl@uzwseDbr_ZRT=AkhGNV#Wi%q{n+Q^RUj7l1Ob# zeB3+Hi#h_G^X=a=zkrncPw`LeN5wLnQ+@sNIf^cd?+dsoxMSGC4s;aW^KUvg{PlJC zakS$LiK>W|^w`nM!<7>MYtgPt!0 zygKLS2M*l2{H)mhy+L-6Q*O#xLtZgNJ6PqUj-M9b!n|O2rba!9kMo4h8gLfEPs@LJ zcWiClwZBR$=yZ`vsGy$*+!!w9AeV(|buwm?a6?jf+dwAwq!f!D;axwh`_6*~qgh|a zU~}aySBvY^Xk^<^;_;i~t_7K#pK3H4`_L1;j+M>Sd$U2Lv!Uce%$qw1{$>6Q_JP5{ zy&-fr)7ysz6m-b0K^3~p*6{7hs0uOqL?(O|!P@2idCFmZVQ`RxiKspnmgA&9kR4_C+G!r$|bF%A@ zfkdOu=T4Wtd?p))0!YANpfnv3!@0*9>EVmmunhEy$NdAyWzZv_NhyiNA(d#jsSzOa z(TlBR>1DBV>E!;Qhx*Gp@@t@C1d3x^oQBDk;0XX%{-A%0F~! zolbpBnko=O$+^F{@xFw%I|R1>U(6~@pjuNWbg{2AZbqv+R$K546glQ{!o+HvRFpmn zHw*c8ZLW({sBE;hs}$lYH~Gl8buA(<21!R@I4&c<#=*z4Y&I|UZj8}M{Js@UVeD{K zaniF7n8h29nJV2!oMk>*3`MAG?I_WAgojt1M?`w&Q>9SVyh+7Ovk(b#Fy*x1;%ZL_g$J85h+wz;u3w)5@#yRPr=-RItYH22JzGw1Zg z@4d~xJo;e@iSuARW88f1XS;c0171FXW`|36aWhe*-_NP;7`q;c&meH@&o52`D_^nK z5kQ)1n*g=1F1XM|)Zt_h5P^3I!6>9jGs42BHmpv*eiO*-aRd?ukB>VpdQ3l^4zpOz z*0^(zJOpB&xENU+ZYKr@Zz!UY*I|(ToCZZ=n`tlkAhThSs<#@fS|Z^vW3jJd`!_pU zrX1VGg4k4fQ1ITCu3)K}7%y2s3w{bsDP5jDaziH%!~X7q{F{vo0w3~SbY-$%e*XN4 z;HT4YyjoqEg1cmw(z}=gf`Mn?N^4Kl!)5Ze8hZPzVmz`Hg}f{=GrdSlkDIBbr~9xO zP1vmLc{hDIF%ma6{|%*tNuB#JJbkF*VR?BpT*d!_v+#`Yt@DvYuJ?? zPbJa3KYvq`FDX6AkB?X5pZ-_9?qGj};`{D9+tLX1c)v7R4YT?#C3Rgg;Kk@6wyOu5 zY$k%7(b8^q{Eiw;ZD-N3vgR^co;^}qZt;s`zSbye0xM-hINxsaC z-zUF+1_hbVS3c4eQt|5^I_jj7*DEiNp!mRcA3O8Vi3MZzQ+8e;8>u;BkdL=9m{saR zer)|XnR0x@Kl58|)mnE20Sp`+)8-6nBNdJ=G-^&vY+LKrMP8dg^LE~0zL1|@+FeY- z+KHyY6wangv3>i5GLK*Pbw6B?4o-#CyL319d@fpBj{MfwHV*BXcl&_sj!l<$_}HAW zEs)CoKD}IHK!X`o^JE}Se8&%xxocI$t98aFVtA3fLwI3Mn!%|Cg+~&Y=!dNCB8<}c zXmZ9_G`pe0pN|~OLjH=w5%wVUImn;E7=Kk2tpx#&yTHo)I5d>Y_U%Cdt*a;_9gJ)<+MGApvlW&G6PGz>8_i~)YUSo#N;F!e2TZJ(7~PDqolvrxEnfP^@0ej~gIr({ zy|Rc{m(vxyD>hnF!c1vW)d?Aiv`3HILlc~Y)jW@Judq!)3wP0dQ?$tb|Gs)W<2C~< z!@K+>qmZzmkB!ak%rh7;qocR}`MO^pM7o2%RX0)zj1`94&1^NcU1|%$US!JqcC|MV z9BgOCW}|63TG;)3)rI25F{V*6nc6fcmwoYONa~1CBIhN=8CmJLMUs z`+a{P{ngEu*QxsUuX=T`xEc#btuA-ajo`HO_x$=e$5EN(yGt{QkK&0RW-(=Dt?Mu- z9yJ#0G1xy#WzV?dL|+@YGZS%DJV>GBf&4|!E8RrE;N5%DaX55{4_Z=66MB*HhTWSa zP&=V89L%O$PbFa5_fp|w3L2MOxA!fHBIQ!1K>G%b?Q-t?IUbYb+@vYB$Ej^{M}J`; z_R(&(dYJWKYh?&+P_l0$9o|ppx!h_kIiF)WETbldNRQC-bFlru#+^pqnUF8?yp0y* zdcn}fY`^T!Nczs(Q_`wd?U69J=3Y+4QkS z6P6;QYVkCb%E+PhE~IvsZ$_l`9k|+?F4mlO{XlD-uHGUr8~piR9!Ef081{hlUb|jE zBJmd3`d72W+grjRN50>E_FHI91Ql%;6~Jvs`7<8Pmgu~9b7FfzKN;qA+Fn`{XYuhL zM)pC8#tpnRJEFtsR@6Kx*x-UQLz+&p%;@zEZp2=>_=r#CTuhd&vSxFpcKR*k2XUOH3 zI5f|QnC67>4^P)$&sd;jO$?E#2xHNi-Q12Yc|SQr3c?V_h8kj1;~03VR4SBNtSBfT z1u#;CLa64Wm8+vG<)zcJ(T){oqw7mVkoL{U)Y^(Vo%Me4@YRBw8n4FM%vbZm2tlJ3CO!BKR@y_nI)-55)unif3&nQ3_% z{pvDc+8CVdRWLrD_kGY^2k8VWJDcP9( zy^3lsGvni!UF1sTOjvU2Ynq94i9cq@9k5w;nC#$4@!TJu)YUp%69Xcp(x{7)-0(uX zIR$*j*ix-5+hmjsjf@Cfh$GWjn-7s<6SD5`9LX!8zLqa zAqNTDwNT>sdGk|A4_PFnq9i35;)NphV5e*4TNjB#s<73tj|Gm1(5qgE^?)X*rv*RBi zttChS3qx#USTN;skU3E6msm*H&9DP`n48`FUB2T5ac{Lmx2)vu(N8k_%I0I$?*Fm@ z3cf%^R6&82#qRl{NXuKYJ5_xzON`u0JP#9z+xr65Aeih|%1!=!)AuI?C-d_8y!hhR zxLH)STAhvpOa+LBFxtVTpEIv58*?l7{dM3hE2>;E2O;PHHEL1nmF4mJq(Vi`>>x>f z%e3k0wF73@&1!WYK;7ZRBH_$}#8FCh?O};wl6+hmT4|J;8YY{DXIB65h|k=PL`*za zqSgbCO)VW6EO!u>`h97!c|iK}-0Bv5IoH=8PTgvUcFO)hC7lQ81#kc($Z_SE6S#J`u@I!0v{H04!`8gm z5CO@G%Lp%j0W3z0&}i6}SLyRs_(L58!`|zE{W&45dG6Ucd+VE{mHRK|Z#CQY%jl){ zw<#ysEi&h@Y}!e=^!10~xV26yUacilv&uEXE=qg=C!C#E#vwn7y_r_X$cy-BBr;`b z+bBkdYgXR%g)-L$t`d;2jS^o65I%CP;L?#AxR3X{7u2E4mP*mynRW!wLiv`la~*CO zYKn$qJ4}T|SOJ|0pqxGuyo5f#J%JO!KsOxNsoTD{%A&v1pB2K#000!KX;n+HWtYov zF{D!N3fJ@USurxz0?Ae?4+_dLqOhJqB;QW^DO#~*64WIk)bP!Zn#5%!AcIMN!In$T zP&D-ygu942Ts^@fybG*tt@-bZoa}pbl`OmX-^GMGkUL~g2ISKQATTOISL)ZRT3zOic!B5Sz(VEY>wH>-ekuhUS_2$9 z;#?Au)K-4qej8Oo!>oM^eAV*p-;{c{iHV>-GAuAh7rw(+CtY(cx~V}Nb-cT?GmqW^ zrPeJexHgd56N^R4g6T62Htn(n^(-LdsPMh?|7S7$e@ z`aCKX=o&Wk+jgzR^le*Vk~}B)?B+|YV8Io5oUFX z0qgB|rRQG&&b!}fC>w#<-A)%kATgXVl#`6bgTDXE^_~10pY$G!e zhxf!=m|nWT$~VpWm>)_~ho84yn?Ua?SHG5ZpT9*n#a=muyb?4^P>O8IQqQM517TZX zZ6+7-yl(;GB%SZqrJpBAsHhpv8qbqwOu*MY#A&r_-2=Q&fYUbPGjkdr}W1?%@L0nfDU zfLKfW`>5cXI$g~#1<$AU8t|YUYKiZ2OHU`3H36NMOw-vo;?(?d$x&-CRSUEtoAh^G zSB_{ezq5_{WuKlOe?fN>B1~N$mRAV-a-S#xKS80$eNW9&jcpFm*-S79FMWzoA z&fC0mvmzTP$)BhNy*Ml&q#`Hg{inUJgh6fE@-p>~>v=nRd~aiVmlfe7#pBoSxVgk1 zhh2{_W+vGi0HsxK$+GL&KGBP^=RuA4GsFUOj=&S)n`SGq%M!)dM>*i6MtB!F&nm2n`eh}-fZ|19qxi!f8w`J#8<@kbVBpar+>5wAR< zdx1**1N!W&8_GAq>uj(N5TLsAV44;|%l8BQ^+NAyKKorEDM7CqQO)Mz9Vlqllk2^G z+?d4NLObb{x39EV;=~tT0IhVzDNbAqY)=9$N-6ASv~RUPrsERZY!<489C6cF8Rv{_ zzthN9uhu`LQfx0QjwK&@#)%h+AfEE;e24Z!L^RNRPj{DM)TRF@T{>JXmA`%*m49!y zxsR-eY6(?=7nqy>g?1??L%fZw&tpGub`#)MHQs15wH4%xaYh2&w&UtcpbMKRU-}6P zyLxCd+15>bvu@5tOcF%7Ib4J7A@Q|hS!&*7(maDR$VavU-K*rw=dOE2^V(2}t_wGY z+J~$45ac8#xx$pi6YNrN`x(|8*$8};{tz8``ujM&5{ivK3@T}cp35l_)<5;b+qTPJ z4Jm`y(S`%>j0#$hQm<03ZSmxv%g!B05rt7K8k|U%@M~H}NDzL)6G6UAM{2n_v;WBO~mD z5faVltp^v~d+R&?vxaU17$5I=-}ms|_wspyc-h?{xr&P$q&&o=-0>Yv=L00%- zpRGD&-=>-Jz}G)85axQ!dUe6U@Adm~6J{#~TMoJpbC6?0*B(HlDg+wX3}zJff`J zUBOrkF@on=AbHnUOPGJQ12UA7y1v4+O8O`UcS2lrQ9SHfy zGvp5sl*l`naBSgDOcIhF76D(!R07^Y>De0j+$Y-s@ookDIfA_TUIRBu{)fAF%4BIl zCo1+8FB*wCg70Geydho>))}*%9u|o}&GtWd_qui9)5&oM*RWnCuQQ5j$dq!^6B~+= zkFv}~oZ8Mg%kg%-uHgOH4o2EDh=yU&=II#t*yW`?Gi~Ns;uN*%H3hz4;I;E2e|Ial z@-jR-E&u)KdpIyusn+Q*c~mqasYL>Rs@Sovo=C&x`eHpZEQ7z;vQtNFvsIABt#it# z>t?)%_<##_f*df|&asl1HJC`}mBd()ZvmDvR!h=Wb2#RG$Y}*bU!BO5KQ^5DGW3TT z|2rG}Q8s-uM~tA_Tejb?Tkj>&?#FJ}a-KoY6R}xO?#oNy8y)h!=nH~dX*Jw~2WsdY zin?rJk+Ej*W|xy{zg}1p_<_dcaY^U9%6a`Xld$t&;(v8qz!;D1flih7P;cRA-q~E= zL?p~K2<#&t)hdjXSZUp z?k|$N&ussgU^kZ3siQuA^t3PHgsKt$_4QThpFQyY?$gi4##iy9S`c#s-w|aS@dg*^ z1o_bIR8;2u^0oErNwOQxA_!!z+vH|kP3k?@-on6Y;{^z2N<33kk|a+vBwtv3bvX6bZ)r9m_Lv`w`UnK87yfdCR4d?px%a zgwynN&Y_&FyomhMQe5ekouFwrEU~cw$E@2j+;wALK&~D7bEUe@`Gos{qk5{{_WCIl z%ig^xao`%)m&rW8&EC%rFKVrJ6cynORXDikhtrhZlg&RL@p_bl%K!0fU%Vw5K7S7-qUUlgNXgt zCd@=!OVTpk87?82wkWn&rcjWD(qDxF1)~HOWmv4)7EeftAE@3jz{~g*&CKgCo3Bof z&|mXin9wET{#Z>hg0VI<2cvmXO5*A5_Ha^~Xzae{fu##icI_|jrZ^>XWVMEqw#lQY zkQ?b>3OLT?`X$7nS+5v&Q4!gC8C*TVTG3jHjwh=jc}BOB^VJ)r4*PQ?&qJ>2!kOs2 zzbFgDMtME751?BO54oJNK1@Y4fjF!F9#ONACG4Pn*#2&OXyI4a@M(oR$5Q8|BQ=;Z zgNOg6wP1L z_d>_AxbdrMK;ihavi(s^Bqm5$sUP17zEDcZ@DKGx#kF zwR09TGn_1mxBz;_eS#-O^~tx6T%V6=8_x$Cm%!DErqkcf$BUoUJT9jjNDcO~$fUk$ z>C9ly8w|ZzrXdG|>h^oz(${bn6YLuuOE^+=AhwRcqjyx*0V8xf=N&+@#v^UoN!RA-a5l&99p(By99GDlzei zhCRZxnEN4x3hY`O?PYJBd}>mRqv$!fR7DBKcs^pDO5hJNjGMW_r9aIn;(?PgX%F)g zrt{jAgr}WN9^TQbLMVUUbnDy&@K`^!`5=0QH-)WJA#x7xW1!Nkh>a zbE!R{C&4xj)O{d6Cc0MFL?S2!!^K~tS1NA-C5RE1!wVEH`prR=u+1!7J#8FpIG*ok zL^~+D@6LsL@EbKPsMZO3A8!^!_}Jq9xy5Y7*jLk4<&u_T-#KTL-+G;||%3Axgq zrc59{fR_HvHWncy6iCWq$%PhzFJ|L(Y5^ZBzQ933#l@tv=Jw}E84eAYzi8$29hpW54HH{TB|MSZ3oe84ngAxlz|sbn zGIrw5(io@x8pN||OOlZU2hWiS9R{ErH0-lftSh6HxH{#@$3a}QMlrOJQ;DK6z%XsX zU|hT<-Z~5qG&qg@4jI9~0MUQ0S|CEG5@C;li7xEini#GCi;{`m0T?oE)JKO1pcu3r zum!}=^}-MnsdSUZk|NzGV>q)Mhwg!(++KcO+p{?|3TN6vu?jBT`ykP zW-1z9g|~S$45q6F2S+d2t=$;{dvS8(xLgJyQCngnk=IDidr&ySf_6~(=E^iWVrn5M zPmfYCq3mnXP6M8vXp{*!ygUC6${LT`b^+UMX6k;*ntOun5h|h^jesA1aIw)g+N(Z& zY-&_Ab-W{;PzFR^cV3O_b&APi|FB2}NM~0)dS}ckRLT`AL_NO=OGx|-rnWfiU%NX~ zD~D1=2Nwxv*|5kyeC?k1!DAPQ%ushaoE1lcFY!N!?SO9Ebs&C$8p+1??3eq>>y`{wSGLI3pW7jI#!dN`coXo&N3Ij+9oNB@Vt?@j5yPN9u zx~MH9q*4=|)H{ zR4~+!anpagHd(z}Oa^OugSAsRPlOPgUx$=WxjLC@N*~o$`Mh<|PlRwh(|tjD z93G4%F_Yg?K*jA|MAaRHyXu0l&|j668B;nu!a?Rw3xc zNINhr?N3q4W)GO>AaX>|%i4dvi}ZR1|qX^I4L+ z$p*;Cd+O`9pXi@E5KO%8vi*pCrG{fY%7D&Ko#F-!|8(C};h~Gr@obLx6W%!wZW@KI zDbR0Uzr-mGTQqKSQs~yo83d5XvR=XZwv(d6A+QUE_#y}Q+A7*>Vj&d&Zqk5j(u|jQ z3ymp}tfJ-uU}qNOfkIF2tF>f*Sdz;26Wj)Tnfg&ZSb;`#_&7XuOi7fi);RmBq3$A%b) zJ8lm!MAt_@4HhAbDc^eU<{*>29W2&!_8{W$A(> z_7@;~jX}pnR}?aAEk!VbyJB!i@q~m7p+l2!wbz}8$&*N|bDPG$`stO9J9afzhx&&MB+XxEzub1Q5NWpW;`f$ z_qO|FJCF(ZS1+8m&>Utww(H{E-alevHzkNnpi0pU9rMvTOk1_xM#dqJdY4>g(%dSR zJ19$53WNMBG>_TLSLS^ZFRJQ_07Jbr!D&^R)g7i3R9i039!nJfx+3YGKEF!UmJ64T zUkIZ4<8g|y$epj5+YPG*0c4% z?UvS1HWBE41U^zW;8uEsUpChdi>Vuv>kp5%wsYZxle z7d9D@yf7OaRbny=ItLp~`U(_17gS)8x=MOf=~zkS7qj6 zGTudi!W0|b631ow$Y3u3Vu$kZ)zhMJb%jc`uU$)iVd!UV&7=r98CZ3zkO9Bh{GB$r z2QA}gKrGc z*RWxEZOtW07vqJPeP?e04VL^Oj@qF%^B>P{?W=r6RNa_|aT`is2i-;tetg8^zMb5` zCFXyy)<15>CiI;dr#o3yI|C*fEoqV4q0WA6 zeo;rH0E7~j{2SC+xH47*J#nAuI(gqRHj32fIFOc`>jnoo&8BXtHWfUp%tFssEA^Qw zqF3|=^wz+si0-Ojvw@>XPVD?@h;g=)6Hf;k`FCkDXmzZRI{&a1fPVpkN(XWjbFOuO zkkl0j!_J>s4I8=~t}`PP6S}e{&&bm~(~(A$n-X%u$$y^%-ZBF1(3M8^+;*}y@$y=E z`??Usqi8^yH8#~}(3G%utxs(_C#(EZJL~ZyWsZ3rj>{(#=MQ4fZ7Lv5cPrH3dr_|~ zV7AycCl7+UM7+(Ag|$FRwm`x@Sl!{(#c@LbNz{JnGQamK@#ubUo((Jd_9(<4CVP2C zk~dpC-!#sbBbT}IKv=M75FP(#cg(m8s|=cBAP44Dhv=A5a0C+F3=W@5F`2eNz9y(C+Hj z-0*<=qsVft7M;g<$zL>U8V!Sw}^dk){3?|H(&2~^rXlZo|)O%|o^pZ{c&Kl5In?@G9+x(g4x`JKpd zF4}@#2)l*UP$Yy+<6dh?PlD4}t07#<*mLPM+y$_OG1B%RU3t^O{zJXZu&uXDdv}fV zW6Yl=8+t3^nQ=am@%1Z+Ktthz4LYL>j(Ec-ngqC{=QGU7!y|_IO#+kSf`rKwR>aUbwX{!LD=Uu7Lj68s%F9BZURnPK8;8*6s8qqM;OJ9B~B|b?Yj^=Nv^~@}T+|ZN*|0P^&B*sslW#tcH#7?#m}2m|?KJh{W7$$kMfm z4d9mdMU48+-{H?+>a^#qKE687q9^KuToEv0N!EM%>UwMxlw zelIUgjknmYb&0Fx3UXlm*7cXlPEdKSx-m$GQCJ~Wma z7^QcF+0J^_)tc3G9ZX*-=n%S4i83BsEl|b;d@RFi^t@QI{VoVkyxdaNm&*%JV3n6^ z_yLA}k^X4q!r|SRN=jR;?oP=Siv-C@d~*0O&qq@_jYvY)lWR>@95$M()3=OypHE3i z(sP^Qzke?>NT$xuxHwLkrmP74PF|ti$>!~v_+dgUwhn>qjOA8p8LbY12 zyd()2!zAj#3ZwXw6UXz6DoTJ-Lgm-)__6Fo>(~W|%TzY7!Tu#R8gmf!ZR00OCVT50 zPrL!?pVP&Bji7e+8qQTq4RRd>TlutMY(<0nOv;UAr@<8}QiJ5`63vg}4L=E$NiBSt zFSNXF{}iFz+74MxZiw#j+1tSQ&FtidUn_C;3o3lAF6V_n>(7Gngt&n8D@SihXhAL2 z`^i`y)amYF!JsU5_VUK^FUufXZ+4`+CfgX(r&&s4!uy-~P~n(1rV+dS-#py7=YxB7 z2_&`{y8<1N%Ld(gC_sy&1^C-V616E^Acq@uvmePXF->%6o+;#$g>Q8^8Cy+UcdQff z3^T}x1=oqK@4lYu%_$WhoYvFz+cW%ZJnm4yaWA$P(ZWfs<+IDFcFu{8DO}&=raH#B%iwhBy~h z1Ru+tFPK_2$)7?hWj(q^`mH@+vLFzxl^waX#4s`PB$>#*mGNdu%s(IQzwm+WIpX3q z`uKEZ$s@1{hjy}kZOKK%amGOhZA;=>8RDIbn+Xt=P^KL;1h7CrH5f>+<;DO@^G{&J z6bG;*bHi`NK$EBPA8+Z~{yvoO=QcS?=H^jGT*m*9!}Km?0QxSW0n9Pc-9AA-ZqGiRF> zF_kHJL?~SHWOOw9a=i(pY5X<|c1!GOH$Lo=Xk?}Yx4;H{dCo|Ts5lb<8~aZ{BKA_2KLsM-OB0TzKM?)^@Bo35|jj7 z#u;Lkz<)$bajnp-`(rL@-B+XS)bh1Bspwpe#^Fq^q}0Ub&0v(oe|tk?9CZ~Ur=60j z0DaK19uw~(z3^4h<3-w!pBF0s*TI=zZ^dv1?o2u{Nw zGpW3$p&4fcK9BdW%9F^fdTeWApRLy?-*t7&HdX#$zQMx5vr6@TU2Ddsn;XxYHVJSN zW~N-;Gv_9~j}^pH`~HK~X?(Qs#N=P-fobw)|E2ZISA11O-L~ISk~ab5r6?xGI=7lB zkVs$k@Nn=u4sTS~W80pnW*w(;wh~iyI5@m%DBD&|j+7Id&6XoD!%)xY8WCzy!M$W9 zbLxm15Bhegbf<4&C`5~ICW%55%If~pdo+pdZ@NsSbEqU=Y12-+`o+r?`lWvY&oknF zdVH9?HkVfE-S$O#G}0MQDyQWRzxjP+|M?q)J-gv?w$>Umqx|}9vrBenIE&9KCOt~c zhR6MGf5Y)ilbQPWPaPrQUBbvonbc;wgWF`p!wber4_)RmBuJRvb`soN-gsYonC+TB z574dgGA-^7loJNc)Q17Q4R+JGl{izIfHXA+6=4&d*n2_7Dc<-T0YvJ|kk$JE*v_zT z`Pa}x+NtB$ELv|?WQ2t<$Aajam(*K-6gs0Sj7BjAdwghONelyu)^NG%CM?x%-r`qN zw-UTgm&B$UQ|ykDu<{U+_J|kG4`0Yi27H5Q;TKs)RQEhM$s_!5odZUo6o`V2s|}4u zsECoYGz{;rQ-b&md~#treo~v;By5h`@ee-&8sM6QT25i6Tb=*?`xdORoi!vwkka;@ zczVZv0S<`m657N+kRt%7!Ar&8F&G5lW-;855uQm^!Ef_A2EwCB1UhptcvMWE-=7L( zZwRCIf6+3oIk>K~+|jlr;L8#)x-@-{l@7dd?N9{2 zkbs&jLATL#qmyMMor*6{0goz+vlI+AYs1W(>U2SVw>QP|zMOl73k7aN(fR`o#cvJv z#3qW%c7pWWO?#<;>95J(B6eZ7Zr9F{{}mT?^15CCh5_phZ^J)&GOrz^G_qbx4g?z< zKM2QmvzrZ`=O)fUz8=KXe!p6zcf`kHZ3Oi8D*t3RyN>pkc4t0II%@n`J;WBQcl@>b zXSD=-e9HFCWYtM%D7Zo!9{Fj-@}6D5+x?}ZQdO3L8>Zd;NtNmS0<|=z2-oWz^=v~f zXb@+RQ<}oYO{#vn`tb13hyAIGwFSdh0H4@by;EGq(`inqa-rr0~t;W8;!lJ}V87kF3{gh^!5Nn>M$v zRbyhZlHG2wnK^Fi7Z1R>y-3)0>Cku@h5aRpokICw19WVxn#482*pgS08Xf|6dwVYu zo&L>b%M@0X@4Jxas{*R0`ek>q3E5d9Mr%%e5sVBOxK1r;t$%UJI1?CRz&-IlYDP2m z@k0#5Pto(`iy96sDA#WjBIhN@5JQs<&Z8rx7IsvMEs8Jv(vP3uR#HM%gvbJ~ebCx0Cu(1O^hZ9LJ}^7#{qF z4rE(9Dx}44A&jQFDIiSwaeKr4I8ginUmn4}8gJ)U0AgdE)BDQhdX`4ewe9-#i4Q-0 z^?ComgL>pP->O6<46S6Ud8i-{Oqp%kEXcWRW!f&Owt^9u6avURqr{dNs8y?DLqq?H z84i+9G;gP&H$-&*6?RG+iH6J9RZN4abl3WdEt$_o&4z^FOccvD6Ne{UP)3_kV$`S} zUaLVAI~}xHQGkH{y<}3;c~eLcvd~)JGs?)*Sw#PeX-+9YDdQDMvMgW!abO3t^xB=x zk-wX)3AYLdS`-@&(05Unu~+C11P$*!>^xdzxt*en)m%X{U}P?p-t7g#25uUv4Rg<&TnP?c2G2o2mzT5+j_c78)5g>M z9QV2^ZVw(KqB{bjdXqk*PFPIdV;Zl<=YZROHk}_Jia(PRpYF)#Ugt0Zb4W4*D=e=z zF?h~XmVqPKoJWB2U=%#FNj-_EO}yIk7){wIpy76E{yZ_i16i4&ihZlph08O;retDc`LkzH%KoFp*a zUz+&z1dZ8&t>Z2`l0^7ZJzzTKB^5`k1`Zh{*L{lLy*6W`QhlEPS=njV?-|0O-?=9} z=wb+0q0N|jTb>rZw%E|kqFtZ&d|Z##O80b;(MvD0|749(tn?M3SEY-u2XH&RtzZv> z^GVs)=k>OpQoO<%`biIAi`?{N2+e3|$+pYxY+m_Pm8VxGf%lu`p{VX|Z}6xte)^9X z^(?Lck@^gwkRj$U4TJq=RM#`e#`%Vi<%7#Lc!o!Jj z7MFK8$~(->dMpqq0oXS+t2bWyaqDWg^>%56HU8u2S;(U63+FfcOe@C6wnN9CX^?Ux zg57(m(6?Liz(!CgnaP9oCYYda85}Hb|NZ$iv`XKenSHhK;`MTCVvHxl&&MQ5VGx|#Nn%z39c{}4=?#Y=~k`l2^E%gp# zgSI9Blm%YZ=b`k4xmIqgW*?m;!;4Ac=lWu%>CqvMu8Xf>8Zc*ji~J^o;w1TffEDWc z|G5C6)e!Ae6DH=3&wc2Z8l`d*+VAIYlwQrYv~DFXlP!pF$f#zEfo<4S(ixfAL;dm} z^)8=NHhv{(O?jk2J;V)3%aAK2aP2?9OGLF5K|2X8l`HGjJlpp5Z)W<^J-%sK;WG7p z!~b_G3RF-y0Ox46k*u5lRu%^1msEr-;QGbIT9|U}TjT)q)d^2X zMrZ*on2t&IOT>_Mq9{dEh=Ve30vW0^k0B5uHpW)MDK|+S5I_r6QIYqIbf$_eE43j& zB3GF$ylLj?CC!WkxhXC*zs{9AqXdA$$&7@H+ZWB)Qj#iSoMneBrL7}?@bmp@YmxWr z5-j^2$zC0hm9L7_d&!vyzz-0>Y3~Aa*Q==2iEvb)&`}U8L`hkPqrR#Gex+HKG6Q4t zGcjl+Mi#w~+bI?-h71)Iytjto0@3hu6EOawfap`L{$LgCqtTN#f0d7xm(wM(-c$>4 zaCbYkiZb(FXqOw%>QJpzeuSy)z_9AplIYSRz`V3X5d!1G8Z4J|U^Ptm{3LnZ=8ZFY zoDa}|4Xm;&%&)2pJn-swqto_np=5(Czpyr|C7$nm%F6{|wA@%mWH#$QrV#}{^bg;e zI_G*VTT;D$$8ps;@&1@YO}sk}>9hk=h7OMdx~#Pt6FB%^k~FkLawj15v6CmDE>IfYL;=&IOm0!R3e(IQdj$mmL~SrCP4*`7Dz=JW!IG%5rsat$yyB z;&Tse7DG~KdCpT@BYpdt{2W3AOyu;M_No0WxTt;3qZc}ZJD|G>}CMlrwQ`?ZH8 zHKBoPrG5Ufh+dr!lt_G!&*@PG_O>gI>AdyevsQ0T`sx-teBpd^yYXrNvZ7dX#G7a3 zd+2w!bvjw;>zQNqo2a;0*6N#ewu6J;8JwXHnkecQKPl-<-NT)6y`ImdyO)|nelWq3>#I2Gg<#XcaPjn)W#?t^o;b&`(mf#~V-0DI zQgHl>X3*(Bh_|=tJ%6haU5}He-X4~v|Iu#Q|jWW7@F8Q zqM2A;V$fk`cR61(ginVb9VH4nA4E#6EM`99qTHcY>b6hj`?ehT_8e84Q?p!T0ivp2 zXQx|hbpx5=x3t^mfZ3MyX5(Up70X4(9a?FrmDR61>$sfNxcO_bHVJgUA}iNy89VpajvsC$pI=8BOLJ4an=N zwRzy4_OdcIZwjNa_3i2JV3;50mUs!A0(yTP`o?6Z9piUM9Z-}5%KMr#69yIYieg1b z6M7K)Dr-FY61%>^qSj~$90{`SW>U(PYY28P1fGJY3rw$tJ)^s`>qe+iF69nJy7|FM z-bH@_q{u&!|d_H-l=n>_DA0@DIZ=i?5F?GaR4vD=^-9%6Q4)G)FNB$&)KH2 zXz6sqzpi(wlcmeENK(GBa6g4Qow?es^pw*z@%zv9$6lJ|Q+%ISJHTDF3QdjL7RSb^ z28U-<@WNlKI0(RroZ&^7ozr&@US!OmkBL-#Emiu$niR>;m|wsKLO$2X$D_A8o`daK z3++8_iLCJveb7e6ZvX+5k^Mx{)v2w!-fkBHg}tDgVo0>-8OIqMYZn1V|Dpg-?&~_G2 zqkn3^WB$VO0RmF4j=iPE-v@0_;EY8y%Dz)Dnw*ZYmG|H45Gv=LZEM*Xz%7x*{mFuW zYYfb*>}UE61PPe8cD2f&!d;NxYFNg>l+>AL=2jd;{sYS!X7>!blt5mS%YcFPnz~*+ zWGa{Z5VIQVJ9?EvZJ|!r(*E+uel%pz>Uj?j&1c-BQ~yop3Tnpl(O&nhy;;A;7SO8L zY}34?xpM*R4YQ>Fvodt{71St^8)&IrC+d}@x*h6= ztE$s;Ba@oF{;Y;(6KbhOltRq;4N@-eLqB`>(>Mjc#;TiTXl$GUooZNmmEz+!2_3`w zjEv>>|G07$qJ8XgUY(NV}$OcWm3XC$>FtCUz!P$F`k`&53P$;)!i*VmtZze%AN? zfbO;W+I`hNtLmsa)4nB;szM5INCb>>jhX3Z!m+z<=F55DcE%Hp6us1G+m*Dos;DQO zo>rIbb@_33NT^^|xy=WEboF@b@bs1xo$_TS9~3wbA4|&wF5>ezNbUf&SQE-Xt}H+5 zS24wi=qtb>U#X!i!vdKVketH{cbY0g))+0r?5+KDnY60lD)1LQw^KtMzOB zPCDEMbE`FjIS^C*ZdS|nb-8<>`?Vb>z$DkYBDrO}Ao8u&)-HN$J}oa2CC$tqnMNmf zm#=VUofovurx2nQ3uy0&ooV=&t9S3~8{)~gdfZZaE=Pv$oEjRKm#L~?f5N!&f{(2*rPf35Ie)zR0yfAxZ}{Nds!`h3_zlPk_tO6vt&g;m=Ism9gBD|@ch)Suoh z)T_2*B_o&^81hvSh2%k``l6B|kiW>g2M-_Vj-N&X0#uoSY{Tyc)BAUnX>=Axsl3O| zTgM;7inE;fyJUpZNS zLX9PyRH?V3i5VYnA|zkd&zE{kjtIHB061Oc7IO|N^?gnIza-^vM>txxQx&kwk#|odw$&x zfR_;wqOxk_;=ttzVc1P7l+_Y;1WPH%q6K|lW@8svIr1$`n&QeCXU4UAqk|9fu5Ektwe9N=B!0q$@S&1 z0b4?GE52ZbWh;i0fp@pPjiuEP?_XT9>TlxM;XPNBKx1uI#^}(>WeQF%uTeLrWL3iT z8>{}%c^bn$Qj83@VfY=U*(f;OTZ0X*KZV=?k>#}x;fs~okF;;9=N%Pka_HzN=b{Vm zlHAneDb}2+4zI{_CMfGn><8xm7#NhZ+`xtP1W^!8*Y$db#`lH!hTLTTLoo2R3J($+?RzV;31C|O~1P#`K(eu z3#q|w+hQzeN=tX0&YVD(jKR}(#5*v%iXsTi_Q&=+&a0=Fp~I60QJ^2iy9O-E!yMa~ zDvv)g5#G@>dx*afyi46ENf22DNi&i*VCvYxP*%FXzQQ`7? zaBvgM&KgTL8ldE?!V*Iwf_>LufRs(_ZXtu=abiS>9UUFA0yLaPRuPtB0vIaG;eK5x zS(Y~FB^-Qd0vR#kspzvZcYZqtNEM`Be3y{baAa?oh8-LeP5XZQ9pRVK(x7RUTg8A` zJaeQft_O%aER=Le=^ns?jrn&6u@6 z0vWc~L3WV_CQ&}~*c2$&@2E3s729G!gasT!aj2^c*$i4N=W2nyuS5547?Y(>j;+Eu zk`xp1+qMR2OY1Vs#gnw(uwDciYcp;?<4)1g+_&p_{XU?ixjvtoiImLdZ8g7o#8(q&*G0d z@c;PS8f$2aer}TqpWEYr2e^A|p>v6CZ+}|$0FUk+rm3@=BtIO3_o9z?_b%b`@-G8> zrOqPCJP{lp7iNy+#}N=1@kZjh7ME6d8XmgD#UZbI=B$Z?6KXF}E%~!>pH$5^>emX+ z)xCH@Z*t8w!l?mazT1q++MaiUtCQs&!E!COu3Eg*SMBNR!z{8M7JqlzVBYwI_lE@) z)u8^|rkfDeZrbUHNmx@;&$*KjhmQ1fcwFaA=9*}9##5EV(pUjgbuA+ux~d7Xud=R= zbu|7eu?*k?(r7p(wdYYzc5J-}pD+X4{WmF{*S7FkO`4iC&aweUs9nx)Iw4Cceip+&*9dwoVsvDA(E=p)X=fV`tNjZrC)1vlSQiShzBS0kTG&0NV#@kDK@+PP zlBJK*U-(7-IXNzGuiyvr1M~whw+}?%9LFy2Bq)B@Zb!=0&{uHT`DHu)E7A9NQmTC{0i#sQ-K=%i3)Vs3R}_AcFhzgF!L{e z+VZH+L7PJU^xAjUT)qv^VWzu(L5L%VJ5-dX?meDAcU8qFEYAk1o>P&N+g(pI!#V5f zO1|Ehe$oD&BAlydF3Fa%JfOT+AMNn+q%g9@y=}A|W4@whp(qwSJE-qX|4#jeqV*a| zY=mn*koumM`{g$)PthJPCaKcDjqHEhzk0;?X6BNoq!>UMmEPl_UAz1dB+lmd50O&x zs!`rRK?yQSfx98ed$g{(Hdj%lA$$OCw|qqrKlB9)9mrzoNmU zCQ_Sh7IdDBSTAMO?2t@a{gWNLPsW9fM#PQ*gl2f(bDKz} zr`Nb|jn-zzxBuDLPSIgDD4f$CIrzq!-thp`0PnB?n=JOaipbmNSzpSPT>xxhmT zj26h>4S(EwZv85>)(D=ogL%G;WS(%9&gT9eoLiyN2Qv_;r9$no>pW=kT$b%vagNUu zjV^G}iQ5~=ACX751?InscF@~n^o_TR`vE`OoKtK9Y+3VUTa3(r9jOIF*g0Hi1u7`bw<{n`b`~AedMO| zF(xLiMa=F2gsveI%s!w~8P!A`XkT=6WcZj-=pv)Y7%R6=<%7AwWd?@G9u=%P8aaz7 zI-N%}Ab1K~_BYUFVPLJij0;{vS&UR!yL}Q38eXwc8 zEY-}YIZBxh%kp$4xF8@Y7@9r~f;Ny;Ravh8e=gYdPJm)cnFf44#Z<@(b)Wf~ryONk zUTj7vo;m>3-!3e^U^oqxkRly07%Fd5q$CNmX(!o2Qp7-vi6G-hy}#yoGKG}u{mLQ^ zSVkOomfTu>j);uvK}(WQDAmyTFv#?r2*rs|MWmLC&0Wr?s*e|lO#*UST-Ne_pS89( z6GYTaJq>#o&w~6(H8?2RdX8uPuO8`-e-laz4h zix5J5-^|SW8o==MEHXB!Vd2ZW>l`HU2YUXd+fJKPGg@%p_!e+62692&IXVr?Je~!jOwpwl&ySBAc-K_?>n*}YcmA+8ejnS+vvVlxu%ADk%C{L= z+#vj`)$yL%8!Dj~v}h~kY9&kJy%n`;*;in9HGE`N(j(ZUfs&{AwS%X7d-vsl%JPp) zMbjYH$NDNQZ!slp)rW*7Z}QJyv(~j+$k0&n9Z$VpKH!Wrj(HIn%+`m)MsX8+krxSF z!gsnHv&yGiBlWc8pV@1TcSZji(6jiehLMRtYfC^vw)zn=(0CuL??{BGay8}zWlPYJ zjq`L{-11gNCWX@6O?&lhIyvQ|s5YQoWq0Szp;t50zr4IQa)3G6no}J=Hr+ZEh|HoO98msb$KnpQW`mJ)bk>>qTOhUKTZd z$9acWO~U!WgfQT8Ym2tWXx*m@vr3!KTC{%e*Hw_QgX?XE_qKI967+#Z zN$j(p;8=`cgw+)JkrG_1XWqshybr!JUqMyLu3#rui9bAUkT=cMV3_QikuJ;@SBI@E z`*}P1lZhOHOLTJ_08$5lEiNMdi>i{1#Lc@Trro2%E9>?&b!-!RDaBr))++%A+e z@?QK69cS1Wxlav$)4SQf+pn3!M?(pMU7Dhg_r#n>?sJyE|Tusp0RG|fTMd{u+u!Uouxf1StdJ+x*w)r4ORps66$(6_oTlB_wBeJw{pCf3_9ZP()@P^q`c}`kInvN*y3#kF^v9pKU7Qa#O48AXyqVX98Zeo|)Hc?d>)U?$RI7UOrZ57Q|$~e5~21hT#uJ(1TS>ax7^*l#-h zb&J!exglIuU^?>*`(GwIT_kNVL8~GO=V=0ZW`)&IP{-%K*ZFk&G!m1Bzwu7+zyQA* zkG}N;lBu2heiEx=?073393^f)Enz|1ejA42y*sWaWCms?iq+$3vD9 zX!OHtxUDUe}VYva@d$PIC^?59$!Gemqv_<_a4K-m9S8JQ>UV z97npvKb>6*O%c=MXEsk%s13>a-Bk!Gqt}k;ZxZ34{`3AaO0w7er*G4_0$USGe#w@F zeT|u;GZ{))T^vBx7uGs0#GBR9J>dxf&%fBUn|`2(1^4D=yya^%lef(=;iPplx<4vJ z6o2IP_ID`NupLp&k1w}l`=|`I=`7acqVeSYexp#>=>FnM2liUel%hmoBYIZn*Ias9 z&I^tAY9iO-(vHcv732D|R^G?4_QYi) zlht)jXr*)%$e{nCyBua}<;or$J87}i2p)o}CsThlJ!nUq)e7;<89)mVZ+0W(DrGV7 zz7@97nD^gsXGt6%PtaOhSN)6y$8Kz(XKncnH}6y-;=nTWL)N_m;Yj1C?gpltwVr^=NulS;ZyLJYwb?2PVM9K2{qV-YfQw9PJBVR$F} z3agTuw!g~z?`fOMv!QW$E9tVIyfl#kMp*s2P^>X}RVmeCu!w~LT!G;R=%n=xZzNc> zT2d|Or(Ps@siR+%&=P=TQq=xF>s{lWY5*B3KR*tADg;d;!6OCt;1=uzX^!6prgbqo zHUkO^4vrQSv2`dud{}TK4#@poCb8HXE@ zL~;AXi$YUy$XwUraql&>Jha)E;V~0wzu0lBP^sW^(~J^mab2KY-MkWY8Nt6(gAF6w zl(zDK0DX`XZvHM$U3QiAu{tA99N5U6a4=F}Duu-3M6pYz;Cn&1jJ<)*KV8s22}QS_ zQTTh(t8coSC~SWs4EL_}rDqma2E;FX@0Ii%j(;fgxhHhj7CA$prS)4~gC*VNe$sM( z15X%MEy6d@a3sOt-kywx=did!X{?*#w7UE#5{sVJ)j@gozd7_j7w?SiuWO56CiiKP z1hD;iV2cO0x62M`?s_<{8_9og5>YOQl))3SGGlfkWDqf93YF>EEDk?Lc^rTCVH{bM zoKDjWe{I@wrJ+;~walNgROYpD3i~$+?tJH^i5JYP^M48e(|O6Tx+WnA3mjnO4F$iu z)D2!JnuW-{c5*8bV)#7Sp1imiR74{IP(XcFIXXoV);u*Jr8_0<<;e@wS@ab@yl9_Z zqu?Q+ko5Ysf(%+2wHk@7q+vc^F>{11_|kxTNcyJxi@Thw)ZasPTw!1y{(yeL(@x9k zcbCSWA0?;qOM>t6y1}71HQHZ&`@;S&FDlk?k*cp9qjwmspcPN}f&TWr&u?%1pfCP3 z%>4vg>u;e#3=Tcx5^6mfvj|JGUlDHTWtx^2O3C{=wA3q|PNrLHf2#EzoL~XY{2ZDJ zT8&?}^DViG%KWGU_lRb-j8mrAfJ%a8IM$swL z{VS6os`-=kWNp^*k+Rd**75&X0OCwxG(_?1(ealRPl00T$LVTJy~?J`*lCZ>j{3`>NSFv}@4$IVSt>Eus6i)fO)+Ug}fhp}CUh=Fmd6)!3F9>>0cv{;8Mr z$=RO3(8sZyEP$uC%0$~I*|n0wG}M3@s5o8IWxNgs@X3P5-d)-|Hk7BLrJgYR<_ZVV z>%Ug}Ty5_T?mP)F>3C3?Sz<-T9xsrb+iSDJkIO0vEM?p}Z6jH~pZH}DHxf^zBr0mZ z=^lPfnM{PPMI@Rs9@Gkc02Si6h$vLqR<1#VhRZQ!iI_l2OU2_hiovfMAMmphk|PuD zQG=B>*&b<&8Xm6jSMWZfHd!v>G0fZD;?*==&cF58_~rpL z1UeKMB;qNvgga4MVJ9^+$nyki2MWzP1w9#{&>^LzV15$oMXODv1%-eONe@L+IYZZn z-tJMWKITTLA^+5Uie6L1{zq+)jrB$&o&SoY)X0c4vhJFEfe?XeL}cunQGWnLV3a8+ zAhv2%kwY2;t^OIb#WY&FV{Ou%U9t@t8--wmKtMA_lY~u#G)PFfBQ!ReBT#i#Lzm*5 zNvyMtBl>U(mvk22EFEKeGmU0BLVS^)Ne#DBYMNr!YVgCDA{1h++R0_EkgM4{xFjk) z8<)N?UPDkxWM)HTx3}^8WT3b{B4W-dpSv=|t=L{}S94UZP!C2n@<#t=3@RIw|3Y^* zD!YK3u?hvXVuzqC*!{w1i9`a-+9#5ujEjqFyH$mpNEVD|mGyJHUuU*jClC-`-}Rcf z7K(Zrz(Mi{*^6+1H!xl?-SU!XB>jm&{(=QGT@oV>ie zsI~3=dhtuzYj^x&F;%*Ndw>4OEj(;UWvOPbu^^FMHP7v7%SY(ys@s=u8e^&r;h=== zT=`o7Cp`jk{c5C`d zzK!%>8WQ5siSJ)7KdXshb*5NtC9F=_0@zeEO-(mO<6ltlgg5sNpczYwH|eUhK0zeg1IpkdnAJ zw8IBiFRv;g#Hpte{(711nrcQ7dYv9~KALWF^|o+FS=@MA?%^|@f{&lIL}|WlM*l_L zdeD3SoU=A;rlV6=bWtA+D`6?V`sNEjn! zs-W>6*$YZPALwZDMr+Q@vo{4%(Rtx;)RJD`-;g?MVldyfYKgB!q6I&k?22#YL^sB2 zdp1DFylU~QyW)VJQdSHoagaX(pTmO(sz6wezxutMF);johUj!lHf&GiD3n487z%Qe z`%}gQ#qx2|In;|!bhowDbZAlBP1t?0SviR3@FNwosH+a}Wb1?Z2l{Y3IaEG>mXG}H zeiU-%H2iUAtKL2Wo&aPMKE@mBG9B5J-f`5TPr>&BkTJ)_g`Ni`#qs9nop!tRZuL}? zG5pXlG&GWue*!QX6S>*_qq~I$!Ih+<_Z(X+~NbR4rG5DO>9nY{QBE>Mc@I| zK8q?t5EKK6vew!CC#<5P|}f%*zJ$4-?JhnC%;%Gt*w0DD+s!t zw?eI-6crFCR3frBxY_D+6S5gkPKwlRenZ-QZYBZ!9B6m4`+}NdssM@}eJnz-=Zm`G z{8AP$K#R-*TUIeq2@d%<%jE3*04(C~Fn`qpIplft@F)b*bvq|hI8Z0O90C9iQ0n66 z1?A88b;zm2N{b~Y%IaQju;Sy|Acy~hbUd$B=WL57FGXZtAdr#w|7`3mr9 zEQQ`fpJY@m3JKZ`rZQWp`+Xa0=6m<>~Mw3omA*^C~2&F0q!S|hH#^eO5J@gb2 zx|u21Zm8|wYIe-v8kO(m`T0h8&^pEV)X`Y>ambe3_(mK$`FlJZCoanMa_LkEWikan z7)WIr#<*ByNfG;;8hTqPm1)%py~4OK02(R)XytZ>;cB#W+7rmA2;en$M7q3 zq|xaC?_CZwK?1mw<=pD?zK78r`$t&ggY-_@4NqP+Y^WTRQg46Co*-|tgQoOtfp0B= z%Z0eSIX-lCHC;zb%YAL7h+FV*=0Dr$F;>&@ASw*Zar=}qT6h_OYphGp6Es>o_4wED z7|EkCt!J3{P}S<58@?3E^UrO9WAw+Xttb_PVLW}qZM69f0c)tTPs^&BaV~;bwNhps zbk95A?<>79@+2FODQhj$4TeD4hQ0WH7M`YMp=8x_|EtMpnkSzdOhBieov%U3PP`Lj;7`J`USN*K8>?_zx?_OMinE1-HlKe1m|Yxig~U-znqlL zUwznFt>t8!nv2hLb=B+zb+Hcj#`=P z<@J$CllvJiRY{ac6`SUtpEgRc(Fl@V22t#Yg<0s|!wJx(C`f*afI?fN=yE@dQiR^o z?*6jPfgAHKCHP2OxS>p$!iW>lNzB`sVof)5_Y`O5%ptTqQtRJJU|D^)A_IhXUOD#)0rXP^iv5^$kjVQfW6R7JfHM6v$T;{MG8=Ki{S+Z8(O$Jqr2?7R& zy55#V&JJwn>$||gf2I9`x8O#x%<;a$czdB4a(r|5RjSjHs!r&*_{MmJZRDbQ1zpf` zt`kOk9bLk#hd(z@J!SHZjFSt0g4hd^(PCYbkCX#(EF6WD!|5B3k)DN>hBam5`a>Mgou@eoL_Y%+k)RX=>_jL{i}gN>6(XsO(%nE!w7k7W=*h zE7-qv=MhWG+sLk}hLM%v;pw}6+k#pF;am~^;&Ki7n~Q*k@Jo}zhs9L@sXDfysG2@g z(6BUO>m*ORg@vxueNQjm1Cg7*8+hM373wz2yAFKi($U(QK=fFh&-eh9f#3*z3+qCC zdzwFKg}nTXmVPALZY#Z=-62=pBo*LsJP(hHm$!MY!iU*;OMFTfegscNW4(Ge^F-|C zKnu>!9=Yw?7>*z3#b}%ktY!f+ksWwLmiMw24^%MCkw+g{^;_pL`iR*2LENJxQGT}F zLv5C^N8c9`=L$MRddX!Z(!Uak4FrPxzm{Qrb4ZES&-?+|z|ds^ ze4i1muv&VmKg-`}=g>IP%@EF`hUFOVT8v^^I@1*amN|$!dR0qZHd6^m4YZ?5M-GG05yABpo=TfZ9B-~d4fwQ>V983 zEScVy^9daN=|V`w(Dh@VEbl%GDbMqD;m*;}{)%dBl+Tk8!(y5Uh<7=O8rDCsc;-lb z1n^=`nTir#O3q7p(cNjGQ|LhsalRQb013XSt z^rH^7-{V5$(fPsiHo$NKV9tR$MKdhyZ#zQc*?pIT@(JE7u<+_PDVvt4VMeM;?p@&7W5_xw%|8exP|)B`$&HQ|W0zA$+^H z4%!ajWl?&(aKvJ(`!x50riRG!T+EG{!;d?}KlfA@!_{eILSOd-f z$D_K{)6*K+A2J;4YvU62mve%I_-_sn#%AAYpM2Or@yq#2f3sHD%MfI8`nTO3>zm@e z8@&KXzrL*gexAKf>ZP!(s$O%mzN*<@zIC!QAj(2_hV4iDh0D)oEpt4_*J<=w;rid* z2R%X3j;Alr9;J9bq(q#Kk}}s~QAerL)%hebnXysWyT=7r&_fLx^R?#8`i0qz61`+! z*Z#GU^2C9zJ6DLX$^k+IZc5hvO^3M#@aIk7sHuIiFT7Xp#!Px2IUs31eAy9YIoNh4 zWZz{AT?Sfsv+U>*(8fDd47U~9X2VFNie9u)V}8FMj30DJ@%b9ffN-yOfBFRrsn~g+ z?pA?pJ%1eogNp&CI|J5I*P2^)2-i2U9di-QEo#~va8Xd4QP~AAgAJ4rYo=9VhHtu3 zy|ua_Zey+-Zk)H*m-)z>V4P|m#bBwKs4NgT49KvkHT_G5uz~xbe}OoG)6l(f-hR6)NG*Z6KSz5NND8kAN%Jl zX10!@lE@biw==vtV^uEJrv^u#`U`>$3{|X?e#g?LHNQYMUZWApTr|L-PE3`)k4`(l z%xusjHNf~Fh;N>bjs}vHFz}C>OyPz)ICv$kXj7&xOE%9*elt$b~DWsulw%K(azIf#6?%p{v*crHkG4%e(zUl)8?mu)nmOn z9X7YQ8BNYM5GXt38rri=cCzY_@wp>XCzXFY{#)*UU{QPq$iMXB z{SGZStdPrhV9ML+P3kcqp(mGS3dpp!`Q4V2=Wk%3%&N1?ZHORMR8P(R`NxpCIL`{| zz`Ml8N>poMruS>g{t}m;?%(j->r$8(e(T+xU~%XRg~sF7*#9bP2F;I1wSD;o!ZUov z+Q`vMg7=l)c^=k4hYbDz>DKq_ZH(i;B#+_)tCRY?-iMi*gC#7)9FX^CKTq9>Uo{WT zJ(I#adzV%v*^YY_{j)s3K0XKz{qIm!O^fn`UtdN%lT~2_;;Wu9w3^&b?r=f%d!475 zSU7eSOyJ=)^1J0>lb7AKzc)aYlHf*p~E&C|_CdHWE*w95~7Y&&hZQiJh` z=xV4i^JQ0dYZ#`&BNnlxv3y>Alt$b&A+RcF;Z}A*3H3F_Uk~vSROPB>TH~{jfK!ACBnG)LFvWKK4q| z;Wssxd4R!2DnSfq)X#$bunm7Vpc8QmlNAWZ0s)Z6dyCP${sSlB`Tlk;hYnbW*^Qo| z+rW_{P%A(-{1J)Q|7=}|%c0GD?R>xXcNWPhvP<>>y?>}RxL$r;l%=b?$Y}fm>&H3~ z|Cu+AOEcj$zdw}To>#4il|D-VuB1l}I-18;%MUj0{j$5zL+NhKF30stv zE9;6d`R%g^$cN}%PE1CKed9r3Vd7Q$v0s=-@LKeQ{Rm}U>7hapOx_oKE6|)+R6}Ys zQZ@hC#^z+e6l1EBE0<{lC6FUIqQP-fDo3E}=RxGW$fl|5YGzRwC1!h_X zWC%XP!;aWpCEK3NPF_-z918-+z-&JN~rNd+O_|C@7Qhq*m8tlEhcN&Q& zuZj5fQ?bULl>l*cT2A`82`{)}n14;@W=QzUYgctGBX8$Y#ReJ6R83qz!-$O~r@<(a zV0}cjuVLb)&4(GIGH+wehW8iqLSnlir!XSq%jJ< zQ||Pmur+~3Q4(Sy-{Gdl(!Dy{{UR=w!EQW|Sl0Wl5Y`CFwtTKNO#aQDkeFho?QY37 zEi7W;x?Yg&vYSu;jfoy=h>b^jYdk+BiIB%D2RgY9_M>boUUtQ|u9x~RSlLvuaQs^n zrzn}uOu_Ouk$Cz$FAM-hGLij*h?DqjdD*zFFT~3M@1-OK;g3V%G=a8LG+o=@&|+r? zRVJ|P?e{)QiaCnh75$nN#*;}(4muy*rC(KZmSIm2i;<=N`K6YeUPqKU4c+681lp|+ z86%nwen%+u&E}R{oZP#+XIIpjlS0}zG|-BZALa$it!MvygM+Ua#=7$(vpI2ydj=~n zDi`o03M0lVB`w>sqr=58artGyCYA@WRzr)God~x!y~*E_(*H2EO{llNwxl{0862Yt znGFXy!_lNuopB+pdetCkDzPN%Pr(@DX1`h=4<&i`Y{aP4opoSXm6cDmWGXZcD`cYk zu`#Vuqr84zBM?P5nM&{Mo`r8ZeDG8AlU+)#jOG4AE-CJA)|Q6V{^s~7VCTQjq;G?; z*ZYe8$4||nHM$u>Y0SLW0xfxcGcGqSr6N>6-CP(m53aKoeJTQ!cr$@Ar_rKH0&sV zUs?g&?KH5|D-2Mtgx-b2UxsHjOa$t0dOwe#?ikJ^0X0TPta#DErzV5QqdixnTA^E0 z8c&&DUS6n0ihQ?dqew}eWGJQk5*1S#WQ^JF5@br{IiYZ&AOZs98opW~N&!C_X3()? z5`!saX0(|=bQ!4V9jV$@z6eq`3e@bF$$@f1uK0x$uQqaE)~O&X5iKnya9G%&k1k+$ z4;;3bal@@;3ofY~I?u1r#$af#XgtEffJ5AfWU)d_MDhF`+*M@BF}JYojWT73gwRbn zcpkorg9}VX33^dX$~w81B{s&uQMED-LP~htNo?%`MXD1jQRD+k5v5srV>qqUK-D4F ziX&cB(U94hUx|M2E7NwKN|&nl3Yr(QqdVWa5=Lda|8606xDkFi@u%AP zAQFq~$*qId)jh|;iOv;t!{QP^S2xP%t?SDPQw;mue%8F69exdL3J2gOj3@3jJsurR zJ_&ycO5;rLB9Ot6U8BGaZMlEi@ug+gt^S@*S*_1-7XX#jt?XiBmA1Y%C#UQUwg!ce z$sj>DBXH;AE5k_@ott27O-gX%{H(C!T*q41bUz97uE<)rJLI7eO$fU%BKuy0rYRO8 zug+XMO!zr(;>=curTy{IdFeKYM;g*&nob7V^&b`&4J!>_L~Nh?zq)a-IhkyKkC27* zjcp1R?#XTShgE=+CsCcI4NoF&#I^nGiBAZy*-shx})W^=bo|;Q9NiS#p z2MT%Oje}DH!f%D9P%#AYE7QVz>`KJGipy)ScIYP&&7429UsF>{m+W5xb@oqqo{2v| z_emE-P~Gw5vTmayp{ERL$oggDm#YyQKEgw_UH|9)u)-4@e2>{ufNE4yr<>8nK{;$5 zm#M_D2`}>HR*y{FR(M^RRrjs6eMx->d}z4)PN*vaaK{Dv=sSF{4rg6_a|+J&xb&Mm zO0LjbHl^&KlJEP`?AqMI%mBLE&2Qd2!ndqGP-D~4=?S^Y=b#f;_KOz;>`qbTh79-5 zmdMV6YGMc@Za(j3;)f61Hy5}FYstN4we>H`cdegaD|#hkYc6il;m=7hz8(rdML=rQ zlydml?v_c2dj|9mMT7!G%)pV!Hl6jjR6a0_O-hb**uUhgu9H8XvpEA7-Tk+5*>|2R zZFZ(R28Pt3xC$X2{8|p(00GT8{oC7&e^SMul-EC&>iED>qLHO);b0@_z?Mx!KgJz- zSYlJ2ir`(8k@hClj0)u>Xsv(Qp7QTx1oi);GbF2OL+g*jtOTbeT!Jnr)DV%b1i6yO~)~(qrp*vG6RZM9CLF6?H!2e*VO<4qbaa7j zobDfd4U34F*Kt5>*0+MT%w7N*5ICezqU{PE@naD3wumG4+9{o~Pc+0v0t@FC~%s06L@nXY(LL18T=FGHK>d8svTLL2YP*1?{zJ}O-`>U^H2 zmv&UH-8SBBQT*!It97buOCzQ| z`uISYz0*@X4y!4#3t&~LeV7_8@XA!lDfiR#a_w!AM6{sb4!hb{`H&A>R20X4ODNs@ z3!)E>%omk!>Lc- z+zp{l3aBLU>f_%IVOHV&0nqS=pA8kGWAi91csf|cC_wjWS@X0HZuYdEoafT#u~qkh z2#`ZpUF;F+eROx(#l=G4#6=wl+6BPGf-_D8v_?2RQ%;DS-@jse(la!Rk_CdPGyoh# z!)g0QqXPhKbU$X)h!bUu_n;D{_BfXDjK&(9CN?1%l|(7Qxtq~{D0o?NT7P$O30bKL zAMZyaE+9ZV|65pJjg4J|^?7+|$>ti+DyK|;Fo7jeuC|K=k__c0qEvHMH%!}8H6z5o zXkkZ0Q0e*r63O|-xXQ@N449~t@Z1(KZT$Rw)J%}c0` z`aL)G)5~@ryB_8tsc`yjZ_nS%ll)9xii13oWc`GT&hRuWV|=oag|e z5QV>^1L^DNK0uAOzwNE?*%rSfwt13kXmjWnkP*W`S;x7hT*18+YQgHL+MsuT_Slct z^fv=#C(y-_O0Jl`s-umzw7a=|gBhlKaMqH;G*$S06D8H|HSSBMXGHJ@0S~mpq%x9` zCkqY2$a1)STkoE!`C&0}bQ^=y|Ch6-VL^EdGzfS%nLN5OrL=y{g2UxU1_>5Xx={C> zYN0kfX=Kuv+M%Ke^I+7VYa@Tk>zvHPj)aUJN;C}lMR&T$)eg6^)#9E?( z9Di`fI6O!VICjQB5$Wq0bK(EW%UG&qDyO|(dAjtk&5PxK?IMNsq!2pgMyRl{>dCjU z%Mf;4>PpDclv?+;y*$~2-!hRjkfQ%@QuOTu73#mX-@p5|Hp7Un!@d9RiaI8+Ws-JH z!Cu#LdE6U!Q4u>NLT$kfqS^u3Dv5A{;3a63y4^mHSd=bpjO1*n=vPW?-JgQ+%^#SUgm*?!6f7AyBdV5l0`;5^Q9ii6L}Te&zxI>mi{wj?#TX zEkz%;u=vF0QW9HxXR@@h!4MdJK9-BQb!=ROM~MZmN`#mg^IJ>+AWe+55UYbjK!XB| z+P6AfC@l}T5ODffbUuRsJaP{MaInzYBxq^?bR||0ZO~a0k%|){E*h&mI;?oUIUXv5 z5vvxN3}%qb?%8G3Dzdf5DPo(VB<{T{P*q!bT{XVN4Z~+suYjGv_}i^=WjjGZ3VH!4 zDJmr#oO5^pNOJHED2qqP4f;eA4 zDs2iQELb)!vK=*phbUw*Bsh!c9-S5ygdAAq*h(UXyAM*2WMgu$kyTXTmbe1F-MrQP8V>q)Vz z01<_~K*6@Jn@OO{1^4-t+Hyi9 z6rHMB7?3(O65LxirN8axrqtT`-Jry;yyZfLOY<$K=_4?VO$Y{bp5<;1q+~Z92M-L; zgnv)xapZY3?Di;N^gEW`t}ZXLY;|9k3cjs~I&j?mRoMj*9A#l|W*bx^K-Tgvfqm1)%s+LK4k3;@^DNy)+y)eeO2rfbDza(9E?!akHbT_3;PW zGABGI%MT&=(BT0$%l~I<(iT*R-}e4N$WDMERAHn?h<@nYVoVL?AT$Y01R_FlP`GBj zaEXC@zg#sGoFHey9&3?d5aA#e;@-5n5G+Kg6r2Q+&*BIpo$@@K~;+Z?oLjyh!z-4JX9(U3?X0$0WVT8gg_#YmEaTrNUu9b06?UmEWl7e6eWlZ zAW;eh!=OcPhO3JsI!qQ=1p!t;_MG7u0-j3Hs1>mABJ?~DDiK%&5mcm*L<-&_Lg~PP zWe5yyZ9izKtT;cE_u^YXouR#zsMHP%J^cLDNzwb{A8$Js^#Hj88Zb5tDMt>%%Rdm# zZgRLuTI^wS{N7#P=7;Hkm<;;7j@H(RjWtzKGw)eR#!j9xYUffYm2h$Qz?mb55HWog z8f&Vs`@gRzUdzw@1@8WV*Pw(>n)2`?KY8Kh(8$Rn_W-&Hmg6ucd_qW7=~b!zdPS1G zkAEi-5*fMS(f|ATA3`TZ4V)A+3>cQhn1~4>Rb?g0x{C66dmsPnB5cx>br1dMr+*q3 zHFZ?(S;&M*!By9;s_QDsPTKqUcN!*LYkE-l#P#mpKDH%nbzVHCo4kO;vA#Qi_EAd*0jg<{NL0R{QKlM@I**RI09oPLA5-;ONx9 z*=!$BNy4eUJKx>^{+n-)R{OptyjDK)

Z^@Pd>r87ea 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 b^M?!%c8q#dHP|-*^xKVVCRfWZBcuKY2f{R# literal 0 HcmV?d00001 diff --git a/eo-flow/figures/rfcn-architecture.png b/eo-flow/figures/rfcn-architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..eac47bded1388eade97b1f97b5d57a45fc979fca GIT binary patch literal 172044 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%0DH0g8QJG$>HHYF>2W9p{;O1SREOQ$?- zZznw{aubH$Ko@eXTEO?Y%+T)jLI(_IB+@Ok;jfuNU7jwtVfS-n`pO&LA z6^rymI}i>Ts1T`nbESuNSp!(EK})ni@YmR<^1LEN=u3bCwkKvF;Wm}Pty@}(0;xp{ z5#{10%cDE-Oo8l!x-aH=zy&j&MBg?T`>H@MqP)G279P~f%$@1d`g!8|N2<1co<9~@ zO53T(?MdL;l)_$Tm?oR{2ZRp8fA*ndRLj@&I=PT*7=9T%=xEV?mss8~k{QhIOiLPA8uj4$ zX|ZpK+;lr31b4YtK9x>hYRYQU3kK_9X+<>fX5!(6Q?!PVYE6~ueEe* zoQ)c3gf}tjLaOEHO5s2pUbVeMD;X7Wa{a-tibEO^6Fuq{j$sxgtp@8ewYd6)?PWL{ zc=RP`N{ZJOdGZ*T=sthH1m$f*dBJ5angZ(q9&|lRZisNx1*7JjVA*)nzI$6OM}Ek7 z)Bc}%F7#CfHrd|Y4cRSItU4yFR8mwhui?-Fw$0$-{wUf)hN;j}yTSu}b|h9G1yaf0 zae>gd0RyOxhzKdGp^eGkhK3)N3;c5!Fh@XbA}>v{*Z!n#ZNKNHq5g3a?CtF}*j>H_ zjvmI+1!_f2vfre3lmUyV#q6?@|ye7)Tz zt!KAj2J4hP{s~?PDy}N4NmrcPOHXOIhZDGu)i1@Im%%I&zdKGz73U#-)(a)gRw{$71#-pNLd=}bzS6F-7Llx3JZLdBg3XW2Ly*U9%_{UT~OC)d|qUnLpS)C z35)~DOM;%5igoqMYUXjRAP}1|kR-j6)31fBuFF|M$KJn}E2y?bBhp_;1p{4aa|1qs z5?YP<0YkzOn_$<}WVfR3Oo)fD0@SUF%+7adP%iS*X5gD7+5Yj$vW~ zS2Hbr)gd6;)=D&X5iw|g=k~?8^?@j(EOpP}>*at+=<~k!lkW_Pm{LtH=jAyrL9qRs z;4og&o4=gsH{{%M@xqO$gSK6ywO@zkH$DM6J2)j|$;2f88KTdfjBY3Wvz)v(=@T({XR9yJ-EJcZ?v(e|fU zqAme56`kAP%X>DJj5K%6rQH3+Q2~Rmer2mYtHD%5<(EznVmvfFb&-947ZJK@5yCK) zq~Y_BSW;Bt#lU#8ZEqP}_nG}{){*p;;05e%|uGu|Ls{~gQlU?TEGY@ z_PEdstk6H-adL+Q!wvg(8cEOsjW#NSF{@=3Hh4bpa|C>eT12kkq=5i+c^(oZ4Vhs? zW?{-Sdifzte;v%xfS`}ZuVZo;2ASh<%0WnUSKUc z_CTA$fkmD$is?|nF)lkjt1$kt*d9KVbLVdC>w-+%Pfdc9)0o_FHh)HVemi%!cE_6? zV^@zSz)>7sYUNmWMt)_gx!PT{@qz=GH2EoaTDe)B1hF$eLX0-pC~GBBNFg1T`dq9z z-VHwqaW+2TXwWe?b9Lsk9QCtS8u+O587RzWqEQ5*J`Wbvn-C#wNCtN-}nOw;wtAvU++%dKkzF5!ldI z!D;6mEo_PSh@^e8dVbIFkUmFLTx|Y9(H(ABLYNc~3kn-_`LLsn+@+D$=foTun*Yc$ z?W|*H4Y!P2>R@%lo{n-slb`OryZkTk7!G5K!xUea(|m+Y zbJHy#=oUhWNHNogg)x&4hiIKs_=3>6!*-}|bYzgl?(@~9?>_I~l*_l<`elmJtv z5MVMZ-^w@L3L-@lRaL?#(zn5$3iNLlG~;x-t7k()y<{zZH{Run_TF<(5x%@Au2ajk z*(^+X_)3fvgP_s?P0-jFI@fa@l>gg8Fxzfv^JAQ?)MCw+a^D}m>hWLr5KKSM^P7nU zW6xQu=BAgSc`=LxJrH*T*yl0Z?MIGj2xtRwCCuk@vL>Sney#^$VdOH)?E&{NRV4P@ zUR@PWFlx$59`7`)2+>OX#^^G3(9EAf>Lp;L+{s2V6IY`ya5v4IemlHv=dG6OGc<-C zA-N9XYIiA$jVekKa^3!Wd}@O60;59NM{lwweyWs=JHjnWEkwRkL( zXx94Ds~~xEe4zjpkNN$kK%aBxU|2Hg`)gW=DF3MIcS>g%Jm))`*~i=Rq#A8}-nEl0 zWBSdp+lyLoJ@e`KAh9Bp6XL?-m-X9!6|1-VZv81f;ehSeCR)O9>;C}VKq9~1xx8fj zq#GhuXg~P#glA&T;q_WsHg(qh^OoNbbB^jCHV7e@cFj$AXHPwj)|?vF_V-=8FnQM4 zF;4;*SpI*O*uESw=kmHwOijIG?p4<=E*LxRyd-aRjGH}=n|jIR*H|5nE2CUh3~)~G zLt$9F(0X5)spaS1ED=@t4rErhqswN1z1;(6eJ2hTCnGVN;EkeMY_Yon`(;@G0|O9- z;?o8Ojh_BbZ*@lpo2hU~o@oOPXW9_vDT zq8X>gS|Di}ghRzCFxJFDN}?cI1`J97QR0#Iv;aeuT6fJNBiftdVZA;L+#OkHc&!+a z`?gDpr#St92#II0V@f6fpxb7^(ZzN&5SngAH`01 z@J#m$d^?;tQHA>YQxJWAHJ2CEL3Bw`;FD!g(7=>_Nl`SejcSFcidx-Al~StN59pq+ znz?|+)e%C#b1D(YF$_3X3yuNLG2l5CJj<#?BhRVpTBzzvHV{0|sp?F9ons;JEDXH5 zuOM(R2t15D4}-wLAaF2hOZ~M`U}5B07JWN7(7O0ktcQj{3yV>J#VEjRi*2aELPsh%*@wZw?8Q0r4gy9A*Pzje@$3K?|dRc%y)LlYk_P z2}u?+;!Fm_8hFGSc-RFFF?twy#0WfM3h%|G0S1EsMuPzcgAsy30MGLP z2;3eoj-RN8EJt6I#B|toEaYi`K`o;V1xtvMoP#!Z@49#=Z~Hwbyo83{zAalFCn-8Wi) zUt`8kx^u}LcV8JT5Am`|Q!!)0c(i@7E+XY|wiqU6;*9%D={b`lQlJJ=^iNQ)^T!rP zvfNMK`RDFW-u~w^K946%jdpm~4ir?33#`vybQ!Yzok2gX0bnm355^QeXsLKTjo!}2 zhcJSqL4Jc_qQUFk_hMODM2}y`j*mX7+3@Z=Pq|%PVM+fEf3+R?z`{kKXmwTiwhBgWcEy|ZZ_?IvFw?s9`^vSPF}F+ zH?yx=mKo`SIi5%U;uZMYM>~hTk24_-_g{O-ipj-!S4Fx#Iz$nZlM=D-z_qw6T6GMD zg38KUmfZI3E2A;}zijFZ>-c#Ko-`Vb*%2>XgWw~RYg$bEUMPQdwEHinbn>)cUUk>~ zV=e^o2msh(<4|(>4fxZCTjBK&opUul#)e03xpLf;(t@7?h^WHYKr!VUUiTLi@xJKh z+mcJiPk91SAksrH6~I2=+}wvk@y7{SE1vMA{SR$7fc>!(^v!sj$V^0BhX->%K7!6z z6XM$3Fm(G-&4&-j>8_hCGR16z0P7&bfa^~)aEpMmt`n`q1QYSWccKc-n#N$WzYtIC zd=AYu*{Cm!f!`5Mx^~8yU}*NCWQGaJ|H~p~pA1pq(KQJW>ItYuhbR6YBZTK2kXsGl zPB9=|{mdAOq!bH?(2A|Cx2mEk6XNEWD>_pkwoay(g zW5?ZmCi^geO0@3Ty%%k*ZSaetnk zsv=W2``7bosY*{k6eajYv7eA2`Xz{>1W}S9^%JrrL6Kz0k_=gt;P;6TeSU~OKm0yF zd|p4iULSl~c)eb@J#O^$sL|cyhTE-1kK2tNw?~a0H@drf;OZScJ?PS+vqxQ5!wr|a zZ*+S+@cBiEk_1tbAc-<0Q3`}8N{}QO7TySl*@}3x4GCr&5-eI+?MSfLkzlpK#0y}+ zsGhhQQOxejsVY--ZletS+^QkU3jDI7zScsffJ6a_ z(qJeGWZfk|&6Wn1)q){l8GvV5$RO~^fKLMaGEqYz5VfUD8TGYH;g>=}2K*9*C=*DE znm|w1)V8W+g{HpMNLs2{dZ?kVhgfIGN{Gj9h>HSrHw0DjJCNl?&^|-fY%^p?`Z<-f z^DBywBoUJ6hba0X`h5^ZKm2|lygn~nE*EO*>Q!a?=%9d5`mYyDOW%K?ynM`PRSEzG zgJr?Qix=EFb>U?Z@y8r3*y9|y>4AsAbTp%D-}cd~m=Gk)x}?ySRrG5Bk?OMo3aoso ztZen)D=H#F3=f33BKw@_xc-)#(f-A{hzz6OJm0tMy%XkFxc${Qx;zK{lc;1qxwtqx_ci$oajN% z@yIw$*b2&=_R{gs0I)=)z#s}KC986B9$%T8`@@L!`@jGA``>R_`@wtqdQ)93ViOX< z8-ml|1fvlb&zug2XNVaZgdle86zIu!siIJCbK_5ZCr^&t7nqPj0IOasD_i+OadE+j z%j<>rUii~%8&|&lx}Jxk?$}YJ=M{hn@n&Q>9t-EqMY4P7nJRIW(*iaMR1$sO#@a`E znodR_`3@;$fK@AAEPHRo3z6>!9lw2T^=oge*%auH11IWGlA8`TL=nkzEHaW4aJaew z03gXS{;~Fp-~R30k3Nfdg9r)%vg*aMXWx6F_}Qo(cW;cpXx`7Ry7T^7(Yo&^q-CHp ztpcC#KRN7u7ET=-bLouArvVH-@BA!5fg*)s^}gkJ@4zyQT7Mg3VsfTkdd1^o#!rq~ zR^7$ly0dul!o|M<5VbFJ3KS7aSHD>PtN*-G`peN!bC9&Wf(I{I@vYgJ1yOzMjW~+N zO@xwFfq#5FyxB)H#ukyAE}OL|Gb!O)k#0-Kb^q@E;X?IG&#fmH=h3 z;bXKr+XycDkVolzJpO!$MS*?bFw|1N zyK(9)*7Wkbah1a+>={6{PdI$!7`oja5U50*Us987>3+9Vo8~T4RoNII2g40URiaVz z9pwmtW?KuQgeY(s1|S-tNC8<14XP51P-oQZKC@wDo<2QZRv^g=6q!PnX~^dxAt{h0 z3PqxzS|}2QENY>xE20)5+vyD?G6j+JC3F@P!2<{nA_G)bKqWO4S%xAjfuJ%4p%i{u zf=}|pC;8zC37_PLD2Wgyl^ld3_Zvi!!B7Q?EUDySXh?qeL_d6f5k5(TUn3sXkRi%4 zL|KAgmLO`O`UEQhvQp93Lqk&3ef^>o9+CvVB*Q03V0F7#Cb(o&z85S*!mSy4hwfWT zLaY&jroQSz^ITSR+XaP&8T;xU$cmy~8>;mJLM#}9LFJG#^mQ!)+lAOR$dUp@Qq*fk zyY@s;f!8O&*DL&f30|Lw_Kq%`Ivp8R*|0&#B0}k&7t70k_d;c5bR=BiaF$G+^8a0N z``sDQBzdBR;)zqR=<2J{_0^Z~w~StrSI!oL_}Q0UY)a3GXu>55T*fNO-WN(se-owi zUr{k*#`oqgzv2AM5-|i)GP7~*9d|>lIt+IN_?6*;;RPhjy?lx_ulVPPkTO)mVu0D3 zlk?bba&sSxsEQ%KwBqv1Zo2K3_!MWVh3ozAR? z6d1%}D$9FcEGzr06&a1V=h4UE*}ECCI|74@gupRv z{@l3nGk-kt!urMKl+wL9IgkH3Lf5&n;r)LySm`> zx)Ga@*k_}J)O1YBbi(KvTwuzW%&--ffhsb5EscM6pFI5DpgWv7mVmJPZhWci*&AQY zA9?1(zM!wI+Vaq*U5EE}cDv#Ai%53#?e2`^c(ix*pvU9G$_+c#KlX=L|0@b@32oLA z!qR;&mHq13SM&c6jpGg=y|8f6r8nJrV`5r*RPX!cb1%g^huYBG-ZiZ42_bms#>*?N zT`=`Gi2fAgB?^Om`<91+fT#`b z^u`-MH%(uCG562Rd(CJc%b_X3fwq|pl=U%)-|s`4!wk7gfW_^{*q7SjIuHlj-oDzD zEiDW>`~#;s-gwcMHQgV>k%`*1=a~&;IphC zUK#v{r=h%*0P)E*m=F4pWJ|-;FOMRv$_)Szs)JvP9S$?Tnv;swN)Dz&1WeD_ePtR6 zgDl4M_UpDW(}uG>0|2!(wK&yy8lofy{cb6O3CO6*oXHxQr6n|4o;C5rI4xfqO1~+y+T#D>g!7Q6ni~H8M3H^D0o96 zWPeGNA&2Z2Hho`P*UQuE3XNd9W%xxIUQy~5vKH#=9-ki_JzjM5c+nXW9o-(Zb-U5( za-+S+gHE>(ou2-q!|g+-+lMZXh%S!^mmXdbJw6d`zX-Qagxlwb+b6=~4-E-kzXXpK zZod?GUtbS~x{uc%JRYAY2SZZBFUyb=s*SDQKRvdcw4RBQOBK444p3SKKNJ zg-n(3P?WF)b1G3SYb3P{zam2n2}zNI0|dH?Tw78~14-(1Wp8Lp!W6wB5lE(|C=mT3 zI@&u?Ti0+_f6yZY4@$pBBhz(Yx(ksB_8SpE~}{YM_1l)&*b=&sEHz?jz!ns zf`Y6JG_QXjR2q6ZQ>0+cD>m9o#@)-C%@ZPAG*1Y5m`Ku*7t71vQ? zV2sIPjZl%JkEsh6Val}WXx+39QcuKYybcLNl9R+vn7K@FI7gn+I~+Vf9;TEW$;o;A zE+8W3J8|r+xlfOuJ1w~l2U?EyRUpJ&pz;M8t%!r*j`z}jC@q!36 zuRjO?zOP>AKm0cE^oaU>$44L4eERQyKeg}6jY?j{*a5ejed%JPx=t&@vJfy?I{odZ z9!7MM1qlEiG5CCkUn(uV^XUj(cYF74YX9Wzw;nyPZHts!S~1{uQ|8V`Qb&VGMgO4X znKJXhTkY*#4JV(9MEm-IKq(%jlJUrj7t8K=`ss)ch+)&-z3s1jxZ%-_UmcRh6=e^& z-ITI?eE7vz?ti|&`MUr{&vG@K` zEQr#JG*RhAia-(|A&>+}@9o-_`TenbmrHV&T*?JspM1WbyX?-+%+Ad2?LPCJ=Zi0Y zyI_?+YYaY~?s#U-)H{dwj(x<%)dQ6FHkpx@Gy@OORvu>-Bn%wV2m@h_8P; zhw>_Yqv<`|w0QP`$z2B}#w-V1MzCr?@r=og)TEi1=ZbO9aoot>!)}}Vze>E1o_3E< z_kqI}!*xWuEi?e01&{_{E?UK!~X8+u>lB4)xo!jV!*XDsEYvi zr`kia#s^t1_r=Zk6OsRUEX?WN_<-|6-%9%&b0sTc3sfrAGB_AC^$!33)>R)jnI_8QY=J71Rs>uu8x%mSF(JbCFVcX*~r6 zAu@?erJA5q5@eYL+ok&|C8(85d_h^7F9L*ENniQ*nLrQ~a?L`@ zRPq8Uc^*}~V6{rVW_yL1N14ein^7@SZ7VgJP---xO!+J|nowdeq14utV@vC9SFFrn zLYdKwa+4Vq#@be{Y%e$Q@-~xfkb1yg_PAJ^KMd-?iKA3WiX z>D>no{o4qxHwRibcRcX#XQ0!Ux0(l_Qy>I>gKmq|MaHd!YaYe|KS?Sonf5 z_skm6F}h6^I$9kJ%VOsIC(+(rgW|(`TZO!G7T!Jj`?+`S`XYeV_6!ANd4?||BcqZc zBA#tYe=~z8PJVyNBagRgFqOvO?&XbnPcB6Hi9aAULJ~Ox!m#ikHvSH;ZhczS%iRWn zgpjWyx^+9frdzjREy>6~EUfRSX?H*3ia>D=PrghrE0(Xrra7fRXM%!a}uQ+vRs9#$zacvLan}}|@(`&lD*_!9g3>ZK0y*nS8 z-)8rHFF${%6Gz~eQ!iI6@Es{cl8q?$qk;Z?#tYF%ezko|`oHvHk%ep{8jqdJEMErJV!`T+YyPkzN-;09FAw1+?yc$chLA?Kxe(>6@;VK?POr7`Fc^{PF>Y@(3uc zgx}zs5H$qplRUvpC;{nUM(ES$p$^u=EwLEk#PM@fhLOTY;4o%@8@^u_fGbnYSk>(k ze5Zt=Fvt_sTaC`aEWZBj25uDR;k|=r;LlXq%_}{n7g$jOktjG`f>((M<5&qLRsJAE zCW?*Myr9`u<7i}XQ{iT3Z-V~O=`F`w z(wIfrcw3Xx)%QGBOb}oYM7iCmt%+7MQxQCsWD=H8nWP1^nq>VhL7)yy@un3dNhWW3 z2NMON%{DvU-8IB+&3LRaQTFtumPv^k=?01#J!nA`p*I+jos)-(O8YmVHbksM$euL` z2|HGG>(;52@{CFtIAqD~v*rc1CCTF|gmsR_)L9RrI^_%uxi{LZTvq3XfDyM3*F{7> z=fYyF{r_$E?vc&OfYWM+_Z~U=kwLdlZmWlWm%=9?5VIC62J&v8DlMta$|Wp^z|oTu zJ-WoNfa|pAVhJI8A|sdV2oHau$^9MMyWhM?bLUTSRS>O)kkD@+2KP)v>B&D@B|nw7 zALrY1&?5Ktq1{>~LwlgKCn!DGg6m5T6gPQls|O5f3@ppxu_Z4;Nc{_ZMdKQ$&cLt# z@ZP?ChOC5ZUoHWlCqNE1cbxlm?(8*u%9IrW9YPy@?C#L1GdrwnCm0JFUQxs9+*F?3 zdad+~?%l4b^=UF%KJEYjeQ&$1(~vu-z3T4e-RKXwZ$JQ&4vw9Uf8u03ZNK zL_t(FvhN!s`o;$}mbTSF(G!#$T$8YJ$Lby{B3hbVRQDdUC(oOIXIlp*jqW!XM~WF_ z6vF8Nh!X2d=o~ z!=Qb#TlB+=L$>yw)WPAB3_>ZTJkR69kH5hFKMtX~yaFaOZS)Y_;8K@anUO6vOfMMhyP?7|OFp8I}CCHSlbt}OVV9T~fHs2`)r4k72M0F!d zY&%8bfm%gS?KNDD>_cPoT9i;H(Gu;94jma^*Sr-*0Ns!vU^#AcgC3ZY(=hVz~y}Pxc_M({^^d#3m1$ua*F6f+#{!7P0n; zO2xt3%M0;w(fHS+vyl*I)%j5oLK=0+U6YXTBjg#kMnNd`ri3`Vl*0_*3z6qvcqlcs zx$DPuUAp)9?;|h2c~6(bp8r#UtQvyA^Z4||XK^n58ahm!14h$!?*=7Df6XcQ{g?ZM zs)WPmf`1JEY*w^}W|ked2dqy4S%^6Gr| zzZU*7_0cC?uEXjGW}^|yo_rL1Twl0#Y=w9ll%inY=6waf@3<3y5dhXEB>YSPXO{^# z<@z#ENnJiXzSf$1~sWYR&D?N$A^}GF$=Kw(o%yp32$x$7^lvgg8C9Tf8LbhBT2yP52Zfa zXa#TD5%d@$<_arAeNF zO#qyd0U`vxlsebmL}_nA@LK!^G|NMy*RWCVKla+&3tg=>>?k}s7I-H zPVGV`#ClUqpX>vbhJk018Sc9@$QS(KGqV%{Il0yYG9&#VF$8D&cZBYygsxBPF}Nff zWn2xt!BPT^MBpuQ&`1R1y6f?AKLMhi!;LsETIjdCKcDFSdm0gGH9$x3W!)J6-Crv{?r4)coAUC_&S%bV0n}cl1 zP>5GhfVUTMn^+D}T(zw_0<xZKKaszu&1u!3%LQ>+hbN~z^5p9i9(bs&mX5R;3UjjY`cv~^3W`L#5l#n% zY%wIW5jmUI94k9_VhVu5H3ZriiucTtdtFORs>~t{Nmdm7x)m2jV_U~VJg4zkKB#w^G~w#-(KVT-uM>Bb}F({C?M=yf@cuo{@4b=ZL-i$up1#=O@CO z3<6|Ris$1u!l~=cg3zvA$It%H3v2t09_!?!ZR>+d64tI8iOP3OcO-#oJHjr*f}^!~>KljPH&y%m- zTny`?ZXjg_3YsuM-DEU#+(!)@J7MEv|1jdcFee+IEm?Hv+|ffb0XT|;T?oLH&v@AY zo(It2bB`maMyc055GURHzf%7l}1ds>; zqi`o_6$H}`sBoo%AYsh=NHRu&J#;7HhOI+VyV_wD=4gMx`(AUfXHpy_iz6Qe`1K>u z@5K{f^Z?}AY_>aTu#lkN;nBrXxZch z)lhgWy@I5)z@Nu{kbHOD{np$&ckT>N4^MEM9B7OHR_|I+fJy+70FGr8ZBqGZh+zl_ zLlk{mIj9tcBEg_&<4TexAQT0qkTq+mOaN;*u3=Mg&~mlScE9C+otlGAWn*gD+*CHE z=HRAL!QGyzW%JOe;GtE+Q>SrkZW?%M)$r1(;i;`}URq_pM*c3F7G4_JytP_*X*KZH zXyC2Wz~4;^f1SlNvT5Z{Kb;nS%D#3wE&O#l`0I3Nr_-UGoBSzn)52GyfsaNDU#()6 z?>hO@N2`UmR#Rgd4ZJL-R?DVQ%k|P|;H6d9Gf%A=-WoOhEcMh`>Z!5T)89=8KQ}En zh5<_$FgC^#1}q_985SJF)(c|BFhof!e{u{56~opT%R+7ap8?0np5Gdlg}SaWoRXG- zmSt^>gNEUtQ9iY-<#-NiR@rWA90v_6m&q{w~ zH(}=6E;yD`ptJ)h{W2mU;pD1>gh5R>vPZXp!=4y5{oa2Zc?$pm9YS#5V+&xqngV@R zdYg%(GHNXXMo%8#78(6ATr5%#!0GmXf!C zJn1;^KTE(|PldUppz#BofN$?XvHm>bsY%m?8QZpXW-B$SY9OMeE>xK~G#JB?h44E>c_lUcuFKH@y z3jjKI56qf05r&M^2GbFig=bvPmjj24bJjDjRX~6cfULc5ZNkZW*EZY^7Th;+Nbd)3 zAGV~a!n+=Qa?Gs`Od1xO zfJPSer5fCoar@vol}q`i~m-THlek-7@kP zkb}tGHGjc?eq(Qc8*O`!wylLSUf(*gy8FrjjivSt44gZB^7M)SMDi8@dJG?p0*?^< za_qcQ=_d^Ct-5Q}z`OlDJtw=kYPDcH?l0brM*9si@&59Z`A;VPlgL{@erKHU;3ES& zc8z%+KpT00)I$h>wE#{4PW6Wss*##ciH6+!?Nt^rTh*Abh2qtK_N=&gZ z=j*_P`{P`%P~-)BA+3VI@K*_ro;Tq89p#wuaRnYe#-T(dAl1!)46PA2H6~ou8F5u- zgalwrmp;ss(!;azREA8MhL7tBi<2}LaJRy{8z{N-iSab7$b0g~cVQaqW0 z4zF48!rfs;^{WDC3x!>XiJP$20!flU z6iEb1A#3Ck0*1(*k_-bdAhH~S#mke*q^?DWlp)0GjYud3B?MHGtjqKn2QmW|Pzr!B z_GJ_rI`O(+2tYv;uS_{#d!C_I@6Lu?aH+gbo=_z}yJ?hjwy8uduTP6K1tE|Wo!5q( zgBgX~wB1(g90AkumYRBy1ilLx=KtET$i9+94tMIb zp3lm9BNvc^Xbqn_~!DFWj zWhDp8Q_g_EA(qVnlN@9(BiLoPGUOl$e6R zHXyU32?!4J>fYzwvcHbaL=#uJv;rKBI}6k!CQbdILqt@wA4(Dj48-x{$B=$p_gO2U9|IgonSs?3ho#+qbm)o4 z3>B-*`IG=Rr(PLN7p2*T+KsR`bhFpd+pb~ z``}>1MxVvy22B;1|?_+=m zG2uKDiBq?YL1grKlqGmVAHsu8>ImxTj+m}_2rF-otjL<5LxUfOszNQg_*@6e@+j8C z!q`;@?l6I$vZ;!-nNE)G5c6A6<8-)V^GNDH-jIo32Fa#i=Rzkau609{ft9Yi`%ZFIgFbxyp zw60h{y(-t_+35K*U~C>d>dG7l5>RcfA@=K*WRWDOHX0$;5zDm@$8r@U7)_>n`CABF zV%58_Ut#%N7%+;rujBI}4Ql>Ts+gnwpb!L6){nL!gc*hb$8qrRa7R?9a6Ie|n6aedlgbk`FAq(avC9ScSyhB9PQ`4VVv~uKKGuxEpx)mrZD#Y{mPPtjmQj`DgJ6z=T7tBN(lw~sMY^L;gSFMz_Tx|95`;`Kk}i=7FA`XSUhcFvDv$w zA7R)wJ705YQMIWs?_V7QAAbX`l~AyUN=nIs%*+*=Cd__l*Sr^A8TxmN3S5+%Ltk0+ zWD@Tm)GBYgqRGfrrkvgLWqbb_aHWKTeNt2zKtjPDDgp9DM#hToraiv!-!mTn_q!UMu0`i& ztggng*H@S{y#_bPGEq^Wr6>PbkhATFPk}a(P_PHCe3@~KP=laR}q2d zv25A0GSYoO!}@+yLfNT9ujFiB_cGvm2?YnJpaf6+I4Al0x;x%lIQyM{-#6huTni^H z%)Eg2*ZuO+l8=9|tIO(o2?cwg6$E%7-~iEb-jdw-5OPZkjEcPdbU>kb?w<_>-^;_?~IH~Xxr-C z0;HTg3e)i&SU$(Ox#q)vU6vNVxAuqAm##hv!02iT1$!VsIe^FGH(*_zU5O*_nz8=T zSKj(ZJN{IZmf+Lp7N7p}*WEKwpGbGLgn~Vk1Naw!A04KMR>wR#Qv5YrU_uwfh{&ua z2v-wy&kVp0_i`AG1S9VXMCxt62>YDEW4j7ZcgsTFGs8c1JEuIu?h!#=+w!E!ZFv0)CT_dRrQejB$nV}LNL-w?#HlJT<=`Rk4pmFE-=vd zkkE0L0e+bbF3t9Y$c&`k|IY-7@5Fg2!U3kvJzXoSpYy~EnG>eMXcFV zv89wkqV_|JS!qEEP)H6)T$^WfLhW*W^(9do@xTQ@7}-jYD)W{F);K+OWYWP4O? zNB}s7fmlxi*rI_8NRkAzAl4&!t@TlKaO-*DD(w#d4545dS^lGe>egoV?WLhIA#JZ8 zDFp~iz;H~h*#Virrw~LQWfkSPlAeJ+y}CC@Cbv0i*Tn!rK41yi;3#=PUiP`GN#}Bh zPMR9oRuBBu73C-^Y@H>&O~LWKztAeed3$t?X|o4yi8rG%tqvOzGpdFr$QZ5K#N z)K`Pgy0THMuJ{qa8*Npt0t0{#3jz|G&t6V zb2SWvkoS#7%_acuy@!o_s-@&D0BGIaF)X%o{+3Ov3jxyL&5Exm84KVu+#2sdJq6w~ zYc!i|wt2+#>OG^S*W!F!%Y&1O6MJO(9p znbA`6768;L4!ycY+zsGO$N?m8HS`4JJ)_1@@4R~q9r@y2k3Ko{??m1LKwww|&bN=l z$xB)2AM2a~$?b!B_#D5Gw)|vL`f)Vkb>?E|3B`K`6Y6>4X?=VmhD?~e%!_ef*!zo<)}aIyY}q!%H(lD z?p>6d{q(iu3s2nQ>Qn=G7r@pAQ>B?Nul7*QNQ}a-pI&A?P81Q04VExDtPt}%2`KRQ zLP~cP0`n@tPtrgg+!ZhGBxvthhWzCsw(Tj#C%cUh97L`!=L8rT3HKHR;8>O$I)@1m z@8ltbi|EuV4W{+MxIEtjx+;I%UeFGzHzgz*lcCng8o6I_^Ds2+D$M;>$T=@FNbhrA#!B=rbEm6ry+%U6LGc%z$;g=%g%F037ib|`}H zzbGo_)~_dJfx?b%FnUo41rqX-hoP&q6<+3ibSUKN6S#~_`gYjL!@Y{fg~vRhEph`q z&8Qe5wmN}poS+B)v}(nw$6`w6O}_k<^~sH47=%ZJ!OhJL6&01BqG%wb=-EX9>#X+1ErlsznWnx zFMbw4MO&5&$Nhgb`S_7HcYnX?!|9JN3Uu|7KY{0QWan1o6c!>AI;h&Uoud*T+=U}0 z6)k5poCK9bRA;1~;Y$jiN87(J?UW?$sjRHmEd70S|Ia_H@0{54QJ;1#ciK36=nwq1 zcQ=G~A&oETXap4{#k9h|LjWl+C9JN6w;W1g$jRDcF35QUfqoCQEVCwIC*`;WbI+a2 zv}{N|dVI<6n}3WMch8(oEzR7h*JH~!pCPTd0&3ruIeAbjAv-He;`{^Kvl^{D8{Yy5 zm1UKDMcK2EJy6;jJ1ND2jEohTmJKOqPJJKUv(F0+O;!|U-^9NCzry71c+yG|B_v%+ z_h-GlJCX+EBPHHcO^d6S;MS0q^~Rlos?!JezZ(&k@PSt6=I{c&c{L3?cJD()1MMJ+ zA}!3X2v++C)_7{zfn?C<3&l5{!!2qDiE<0pKUlAjGjA*a03ZNKL_t&?EU4Oj_^)?+ zbcy`HUFTR2I5jH=Y88jb4vrlXEA-g=!&CeetB@L;0)dnF10e)T{f!^Mp1?AbaXDplL~Q&& zo_J4BK3`H^P;l}VS7j%FCjtBYQ5XDK{=_+!n{nQk-Oh1P&5n}Ly^l9i{o8?e_s4*< z1t9up6t6Ca@nkl-3@QVE*L37W?MArtrYaa^dt z*q-5NPj6uKjx;a=g*fvHGCK{%fIrGnn&1xMhMP>@DoFGbF|F(aY`InjPRXl>3FDJfs^Ex=g@EJ_-E}8ek5s z1jkDdRP}FjteHi*wmq_=(~y{b9bTET&w)EaU{4V#EUgTstS2tblI5dJK2`83peP$4 z;riQVbpFT;^G%OddE(&-2YnX`UAXScm-j{=s`a888X5u*cO6t53*Iby)M`{L47>o2 zFyIt6Q^m4ihy+ohAd0+#Maz^BK*ccdcGrSo7zlzW%PcSiq9hY?8nsF$=2#YlA@!D~ z*Od_+y9@f?9}U$FL=!9Tuf9y~Ij>)=evu zp*&?EI%sH0Dcl$qX0syAQKts5c;GS&^!12Si+8Oe5kgVxylvAlkoAf=!q#b<+8)o; zdLH&ihwND{+MP(Cgn(fvM8ei0n+X8INDz1tCZidJ1;r>TDuH{)wqCW{ATBYK{`-NH z6sKow^RH)q{OeCY42+EHHYvPotSjq=OQ%nw;6@hwJ={=b5P_JUEhdDVMPOVnCU56@ zh(EW+y7B0)okOF0_I@;R@NkzB zoG13}0>iR!X9;}umEZ$=f>E_i>@;0SI7~(P;L8fZdAQ!&*qC#pkS{5E1%UH!sV&D} z09}-kv9fM|)06x6JR2O@spstfd!aAW0#CH!{9NQ^UPG|IKdvw=q>!in5PrD}ec_Sh=zD4?z zM|W+5e?TC-tBoiO>u(F6M3HvTqy2Z{oZ;{03$`T62Vxd1`yVA6mEym}3GXVQ|P&q$L4L(~PO zFc#*#TXps7?=3r>CW4T^C?N~yUbt}BQIbuce)w_6&e21MO`bm8-hQLL8b-YyJ!7Ns zTTU5_I)}Uy@$d;$u{w8DT>1;dPFw;iNz_=Fx4bGV>r%7Mr};R`P-fBha~-#X1+TB( z@^M^L*s%M?51D3ff0f>d%4!45f`H(5zR;@c--jrr_+j_qAKqBCCW$AgccCBGklycF4V?hlNc>U_M(vzIdr zn|?jJ)fN@r00lw%z6?;{EJLv5Hg@#ARWvpf&&druFC) z-yIP#EsvY`$CjUOo;`Z-|8Q$29-JDl0IE{Yo>{u>n=hj0FMl)6&BL`^_`$6kQJkBN z6Z>{y$izEcT9ySBCB;bFvjHzp8w9n=xyNl$lJLn-d$SK;xV#*I^AP}B2nw8KfQ9iJ zaHOGh`PVZ)*}HB{|4wn;rnvf@5daL;RrvL%A29KOd1%X3Whp0*(WAd?+g@Cd=UB49 zwKxl4A<%Gt*n@CN*uxHD9uU09x`Xa_6Jyvk42TLt1+F4BA`=zm$H0f^;kS`R_F@r6 z_dQ@l3W+7?tjR#+qcP|-v}r=`9o5iHd#?Z*lH1`U>5l{>Vl$L zfTT9Uy^2NAgMe3XHGJo|gNn`LEKD6K7z4nT6QGa-D37W#;nSDLrCqM|YaJZa9=?8l zAS^3;BT@>3S%fH2a0(G7YtjOe1h61rE#8X6;;l&(hLDlHVF>}pa22gjAd(5Z6lHdV!MrsAXHMeD@JWT9T+4Dk|Y5V z1y#P=8kHnSq6D)jL7)I{V|M?SXdQ!ML^fL6%o2gg)~Nhxw3t}m3?hL+0`wxF7Zei# zy;S?tAOZ$SHlxKv#gzX|lmQRUYG!aSQw}C7e-{`vSWXRwRn<361y-eoPOF8RRs%P! z+Qw9H)2gAXCO+^G68a572X`%`H0L7m zwif&cjfTVvpuB72&j^(jk})@HgJ{zK;?ja@P)sRZl#y|@uRT&rLD|`Ze?0%^uX~!k z)Lj$>9N)bYBc{&4kO`9ztS^OFQQq9_YQeYvNKm2qj>@9JU^eDuzh$m0Zi}0Ue0{~l z^lj++O8N7|$6LStbazYcqiN^P!rQMM#@sy%;r>2w&rWZ4Ubawq`NAVA7Lw7>>^uxN zuAMOC+<3lKD&!oT8Rz_=%^MeGrCrXoxAXGZ)9BK@2ZoQIh)z;9sAPWykOdxH;=y@& z+udg_Ek0Ov@%(E|I)j$MI_?@GZxzr38`mvNzi{q~y`5JsoI_MXBKnWK4P6)$AT)eW z)OG9xwU7NJzviO6O;u?Z>P1p^A&Nn;hh)B`qmb6a^gJ zwH+O!V{rCh%jPPmBq3?@T0A7b-j@_>}4qkzNcK85H|uBYq%{4iUci{u+x#e{y)~yiDE#a=fgS8J*yN z)fdHEBO#Tlk^ij*n-3HG`L2M^_+s3?whZ@bufm*IfHH44oERL5_~cw9p3lXx-B@ zA6p87hMG>I6oOySX7Uydye>Iv=}*0Fxw2opq(^ zK?rf?;gtuatJOTe^uDyTA|xj}U7tF*kaYaW2fuCjamA#$kNPz?6Gxzugx@y)i0*@i zqJ3CL44*O`KYjczd`q%X<{Jo=uk+eaErH6%58mDTqax*OiHw)QF`(K*d}^~Qb~e7 z>&kXhVUG105h0M5C06VjUipF5GVsn-|(=e}JFJ9LWbGUJKG@lBQZt*$6X+PO2B zFnb;d!(impnJE6|3uF~!1A#4H>ERXM3&z~*prQ!UM6Wt?X;G0-RPY??$-&SGgb=6N zU6R<|gosYJyR+l`=-wSE9ilqF(f;wLKGf>mtj-L%nb!~$9%1#`88><~%Jv^bfqMf# zafHA-aR7>s{#t9ZXfl+T^YZ?UIxlk~rMEjf?kFLB7+E{FF*NJG{@2l?Iib;;UkVD3 zSmWXCW3AJ*lnaQAiMIyg9XI}V6m8#yT+fC{1@B&iP<(hFs95t{C+MrLn+gk`MxAKH zM5N=vIC=en?MsQ|%;Y8y;B(%jS+-&RnR1|M&o{pxKcBrWqT@?Zq3zfBd3#vvcJ^`x z;-kWpXF4DzA_U1-Zy+J6CdOz%X}RI2{U@F|a3-y&p)y2D$1|YLoj1$$B@&!IZA#=)Z69L$^g~oaB7WQWBXYAc5F8%aoUD*? zU@s$3q( zouM=z-Mf2X$EdDRcRun&*CrkdK)&x^I{hbZpFJ0)1qC>?Z4<`bH>X+gHH`XdZ2tU% zT^EiX`pDjXO364tbgKO*gZ>OyKwugx$yGy$I!`l;lP#+nDOMlp>v^(+u1*UMVL^8aRbIWeazLH z`S|$9T}P6y-gpbO@3CXy zud8Cg*b?vCzWE$sUAm%Ubc{>NvVckwc76BXoQr2pE{9{;f-!)T_aR^a0K3;?9q^E! zOJ77Q$?k1fvGwyI561ZfM{D080zesnF#_?a*~sYL4uJfMLJ2|m79%*LggrCWIK8bH zNq<%2uTwHXUudf7--swJ#`1oksq+7nXHcP5VN-S?GKvj2;iZuJ1aSBD#9NmcEDZz( zAHE7skl^Fz2C=dNm7(64G|dA;Mr2_3#=l_5`yB_$6M*)kfVk(du3W;7yp1?gco2g^ zQ!zWA!soI9g=#hSy59kBO*?3_iqQS)6_jN~pd!5X&oHYMFzC=VWcdbx;eo({N>q4h zaWNqn5D35mVPA{L=;wo?M8`kj9z_7R+a06oks__(>i41pC*sELmXxVy|JuMJidBw>wHH0gxK;rjQfcS<-Kl69ENB2ncbU z7fT3;8sN?Lm;cMl>j|_R1CB}-VPU)FQAq-UR7Wqkb~<7Sbfz5RFfWV5EV0j45)ep= zZmhkAwAQ`>_Lc%L3K9qr>hH7BhNXfTtWE3>YLk{ys(4OQFf3DZzBV7SM>ks&#LR}7 zwN#H~7^pZ-(IU1Ze*k$bQVQ66J+;(H5UEXYw>t6*L>3aUC6O)UElU`vRVsLUc_J|( z7CN2QPAT>=Cpr0ovuVGLkJmWiBf1}wwCKT$7h6RmsU$yl&7tj^26yS+V^&P>ey#ct zb>_ftpp>HL(2)QDH%~8&m@)(Ve)=BO>E}Uv4R11`&|G-M^@QR2HHi9Zux_m{`)ex5 ztuPkmuLO{4yS*v>zouI^XM~ko)c+<^_5Ra;>|Yh#qt`QoC*0YpLe7VGY(>W|UC}AN zI{<)XIgFZiH#U9#5j<|D!Q>YJM%y;p(Yg-da1ZYSL+%ZzyjovM!H}JmBa{^{1yIZD zDI?*j&APq}2E+BUf9zio-*50|@%;vPIeQ$X6omyxm3>2?nff8N81_q_e0NETkd zzT%?O6$G&1v-dx3-!Wpu=o$A+0|1l3fa=N$1V_|J5(kEaqEARW{FYYg}E#AIq84ZP1}@lw<HIC&vHHs&gTp(G z8b52!!-No2l$LFwVRgStjy&$V1sYaK6JW>ji;#&kz{(kT#z1rKKOCRkDbE;M?F4c?8Af*6qQv%#j)`7 zsv&Lye7$fzuL$K;dU$)dL6Rue?LPA9r$6o5*;xJ$r7Us!yw`MJ>BM={{SxIC&P#c^ zx#vyK9@xKZ%a|*8{2ol`_VmmH|e30Qi>xxw_?!klfbeZ+68w&`>=3aI(-sxeFrqTE_>FkO*?sD z|9{{>I$>_gGfubP>V%a}JTTGy49HUtBtP2{ITiD@%KDrw#559 znRuTx6$iI&#PlZ?xs-T6_4_{apTF+=QD0H9yMbg*_XhxHoT7FDSOlQeC1VzLy}07b zGu?drJFA}YIzy0Hb`5H+2~{2%P`4mdbEN+0%I@~wE9oii+VYts096P)QC;!x-42h@+oq`?G3hZ2e5r^njygIf5N0LM=*{~7! z#i%hWvo{K3Jka?_8U6|j0JXW+1d|GkNa2oZWU(C)C1xPKO90vxR>3=6KuL)&itm#k z6lqY`kxyk7!K+z>UMfdvIESj0Rfrj-0n_{iY~V@>+8r^XWE4$1mYXtm!vR=H$9fk} zr>IWw^7Mk5V`cwF<%$-FtT8JA5U2!}5-?It^{GUm;W*h778agN4pJs-;Yx~kqlJvM z$So*}3wHQGz~WsiFFzNkVv+=2lE705Jf#pM2?7;i7DbpP31&%xsg{W_N+L{>2$RUm z>FO9SO5jELSY8rq%A#`Kf@Cp4{uBgAq6kS4>>3pXfJ)#%!B7fTF^0-P#4N@E(6TI4 zgt2-rs~A$tEc(M72sjW~x&m^@jM^p>ud+cgTE}WUmL*E;nn)FIRLK9+IwnzhpEV7L zOpFtY$$6Lr5hmWO7%!WdhneSL;>|FaP0$;S;CbF^0?$Jbc<=%bGjE38Xo8s+APBN| ztHlIC1TRPsMG2BfA&T;M(XvgErl6J+27x5mwu|BwP8Fh9vV2F4Oo&Yy(c*neQO_jE zZOaRy)hiuJzM%5Nh*qmXXh<-+#kZWma29o@AW|tI6CX@Y9@ARntpaoUg>$cL{pz!G z<;4v;oiquB**B4N;s{1hzqgi_T4Y=Tq7!?fgPRKc)i%`WCj|b(#z8bxfjS7N*IbB( zY8bLJc8mH-S8C>6CWK6Ah5n~G*U~@O^ZlAb+1FZUnKl5V{&gCK**7rg_DQw2`v-ME z-_hd`q*H-jK5KUZ##Qj?I}{**WNux_6LVQHZ_K-~N-!E5ldWh8E>nuzGcw*B(^T?S zf&SEK-zbbL#$uhesA*X{W47e6)SK6>HkA#{w6LEWHp@%;v(Q%Ep8 zZl<=%HN(1l!ZWr9L_@XH#~8A%{$b3$;cDrCOO(>_85wVmX)1ZEfFA#4;{uC>z?BPs zAao1e()`E@SfBm176GzWd zN^vti4fb>j69*1K495fJh9xq!9XdiA7%Y?6#kp&%ucWwI5AY%Z#;toWc}z>mTMIte zyyZU!&R#rADaECXo9NcL{tA#@F_AcXIRlhZ>^Xk!bJ=QwdM2`<=xX)zcBrkUOiDj4mz5B+-9;&M_%j~Bpv8v_y#yn2qsfrW*Lx4Mv9*M(@8gyPf9 z;CTX~r`vVS=)kz*Xgu_tO#I>HcszOADcoxQH{6zTBd*FggwGOxg(uIih0$<7UYeeO z`|eId_Nor-Yr6vL6K{sGI+%Dg$P%ov(KvGD7_^Sj`qd^MG$UgTh1_IB)7>1LF#^PV z3Zc=zZPIZW@#}e{?-F4yG@&Eg1ot=vZNCiB89G4c3>zaM{-8b zl4d`$8}6WDdT*SOnSuC(cyJu&mpIU*KLJ8~WR(g{CzRDILMb3{9E=3<;wO{5gqW)OvL3yJV&9;?EX*LHk^roh$qW{nc@+V`5r88Ee4k(-5C%M9z(OZP z2?LJNgD_foL@R><0Yl&q1kCIEVsvrdP+F;4Xv6ji%V>nA9$u1@>Qjbg!3%=^8G!;o z1_=mF7D1*e6n$RpbDRjMzP)e%z1C5^p_7r`@DaPZhHLMCYQVbQ^%ZFIGF72a6*AQ_ zv=s`-Dj=&A9z}&HYesh(ajN=4p$ZgLfzu;Gk`*Yb3Pn{RE8fruT3J@$7A5WPz|cQa z6h$waLg}R~tmtKVb(S@fR_zm-4l&iY)9b1P=o70dsN!AbZI1z=Z%-8!iY$Xr>I;Ty zZHi}E#73Jiv1lyPQb%YAehBE72rD7v$8LjR>LX{)jFcEq_31-j{$|Vj@3!{mwUH(>UaSBE@@>A88hZ0_YqYOe#mh>m7B zAS{REdCQzRTa4EFRYe2Tize`j{CwwfFF1ahUr7l5$_Fpc*kcy-SEa=kB9Rz zYB9H=wZ1lF#uXt1OK-ayS*!}u+TUot!6Bw-3i$ZMur!Fpj@D+;+V&p+hJS$w4GX38 z2T4g?(`##A9M*9^{^ge~JJ)~oe8rJNQvQU=2xa6%7zWo}zZ^;3trxw)#a}iLP!+4o zZvGK~$oBU6VFB=TgxVbdpsT9NcI1oCesXf}PIqAl5*yIk)wMU>f~3y+i#CF|X>$RB zHnpSqxk%KnA6Ni9-JF*){ey=~w?(qxs;VyAx*bP;vSt5C&t($}L#{&z!K}%J`2650 z$C|ANf6&<2IE-AILBRsx>AV#8^oL8IiP-nLP348yiK3j)GcRQpobEiWTws1g-`$X z=Guy5$427b7>F(k^8LJI*NjI>pN-`4gWYc5ba?xg4^Qmb84=^Pj+SPeKJX=$-F06d zBR*abu=Mu3vH!D8uysZ5Jpcd>ZC-~NaSG;73qQ%{tI9gOy=mw6s>arEBtM3NE&_b7 zy&W?quf~oDmRnzOXy30tUHMjIiTAxbp(-+FE)FK%7v6B|h!XFc-g>RN{Me!YM6V3! z5kMD!?*fHlZP0C=_` z7f-ZKMB@Vvlz(W0>DngbaK8`fqp67y+rR4lLMx0TYk6q3duCtSw2XdN2xS zSHuPlN*6OJ7@bn>F5-~1l1J7m3WfDQLs}l@AudnT{vZ@}|0|;X-O$o}@z*p0uh-z{ zA7XLgXAHPI%{aHIM>={HEq>tpU47&+`aG#7B_$vwH5r`1YlJP;h(Co=sQU19NmhNt z8KoMjDR7$BYqZe_g;KaZ9uNRL&uJQ@0qM0W)iP*hMd?e31qFPP2#j7vs9=4hs%DPH zFr@z=-gyQL(Zl;U!+>R2tqj6~AuI@CH8}}}^$peMI1UCu055Rh1-?%R0uO=bVK5rN z@jN(=1?vkAEXRT2IIuhiR^UN67L+0W=tTr8pil^)GDHtR_632$XrFn>T?K&31P9fF zuv9bbVgW{Hz$xS3pGE@vBbdq7>IX(Aq5+?|myZC}4ZA#w96;~}hnM_yNwS_rt%VFd z^v^|AGk5cm&w-)W7y5Z6I-wpE4Dp%fF@%6Hy+W5b0MVo@ylo_K9foKOzTSV)C%|ai zdyj{2TUHB(V<8v>B&Q^zcEywNK8$`#F9B7KNpNfEW7Jo#IQhAby-9Rp>Pp1b`lKfS(>R?1mJ0F>Jqy< zeuMrslZFa~0Y>{_=PQ|8PM8nzq=LI{@L zemA0d4)Luukb5E`^Ar{gX_<%_KUE`fBLHXpg&I$H$8(5~R#gBLLdfepFBjF;{`UWl zAAchv=Q~`3t?KeKh>1_^_Z$MioMqP_KPeu@hLHY1g9e|Jis<|zC?5BK>$#fhPCJ`w ze~ie!;41)L6GUS+Njkkup?#Cu1 zV#16PoZNeH6FEvLHof)Qu|uD4eikE_H7J9SzYvL(IAAx;~>?yvP`nk12EJVb{9Vh(y8)0Mwo>hqLqmR$Lpt{6%+< z6Tkc0hSCFHo%=a}@Q22P2N@K9B|y=XHTcU&w0pbVzUlDR%^#kOz&j%Vv^O{5^novN zWv@}2z{nEsdp53hp4_+dEm@WiM6}>w$N>HVpa{TUff2b5^@|ln=kC8C8@4x1jYSKW zjPak^kYIM=e67FJj)6wIL@5lWB$#mD)D&#E&xA)!8AyD`iTwYin7F$gxo2$1tnNYT z4_XmDRlDSwrgS0INO4t`4YOXfAn$|?bN?|JkB_?%`BUG3%0;30bTcZZWT0`(#T8mS zX>kxNsfeETD)#(hC9W~9M)%Ge@$2qf{8ji4T8+6Vy)q5+`Gc6|K83V5V!1eLc!O`n7ad>tS_CK3}^HW1y4_JU}C1AS&B@U>4RYb*03>41K^SIH03okT5 zU1~?&hfZ`pD5GKd1-O2cA5@fjeN)ls=rR_mPAW-Mo&~2-v{j zSOy%c5$YVvY36pmAijBxtY^V6tVT$qS9nQk!UXJDH?Y(4u=R%|0#${-EeAeV>M72W zq(G(q9A(*?!aOSHa6Jw{o+y%+wM#<7;1Fjbn zpMZro+=?WD1#|A?=t?QfoCn5WgyJ4vGNGr_>=rv(Ux6e=It^eqKufBtfBR%*j3TNMM|<+t&+L< zc>s}oYTvC;TJmsd>38m{9N4UAD5yVQv3=XBzrAa2tnW89CD15tAQVh4#-s`35#Lf3 zk>3m>7!f~ne*aPml)_n8wN*4XkA!r-NAi1%`?hWQ{?-rvRyoj0PP+|f4(`M3E3fW%9hT)V@46fD z<)(EQD8tn4bf97TYTUng8d4MEFl}5OzBoE?=I(`tHg)CZz3)`iG>nuK(Jrc@qhQ77JaeEh+VmfG5IOeTklod7Na@I8!N zN7cn3{ae9_}Sm{al?!0D41XZ zpXCOn3My}i16w9Q{`DAe@gll%IYeEfy;CvKT0gXstRnmJ8hGkrk!z2|ub2M_BxxpC zHUXl6MSE)KTQT1jz~3kgEY8CCj?wJoJF%E1F2j@L$XipFD79hZZu|moBXI1qpk-@(3!V53- zUf6B5;j7c7usfU@$wmOe2Aei%S&JH>MnJ&voR*=g4`-JZZJ0d6FfbVf-;j1d8}>p~ z>eI0ElC^z@sB7hThqu!{#H}`!6^#t^E)QN0T2Kl}QT>tu0Ym$J(f|S51=dLo8Zxg- z3-~fcwe2J|Aj4GEWd#V}mKC^U8E#pDTc5gQ32t4lS0)5bS%y=R^bp|?B{(E4>>dxS z4hQTW5j~<74pCo6pE@N8E?Gg3q^~21a7fl;BYmc)YsA0eZu3S%FKGG}AfKSF%Bq=>TL^?Ug~zfMtnB z>M{fzr?o#2su{8os}dbY4ay=}z%x2CbIQ0kYa z@J=aw^_CSSAiG=JFUK-47zCuHCgI8}7GV0c$$`D*zxu^5ei6}L@7vPTO)4RK9w{w- zW@CH%=xGc1;p{NC*2toJ$+Y>46WBo-jJcf-Z29}!xZ>73k(zaJ_w=m%LNr#LgWP3? zg|gsc!`F=(4j7IH7ngvZb7#Pr`ZseK2vk+zIA3~L>}dNofQyd<4+A%+rkWUF_rqmn z&unUMZ;M2k7lGW>*7}vh*1crf{Ke^lF?@4AKpU#IcjH=IcmE?WU4)1NfaJ_9ba%AF z(`AOm=?0rPI&vh0VPH(pfvx-mxTxsT$zaRlZrWc0Pj$^`57sEQkTf&YGIv zJ!`e@AF=Z-%W}8mc6DbJjJql=J0~a=jZ*59I|=6;8cik`1Od&ZC*h1u2H}RucMt+& zdJY`t%fRr#j<8gg&{K2vZBKjaOT*iVhC4DcVyLR_e7LOa*^&Nzwbs=h^0?g#W-MBg z-}^e+QdfhHrbf)r%^fd>+_B?Pd-Nc>9Zt}=aC|Wa1|OdYvAqq7%hAU~(%sfnEw$A@ zsCYaP>o`hDSrh}{i<+9>JvS2V{Prim_r!G%Jn|Ec=fnD8Up8wNzF4;gT;{+XvO-eo zBt9m#-G1)O(c#qZ){Kl806QKjEq!i-**s$H?t!2D?3c^#_|^)B3Gco=bM|cPT=y~9 zjNAdQi9%v(J|CAX*(**Ci)fp6OIi$Ju>He_OMhCrVdRd37r%Y#-e0Y_X~{!u2uY1l zn2?t>!DtZdJCBw|G!yHVw5wtmu-hLledebd%-cufz7ECX>GC+8;+P2&mnCOp_IV@q zj-0vt+T}3C4gA~{9UBX~#R6-G8L3&Jld+Gjdk;^{$wf+n_B=HvBL!a^DMfm6JmO4! zv%x*0grC0h;r7+r4}KRBmY#ZYB4R+Wed-$g^wkQC%JBw(mfGrriYQ(&ec=_kp?-s{ z^|ffJtHEVg4BSx)0NDlOuxH~ZD4aYMY>0boM@zH%(Vzb3^|Qy0yb_Vh2jJ$^t6~X5 zK7XY2*->k+0HDfpoy}^Aj!#OuJb%)Z{_WxWL1Wc<9N+x~Zg}W12!?^5WeFk3%qzg| z^{bIHwg{%Uuzg4SV9&=Zu{fFH>N!)w-{yD){nPuOeq7nm@>@hGd-|!Vh#@Mr7O%zg zquB199qny3vd4YJwE2q@2m8+G#r`du008r@zp395NdSy6gyIz9bk@_U|8IVn(@)tdaMy81|Ei- z9yrRAabS5qIwu)WC^n;0jt8H90p?eCBRRhYuy`=$tOeG%6!awf&$00wfzUu8j?wzQ z%zKt&S@S1Ia-4wOz~ZaiPvArgO6J8OE!6<~sqHvniHAjg2zN@`vEF(&V&7+wP?Lb{ zm;V6AXZyf>(G2^H8aPcngajv?hjSq0T0whXRVcuB5J=e+Cgea0F|d-ARm54{Xw412 zMtEQax4an4ZIcnj?*y|y1CF_Nh*8>iGgrH>dTdtJfX@;k30y^0as2p6SS{U9bkbD? zpr{nu!;D5!@hl60)3P8LXxX?PNrvjxw*`ff7r^rzWLe9=gsQ?L$(m$=p6lrQM*@bn zg8(|YrwvypeTKPv=Ru$odm5p~1Z8Xz-)9`pfa4f&9IKIkzIi=Z5;Ax_ynhRfrmf3) zgCXDA8NQ^Qd(O^J=(I4?f0r5ry;td9UD)_@FAkL^y4FX~X z0kQf%V*7+vAK%}CfLKARYm7mk3fgBzmO~WJ!6fi72?9)lcb-Qy&m&sUb&@$2MxKL# z=V0VD{bcXFz_MTo1A*fp@Ein=gMri9n>NqE!1E9|&Uftl1jE9>abOw77hc_C|1wt3 z*42XbX6|~!n|%xPZmsYxRTLGXB>OrCyyj*M!y-C53ggBW;FcS&MN(o=uX)4?-1TO2 z$40X`A_g8qg(}N+wyv(|gp`!a^CwOo)I-#c)gK})Cl}M^FA8gY!Z64flaKQ!4nyoP zLr%#88KisiP{GG1LGHFdvb2M_$irSJxEpI)#ny)JtBMl7K-@*JvAw;0LwoyZpZ~6I zOQ($xvUu|B%S{74JOx6LC4Bb&yO_RkNl3Gt{*YZb4i`=xg{Qp@u9!ry#_%#0h6~mh z1wsg14K-k+`X62#5|qMObFR|W((o7%xd-E}uKn#6%f3h$fm{@wtu3XF?(TxA^B0x` z4zE6Qa32yWrussm1c8d8FF;4t|Me8M7PBX7fg~c|_aYvU?s_bmK#h z{V66sA?%wO!?MWBNX5bZ`@yHA_rD?`;1iQeRF>>@)tn#li|(0?X7ia1=CecHelYm< zEz1^t@1E=blo)3U`*?6Hi>#EySysD!&*}5^O_8e0M)MBy2J`k&`QCx(XlXv_?r}_+ zHgD0?-kr0hhYuh&Arbi#!y}zC#^mGJuI)(6&P8u|j;iB_FjZ{8yvg~#WrPrn&&$LI zTfRieq_OBtqQ9|jN9|kdcdzJixgvI)y?C_(ZLgMN)Q>j+kJDx;k4a2ko5%aX*8L@8w@zQV=E?>%tp8! zUxBDNdI-{)J^0?Oi@}9SUbc2x@!VhDKf32cMMN_)UnxV|E9Dqi7iR=8T;jczTme1#EMn)I z(UKPjLyv?f)_SmHNheI77s68=3+`Ssk~LDG(G6H5Y?# zUx?^t21bh$@fCF-MgxR&E27gjBetgo^##cQ0fZtuqW7mkEDRWVMghhF$a)@;YOy2M zoe57=a6T4g2o#<`A{^9!90A4!*zA>POaBU%slbH&RWR@_w2q5GN2BNdr}E1;UF>{> zByd@V#fcMNp{30Xk0gO1M3*zrNG*=jWD{71(a2MV0bv-Ov|@bZmP#pjo&(3Sn%=FR z9V@FUIF8kHNp&$%5+VSAFf>TN*85rDJXr09->>d1O8|}mSOUT_x<09%JK(36d`4cfZU`1+45nv9%Zd^#X`uK+QvAy#MGZC-Q#8XcB|ri} zQWSV(O`}%wEmz@@6}UuM%Sa9-p`a*mNiy7$?Au>Zef7GEvI1GvWC?u6WO{hBbU}%> zEaWlPg$xMsXIuxGwyA;H)qt0E4K^s#riy<2gMXENlRZ(Aed`c-+ad#j=a85fkGZpF zV(H>}=+(OzaRT>Jfy35)%5JgD8aHjm_)sQfp-^$`Flx`11c~f)p#5AqJV_bD{>>1Ug^-j2XU#birUui=?n=KC_wF9ubm_@9*jtpvt zmoOaN)>Af%rDWXH8RG{_yl?sY+gNzhtw_rb@7>R6GJz8W9R1?+;SlfYhByDZrtw16 zZ!mI3rI#eEO-dV+LJr?OIsTsc_a*bMu5Q7)jTY2dDau<^Y;7c1U!kJep~;e_CiH-R zG8@*EXz-E(!L8ujEqg~)+6|FG|Fq~uHnyw@eL0c}@nhX2?h@ZG!Su8Iotc26uT69B<@9wi?j0Km}ze>Jw7XQIU^?^fu)D zR6uko1N#;JM>-k>5P^q6J$;0;T+sqZ4+E;_PVkKcYCNFo$_$dgL5U(r`&|@jW;&mK zwCLPh;hc+*1TN2WI9FMP+S+=EqNtO%6f7ZN85RbP^_hSXLZCoJw84NFqYqQ+mV5W1 zP=9&;U#ge9)w0q(lH@;DUIks2fzfD0PIe}4xNaE=^84IezOe)@0I|KPvDD@4Svq~e z6)C(hFxh3ZbYaKp4{*&r4Qn zr@%$Wgf+CD$`X32%D)sl%})UsEywDShHC9>KVi367EQT)eol1Ezz?I^P_^y2{((nf z7(zB+Tv9Sbw;T4B23UI>V3P;P{)!|BfiWWowzA`34N+l{V2aBDNA=kavd!`WE>Qw! z5O6u|JvB)gnb&6K7npXeS%oWZy>m$CkT)2Rn4FBd;|I}WN*WX)9ukCTS)u1k0f0K| z&c7sfnBN&*q5piCn;Vb096cq|7A&4nceVnGqF~}>vxihxcEMOQmz{#8vkPj%@a0E1 zQ!M13ZYXvO+~(%9j@J77AW5U=FgQ%y^TTJKzv`}gzde)}H~_e8_8jb5zZy*XMI;20 zQuFz^1ed+yt9?VQ>qz3k??3a>g5@{gG?-49Kun!66JKsz3!0WQAfd;{C1whSSc9$f zSVUduBaL4^cHc{PT|IBe$D=4Wb4+4v4FCDTQ(x;2I~_ePr@b{jJMWsz{DLS|QLyuq zkFfZrJ79Ql2 zXgqkqfQIwu#dUA|`Ni6@(lsMc^-Be9c8f(c7^4Mz&g9SrfT6H)&oSw>Pqw|&(AxP5zCInL z;Xv#d3i1BQY9ys+U}l(dQeLEG=c1wVEIL}6heW)u{GVSRD?NPRDMZ#=;cEl6S*@F} zJgW5X|LDBC-7E#&C>Nxu=x`Irdh0yi#bWt2xj?J}SF`|oyb+xZ0{-|nfB(_H7fWFB zSD@)h0~!-t$l2vW(nDzw8)J00dVo3=xa(pej88(6)PynTENEO11GkAox>-fhkp!fd z*CVD@hB4QL@~d5e)O0`Go%d5dwy1wJh1*!`pq?y;|Bl!!o_f z^OC7rB`BqEdo;pW2_OX(H8><$@@b>?30=FD68|!pQb?eXL3Pbs-4u>xp%4acS%q6s z;Zju1EKTwLt-$6HVe@!==4cLCfm08MtiYwHa4Qrt2;924n!A_rTHxOvl|tiBgEV@tdfsP@x-@5pOoL77F0YaMt8B zpr1?l=Nah6W5K>GUOrZDJUVq9*g*gv5gbSgtG#q@RT`KTtSt{V*7LRv6^g25miscp z8BL#;=Q+g2m@sKV5pG(36{7n-pnj7HTmWdZby;L%RMdj;Gx~psqN<9mAH0jAX){qY z{jwqLh!BFTfFO+;S)k(f-}WJb-N&%Tf!Qe?5w}g;A(Ao0;*g!3e_7; z^mMhfHL8lVWa_+yas81Z9+wNBz5h1mFTWWXWAcZ*v+TmLs6Sf{vAq>Nf(dN&MSW%> z0>)qj8x;j-^*ON7{R`UzTHAJ9s5k)hKnuU+F*ko3|2*@7h@!izquOb=rbr%f{)Cw& zWH{$AF*OZ6ZOu4;^pL{kj%9|TEgT4j=fMaDbe}wM($!GC0$=|OH~>)E+FA|}MY_Re zu_Q0P<#sSb%$_9-gRJ~QoZr6_T`Ehtn7H8`Z~(@P9N5p6%FddqA1HR~!QqxST3B}H zJ&SI9=<%0h6B7rof1`t8S>&Z9s|ODpkolDK{#jr`z{Mraq71jkRaeU?K7v4mfio2mk{uYNhK^RoO0Bhy(BZ^zkB!cJHC6* zwZAe&8HRN{@-kB|b9%(Dj+I|HAIbXtGhl6Ruk5jPXBE$#H>dRQ0g_uZ0U3GuLn_bM$JDW7@bbr7%ir9%`$1WjEkmln*8_^( z+H223?Mx zQoGeMaZJ&KsVQ06{od#7Rtr8~wGvm~egB|GwRpiB42Vxk#+UzCj|nqpg(Y!uV%K(5 zY+Z+++waTFKMd^L39y>Mv6 z`}#Nj(spR;r_YFP_u)b9^c#lqJ+5;~GN~g1xz)?N{AQ+%H|EJW(Z%4LO2790g`)J{%>6r<%w@ofZ*NTBL1s&K6XVk$-X6Fm6n zW*k4sqBib&+&r!fP4&^px)5yN5Vwa#%uxRntW47@(g-d_*RR!xUM*u%QM7rD#q&qdP?3_$ zvI3{1PkV(!mNf%4S%zDdwf*WQV_I2iP~AKV4Vc&D6MXfNHTeXOtU%O13k*q7eMWAg zqCnB5Gy=(SS)tmxa-gI_FoCXR+G`+1msMBK`=e5^QHG*O)jd{AVsb|2oZN8}LOxOLUcUzMDJfwYaSQ~8VUeDj zhYQCK!PVXhnlT1sh?#VQg^-vEx49XL-3mtNpa1c+Hg>t&8lIt|__ZOn!hy?b=_;Bz zXT`j0Zy2`V^q6rIaPX6lWSgw8hSbbq*G))Ff$Xqb9Ouj41K=KZftLVex7%hgM&EYF zcfMZ`j#1n|h%&{1Q5AaNAM0QmH-!xMH$w;mLwY9Mtqlh}=H^4gDs1#%eCV0~{CMot z>4n2BC^;>I*lQ{)&Xt~Nakn(I_7_rDyH&EZ&u}$VuZqMMh!9LGe)?albH)}8dk8~J zd^~YA)YhH;@{3AmZDqZ)wz45qxEgDkr7rV$S4;isNPK|^!}R;7?_WKsAZOUeBR1N| zvkWuwgU`PF8@>T#Sxas8L0d=1b&2U2nI%iE8dh1^1>>;&;}4K&tHlFLW?XcAmSvEh z6pxozZ}n{6fAR-)&E{{^{WKJuPG_gn)-82gx~^Mt`(4b%jN%4DbZjhaT^-oA>b<5T zySClqaX2DoFnI|>>1t~|*<-O@F?IgJ%-*`ofcBpL`KpyDoIG{NqguR3Oie>qTMKH+ zOEI>1U`3wx<|b5Z_&XLAW#DXW6G|ps{5B*?GG2IdZS}fcN4}@3>OVzacr@U0^qjF< zt&_%#pD-;Yb710q+p3kg`dbf#O}_TVP>A=VJGV(&Kls~Q=EjD<;G2~JJtWWu^(!`u zu|go%@eJ_jI0cgvD304waHvg_*G`r=e0re{bthF6PhlX$@mT#%J6gJ&zH&ZoWRRZj zK0X=iHNJ52DUp3u}VGa(x;<(fdyiW ze{icB1H>F);mM~+*#h(=$G}z0!D9mQi;NJ>r*YDL7YG-Hf+P#_51kK6D5VY_@8sT( zWq&Wl7^VfRnV?Hd1G~H(&eXoIxiku(0>F3xsy8Xdsm+Tf7KNFQLJ>^p(S7e2Ct&yk z-Fm}+oxTTyY*YO*CRte-h)amqBnWhQ096xd)krl;{l;SeJfaM@NAl^Ws``*}uN;Dx z>y#B$Ulv+I!8@;MulhAoRW(=(Ri*)Ytg-@0mLW+pJb@w08mXwL5G6fiEhI&s1}y8H zZL7&N=!BgLsEXoC;iUfbO`T9ifV2RCR|(js=?gCrtYs?;EFWaJ#RUY2uvaIAM;GidXE&NA?2n6eB3qsaV|4j1_3FF379%%(vUNzz5x)c zzB>8B`Zr!aW$WrY(xkn)38xS4!z)I(jY;s9lZn}!g5Gid>tg4 zRqI&@0af(CS%2XR*=GIys8wwAL7QqW{Bg^B?|#`_bD__Nl_!tG+*pr=%WsLu&Qdb7 zF!!3}NaX}RZ*r}_jZk^K8vu^Y%HY$jkb@lS!U3>3? z5pj>>4F>$%|NDg?o;?Z47MY}~2o$!oj*kB@T;V%D)#N&MX93Bqq4G~zfe7%xuU&uH7>2=;DxiIwkaaV zgHnpKwM_>Bh{LbeB>^`;JPWSBdDsORqM|V8s%sHz2>+R{FgqQS3UXAZ%Qa*(z^@zJ zE{C~j>U1?ZefS-lGZrm{U@$7(X0ts4Rr|W2uKe)6UvGK;offM0eJ(%sLg!ZFuds zb?DmDh2!V7KBScBXsnzQgU50S8jn~pZ)YvCs%)6Hu^p-unl~W|5VbZ2{O7SqypRo7 zcM1w!8xSkk!CF}7Ra^*yZJC0E%`CbXQFvyk=nhD>ziyrkWA(fEhpPlVM2^P1hw;w4!MS)ul`)8a zoSgXddFEyep-uIhfy?t8PM;}5OLGfUSq7zk*#lM|z7Cy`1T^hXp5uImX9`t8h(_8m zMElVJ0QBMJ{TYsF#GN)|zBf4+7%a}CYQZ9fLWf=mN0MLi+dx=c%abbyeJb0D?&vD>5whw{GvO4+6YTNWa zhJo{Zh-1qI?vr>)RYtF;UMAxwSvBLj5JqyuAB1Q`I0FPNXNg8a`%LOUd=ecj%lPL> zKz+alZNm_qFb|yXuW!Pa@vXI6((5DNe2^YP-!fE6wd`9;gS3sk=4J8mv6xys5!YRN zCHT-id*ApBTpgCqj`mKLVHQo9JulXqi7ZPJwyb;$mtC=J&>BPoA*Zki)n`t^Wp0Ki zE=6;w9|f>cCJ;*DY^?2T=0YhPHRr0_E%lEBxTJ>AjsV=|#)fmE+r4!9g2hSRUTuf1 z8{0lwiDh@*i@}%_Tnrgw^3hgb3uj9sY>WUdcKC)^;eg?JaB&IfIbW*j9|wS{3LNK4 z4~reGkK-FQ)NR`33;*+hXMXljVrqKCdZpqLlE5i4PVU@>=&_RrWr!9EgykTlWQ-TP zTB^j(_VNf-^Ph#x>+WCi_Od(g%^U7<@q!S7iPL9d|N7OCjVAE%Ny9GFkeV6qv2~1d z)}CLBOJBNzN{Z(|cEPyYlF~8~hEvd|AFOOScCIReumihTiXCnLu$3MEAuciEvZtl{ z%dDb;<*C`Z;kzS+z`K9^UG0UA?tF5Q-fGd@{I0#?bl4hiqYZPr^UFzNGnbFa7=&9? z2y8oi=ID?9{LzC>r}G;@;7*;p;Q5E1`_Fq5(;{=-k55j)`T7Olz@O0&Rd~^H*`a{N5cisQSwfC*aj>L7J5Q4%fQ{$U!sxq3Yt2W^hyAF*ML{Y4? zb#`W^kI5^^$}jZw7<9BWWADbbxbFT(Fx*isUa%a8)a)GWUcVY+i>HV51~~ZXI*b#W zare^M;5iO?nWvOjc8ktg6c;!5|lT& za88+oJgE`x=+K$llm++}0?HAnx-ATk7%<@B;cdu$HwxUdT@7a|Xvr_^$A|R0?w7!2 zSr+w;ji{=ug4^SPqWU#(p=aXqoJN3B5C}YnD2@do1hS%nVHi+V1<$b{l!EGHnWCz} zS*Zxrxb;$IUIVURV$SP*uxF<{1VI zL$qyl`36?&ouT9ls-3Km_Poc+ZPJ zqc})rRx1MT#Z7x+&*-(J#RJ1%`C4Yb+>$Rp6+)uui@++bQZ1PIZx z%6qLBSZA+1NXYL3uY5u;{?$w18U&=JrQ({amtfMwqW)^}uR`EL_IS?rSgpBfx%nlT z`2`FB?BB8p05ES5PR8MY~Z7f-TdeiFBZ>T5OJ2gaN=ZC z?B9)!j!qae!*dfJ2wY68L6wwZdwu06kfg6GiOwy&;g+}W`{A=ohhh{r5Cnq}c?AX7 zyLJ_#3MLHyH$w=FnPUn>n^pF-HtvZ`Ek_P5)z#g`sF=bFaYf>&7Rj@ zeZ@wM(E~bfDo$sk%UpAh+}(Z2>0ozsG`S4M=nG?~PP^S0Z5onreEEqZJ!>|7$}oaq zKp}G3ZYj4`)!z@%e#w$=O&uLB1J6~@nmqQlm}ujWjz?WfyY014c09K4MCm1|^E+7N z42lO%5{{oOj@tnifos*V5W|sGz5%3f5*FW$mqDO#u zA6GmBg0XMX&+ZLtojcdAddb$=@j*m(`VGXXQ|i`#yF03&P`1x7l`>d9qX#i21>2kb z@84-gihqA919y5XD5@;Lg8F#Gq;-Q&_CR0&!mCh?z!z6fMEn{fnC|}H-K|^WqRae{*SGjH`wN~i!O1V)|*%dv1vl4b@b z%DSE`fsxn9QwpldA?R6)ni&-Q#GI}ftC4ZKKCSnYAOk7g@QMMz1nA-hmE<>?0)qgS zPX$p`T@OLqhoUHOxh2T55+u_Qq^GL{5Uc@)SAm+m1Qe`~-R?zV5^V{~Ffj1ECT|d6 z#O5==(n)QosxR9#NZP;`EO>?m$8x@5{JsoT@82w=XSc#fe*4Ycpc}je(2@b`5S=*p z>NPM#&$1>fePpv zw!!=I)hiT<>-|a~1CoZm<`h8L`u?YYLN(&P?@&7emgQiIjz-bgeB65Tb%>4a_nqcn zhQI|tt)1U`CT-eW@);fe(4wB8HIP0q3lpQ^0XNb|O+r@yj1QUF8;{2ec5Us-k*Y8h_}lIUgCliV;B7nUfb1Qqoh#&$w*f zV0Gwa(S!f~+4D7uF=os_>rq+qxLO(?m)feo8dhaT0mmw;FJz=7q|Plax||tgyO3lB zZ*SQ3-!HD*@b?j_-e@C!;Z3)%y!G4PnLHE|t%1NWETXasaA3za%%6}G);2NGMx-Rh z7M`tZzR+y$DvM}^E)h(;Z1&^ddip0%XXY0~{JNi-l_NN8-IHr7%Rlot9N%OkxIj2N z&22T3=w32y{^Eqg+dhM$$e6$U=7=Vbc#)M~h>GKfA$dGLqh7bufxYj%jHj=ehA|nz znyp1+GO*`(1w>g!VYXj>n^KBb*KV_}+P43fHizr;h*$K|2DNsyAGddP&Y#qqcwe*> zW5!R6=+0u|6X13_LlW<`XUnnrIh`s1cyinpUkBY!pFS zXBiHhPeNw$7{r-8$UasJVv_ND(=OJ2oTq;fIXg$hJsi`8y)=~ z6DEYA8C9WFD)w>Te(9`vILEtR0$1CKiX%r(z;3gH5)}*u6kWrXVHgmG0i_x-sp?v= z(NRV%8|IY)A?u%sstPf%Ed6g$ z)pUL(RW}k-6>U4+7|d%9<}>5cm&sHQ=zptvy?WPK^=lA&WCb2cGbfXD!!kJ_Bt?N+ zlp)EAmbt9@P0AG2zm6m+P!+HCaPLrcHkbsE?0R;tN;TsFqq(t0bi0=}R#nC?y7@MwWse-umRV4Urpj}0HrK-u6$>_cz~rEafiW1t3Id$9 zRbY+La8{o!cegcu8^FJUaYP{G&X(rWU9GKG*}A$?mOuDt#D=PcLP};fY+aqOH`l>N z8L)AQ|DV0@4vd?;-+$gA>4x{-Gx3O%5V9vE5CS2D5LTfijIzrpqZA5-?v^e(el4Yi ze%n$?Y1u2RK*CH&$lk+__ujsJlHT7R(hWO_W3YX;15bFlJDsHWBkAreJ$l~f8MeN{ zK^TLQl!~5x+reZ7j`DpU`r4Xr!O1nmlT2H*_?N4{^Sul0(J{m3D{Hk!Au%o%8(x12 zw!+dug&G0|DXgTV7pWa>P2QG(=L@cS>W`099cXOHB_}X%_ck{^ z-Lr4o_Xk(y@MFhE>(`e|o4GJOH?LnJwlDthgNF_@di=#F3Jmo%*Z*Z$;R5tt+Uy|e02d>uU z#v_`lE}T4fLEOf-*Fe`)%w0M>#Cv*PKK5+d2-WB7MZ7=t>!0o2vTp5{N&!6>{Pji8 z%k#dLH=ia;c^NI8`1@goS89yYq+8F6Le#bvJh9D&{CRP3%-11rS0L?@VV`IWQ1Tp! zf#a1-^vu%1xQ@(A_akm$J?sJ-pp?;{{->Q&4KCGED|9U@KreH%LFtRD1@k0fJTm z2v>6o2%#UPJOv>j)M(7CEdUWTKrjer!yndA%?e@=x#Xy3EbsUGdszr*eTZpe{nUIN zQn0FhtOqnRY|gMDKv4A>RJEGN%m}4JZ^f$?T3*v}%z(Eb!K>;}H4#=%XdcZZl2ujj zO~`72_YGyXsv4FP+HnY6AxQ8J%uyB#BJ`y(>@j*1ui*`*`nIo8M7Tx6Q4oQLz)b?( z>@%QZHdMWoF<31Mva&L;Z0TZTXJ_{J-TSf;xX^XI%GJ|-&YW|W7fe0vjA0{!0OO=6 zBd-95w|t78`dW~T{6P~!1BINJ0#8E?+%<6?mtgL&MpL%2RR~w5Gd(6IciU5l&7KQjiIS>_|V*3?V(I5FPJ!S zr7bFYKtC82dv`gW{@-&NkuCiWDfc_O5BsZXzV3H*jfLPKO{Z)}LFt5xqGIC)^gaJ{ z-P+c--v2O~NOHg9y!~D6TRWSpuS8Fee`rb_esp$rs#IdTCXdU#Fd@LGoB;bOYa9Ra z{Msvam)A57cYTpS-h>G&F23=OhYBZ79@gLenoE&6104NKWul(mFx7;;*IDhxKBqOV!D8H`!kh7__`eYBq3c}gddC=$aTz$a} zw?wCA=MHOM7P}o>lCb%`w*d(Fwy(!+D^CYM&i%e3cu763;lKz~V~t7=tuTdPe~{c{_uDy3ytUJH4ca!qJ}cz^MK$QfS@TU0dOc;Se$!M-Q_>9OvU>?*eGC2k(9u zi@5j#e3sRWzv?!qoqHiG1pn^>8PN_eqFa2ZDoOw-;Fzaj-e0RQzNrq$-A;7HZ4Y z06A?Ex5s2%bu-+I_VKL^JKl^KpFc_BK}(6=A!?y;G)n0)ZX}olJPG@p1)3Sk79j3* zO$2Xb7@s|39?lq|qmA&gWlPV5#nSJ^@RyFj<($u-b@sW}UU1zv6BzF|^JPe2wMRi# zEZFqwbE?~~5^Gl8u#(0>5CTg^4!U-I*5+-jxf3Us8gsyiNlg6ulFP2V^7NIL*oNbd zd0%izMsj*4K795me`jkmjT$$BoJbiqRIsFF!c}>&(^GfkHvq;0VKYz|AzGJQo)?K@ zNC-jcsnhV`^Z$Vs6+a}QbV^D_yuYh8&sBB!d5nRJ{ox3T>kl#U34qs)?eDLHy|5I6 z{mxJ>L5fW%_O`X`^mnw3`kNUQdv=t^C#NNjpK|Kl6WN2PsvkeT?>ptH#oq7T1)=%< zuEx5X-L;1{4Qa8%i0XZN8lq$4SkaVei%<0T+3j@dzxv6KYlPL_?=TwO>+SZ}S6<<( zt*#i-Vk3Z^2P*3mVxrmXN#hqEk9Y~dT z_TT;3#6+fPYUz=K`#x}Wbu|okf1?3OnVHw0clC8kr=PJTB6s#vva(TiU>~-={0x4w zdI^%_`X7OopOJ#?2P;wE(t%e$+|u;I+E4Fw`+OTCQR`@iv%Bk%&+Wc?<&C#QrDT1s z0TG`YR(ljUm$2#Gw;*((zx>3XpR21l{8NnnVAfHE#%iCdy2}6VN!*3jRV25@*#TBf1Gm?G6Zw0I}%Up)Z5~=_I7Q zR1M1qKunhlnnQ-;vlM7u3Su%kFd_W_VkHM0+maFWDMQMqKFDkAkexc@3>PHoM|`sf zjd{oT9_oO{P7$9Zp=QT+tku4W-CG}nnzRr|n2H$39^94H1zFe8l4VD$Ee4vMKyV;2 zw;8;|fgR_@!|j*QvSSvk1xI?Xp8#?TLw&dF{M*Ovdv~bzbH4;GAp}iLE!ey706ZQq ze5z(NO$P-aOAH<(lt3Z`3;-2?M2y$rBrgjntc4MP7ur^0HVV#2(6^T}28l69oI&Qs zqtPfh=TIcce9eus@446ouk(Oa2QcCiMxx)74F{{xPGjiD!h)|6 zMic;8WKr-$atfRl51u^WMz@3E)PEPllf=++t%~kNI%;RxQFx>UF+CnwK9%w5vTW2R z$SC@;Aw-YvKKgW0?UbQ)Dd_nu8M;#fp#m1g3)h|m=x&Z}3o_u?n2Ox}ov5E?gKF!2 zk4&l~(9N%BevSug-}FGlPX{WV0HVjiJ>d~tX?YLc3?EvOqTseD@I@InbvrE4@a#xN z!oOn>`&*7@x>mxMt06TdacU};iP5<6 z$hbkc27QTx&9s3q)zC(`UHJQkvN|v=Jcun6g%)zd)lBc(a1vUg1QMgLDiYFCk}zpP z@vwOGjA4+R@x|X+e$DlB({l$uEc$bGObC`=eLc<3%s|@*Z$kG)?mX3&H(rXFGW#1m zI(|XKIvpLb7Ehh=qYG}hWl~gZT*Ny+ZTW>{+O+9t|8yPH?#_tyD<>o)an2dbENPin zM6Ac2ym3hPR*pZ+%UtBj<#^ zw;e6-JNE5(c*rY^EVO^T`u6QR4^3#oZnz64$4xtwOr3G<`PbaABGSM6 zPdZ$(6Z_qinD;#=-K?bL;5 zJQT@(M*#7qGv@qw#dSB2lZGKQxj)!rVsYB)8}XO7x5DW@@wG=>v>i8HbQVd9jfw{_ zJYE4~2%PgdljqF8>GTyBMeO@c2*JXYmmncEl>ms058Fu!|91ao^yn88UHGn>$+6M0Cb$cwzqk+mr9zX`PSb?N}akxK8MBA%*X!=_TvLBm-#GV-VEXO|- z!pGp)k_>N;4TS56{bo6mzqt=eZVx<_(a89Lg5KG@hNN9K*Bz-C1?*M9Ff_muBxMZDuTWWv00BaG5e@ev` zWh$y;(xKM&4qBfHy_5STwfeRQP=FOjNMMrxle0~+Gro$pJfEo&1N*M?t zP*oL_QG={CeL@4uM$HVI3RoGCfDJ%+0|6nze2tJNY%hab5>ns7pwt3qOadf0U4?)j z;hwI#;qeOH)itQ92Cv`W+lw|>mq9FoQm8;M{LB{!IMYQa^h`Gb&wPQP zGjl$lIn8HI>m8uhyLojDJ~PzJuL<~c0iULsfoNvaGLP|XZT>$^X_X0VxY3_{Zl z-(4d-&950Ayuh&>6awBD279lYa|Jza&E+ViVcxdk0c7EXZ0JTo?@LPKg%s`yCx z(1t@+EXc~u$L4p|z}@43EpJ@J`nIHHMY|hn#(SIUUd9+uq74O-GBa;oe%1BYO+RBv zWY3mOP{vSDG6CD(eG46R)v%A7a8$72a6wK^SN!d*MXu_@Zvz-Bo~uV8DJiLF$*ODq zH0SJP!y2O1A4*P{ijA*42M?Da#U&1UeM(|#w7;iqytCrKa{xx0A7?~@;`)Qt9)-9l zJ2tL)8MbkygZ|DC#vmo8mU!FSD*bJZyN0ODVMF!)y$$y0SgmC0j3tcoUdO=ea*2n3 z`2A{OwfAeDsQY|wZ$s5L{0(*chPT?`Lw!X>M^sEqPtoM5%OpkV^&x0$Zub8155H?8 z7JFKM>(Jb;HeX%k*Zn=6^}}23@Z(T*b4Rq*=9o2U{4zzBdhL&nZin~r=hxl*uh-X~ z6vOzHn3!=(FI)Y`dCOJ|TZmSFNGd4Cnpa-Mf})J$`h|vrGlsH)ti1hI^(e1x8jB;H z$h0%g{Ke{f9vrryxc*>^jv*GCy{NA8@Q%*r=0S(*j6#s?qLK$Myz#cLl}?`(8R=~w z#3!eqrl}Rxdv{`HN!|(PPfv=6u8WMlN9wvedYoTo3x&jqGv_|G>YfLt#U>?3v}0MZ zAU(ezuKK{fjMj$w*D?Ce7sm|rI=y022@X7XXUfIC{1`&2CH(jwjrey;Gv;)~;NP|; zyk66a%ls74Jrq7&hG%0Ue0yWzf4BkdOPb)(;}P|S7qa7M%7n%GAp8{mB;d#sUc|o1 zq3@1DR9Pzs6Yw041#t!bY!k>e6d9g2G|p3?+W?8Fn7z3ImQD@XbsgAItKoxvJ#eUL zK1fKCV`#-K=&L7ssC(4lEY7!?Sh$cExQ zXkQT6g?)Kh7~x|iNXL>e^<&`u0D))vz@m>gZrJ<*n+2mU5+s7d{Zn;fkgS4)lYM4y zraU;{ZORw}V-gtWM>R^RK?<5y4gnI`Aag?=!9v&J^ZViV`{7en_%$E=en0%G3cspC z)l?9OATdbHbhiMZ9UwBfIn+N8=tfLm*8o{gP35e_LgXS3Ors1kGc63v{U?svkH$a4 z@_-q>vCL4L2CNNaMxk&9nR77Hl0atMuqI%}bjf_q7zJY-vcw^C2@01WOA-`Gf+ER~ zB^eTzAag0~kwfM(WOH85I3&V?77Lt*tPohBA2WWAn)TZ)Rw%LzizGvlWmpv%c8diz zMS(?@VUZqkG5H1RSflTwAF$ro5g&zBFbh#jLizG#foUV4bf3ih_>6I z$O^0$1yOc8k`m%^_Bm%@Tw&fozI$I50ylf=X^Z}}>e~;LSfipwtcZlvG(c0a%Uv@^@)$DCQ8H;V-u=%% zpyU>T4z?CTU`fl)*Sfo?r?FCL&pQ6654wj6; z`_1vFXbGxsg4$U1vg&q^`o#FXn>T!#Q#4^(PEl_QfnVK!&z^P_WhYXddYWo~?KrgO z@nJ180@$}@)ArQt-0=lvlO_j76A2;k23GS8L8iWF3BMAsW|ZIN0?GD zFhOcUY!sCkE8csgep72__i>fdqY;q`it7)V`GvNon(EU1TQLD%&$e-rErfaDYv zKXl>E-@3G9+RPK*$r%R3C#OQ!wXEtx`<%}1?hPYR!^wiiLt<~~%^CGE$g^_(`iqGhQ2qY%Ha7L9lK;ml?zKGXwtC?ED$y5P$M+(iOX zD*+hLbDj@*t9HSb)`Lzp2F=XBzYp0&eM9*cx4DiAxP2|UIRIo%0wWeghb^&w-< z5ip{mJ;@HQg(JJF1C`?vv43J3l)@;uT{`xDv<+n1pMdKB0ICzvy>PnRm}$#KT$vy7 zZ7%4PLX#-yRy!(pOv1rC?4UQ-qOf2$0HCWy{qGH_yKWe+{d&SXQnD-~D=PzBmcTiK z5Qc)3PywH=K@kF+07B@HxCEbH1Eq$1QBzeg&cV46&;=oaL~8FL=7ueUE_z?<67)8J z(ILQu5gQg-oCN<*%up+z&>;vtdf;Bz%2WtwVbenXyx|21P{G2&vJfPX!x61Wri%Dz z=$a13D57NEt6IuJe@qAn2&IrrWio_eQ4t=J1v4~DktHz70Mlc(?@kh?y+pvGO*aGO z`fj74lt!;@5-|E@)Uc8Op&=`Qu;V2FsHzIDs>A2kjQ}{42q(k{o(rgpon8&PuA9EH z3%p{);iw%$8P;5g07K;qZSg&n20@tV!8mEiUop}=4pF{+r^o;fTRDZDcz=uUs zH3*@@uWH76ByI+m0T70dbHJN9d}{-*bRi&V#v=f5&Y=qdMhR?IEAsPmFrl({}WnFl!`GM_;n9f!pEOU_Yy zoHx7cDt;T0PKOYa<}CQmMK|4c=4d#EnfZlSwsa|8`|xcfpSfbt0b9%-MdD{JxZd5- z^tPw+@cN;ta?nVdxp>Kgr_4Y7#8-C13_=LLanE=0y<2aDx495X%HV}~aZ~4(xErb; zaeut_av1l`M>F&fUj6U4()05s6_!oT1%P*7ezC5+wIiF!{f}t%ceHNo*}LsW5vg+c zA>RAffA7c|Up%FB+Kh<+@a*G%u4q$55jnwCgSV~erS5|}9*sni5rp{5v+M4dP>^-X zyiHbQcWr<4)mQHw>B5EzlV;EV&IQ-ra+bw5vTg*K$2D&ee?$l*rzK%JT~kRM-9F{Vn@0 z$JqHy4+#{-wsiWUC09&8i?T7#dI;k(ok)Gkj_UIjBwo^jgHw}maPc^l?ruP0Y6G~c zLrU_XJ|P49OH(oRvl>(uB*HH<94t*mT)h`9=^AWKAI``lc-CDDQS~%P>3tB}?lLw) zsCaI#A3tw$pe;EHy6L9n9!KE0(1q3cFQPsw7VWU3r&V3|_ANWFz%cq)45#ag2F*%MhDDK&CP)bk z63-;ZWV-@F2~?jCnx=tLW)6!th)1F8hKDYr&~*Vx3YG5n`-7&Xgb+A=hEmvOj{>C( zT;j0W?VyxG=sMg^CsfsM5_YCHZ?LSu1)_l0=Y^)JpoBov4F}b(u5S4J{=ghvT@cY#u!41=rAsivH6DE;r2@;wCs{&P3;dHr!^Xua1-a*A6tSe;w)PuL6lsfJM}}iB?zX;oG#%rgwc#=gx?9It0kf%bR`1#h2Zf zSulQNuXw_+^s-ghzHx)rdSEAsE;(h;za_SUlBD=aGk@7od3Z5^kyeGW`RA?p?fF;V zctJ&lcb0`Nqr%wfm={hQi8dgaA?GV=1C>uhZk z?|$$RA@=BgZE;kWv&P%dc+&X6hGWaYgRRf4+kD@+?9^wyK2`ni+Z*pZaGn`Ex28njU^}-R2uH z`oo{-yz?&j%>~!pa_UIfiuFZId;-q9`i6_U+M3tx`|PtPN4lON052??^w5fL+&Cj4 zwO_ZFh#@^UA2l-;<1ep$f_pDJ%MiNtgK^nuxaE>_PH$@Kx@Ui7{mBxLI1pq{nmh0N z%dQ$7#QTctzgbvUarh^@KmFuON2Cum{(fckFO%ol;?6oV;k(m!MZ?j+u&1*KX^C~% zGb&<931w8M`Ai$4MOKLWUG0RXnPF4TI;ps?!Tb}6wASOi0NtOao$Zq%#N zfe+twocrvv!z)-A(6=KqGXrt4v1o5;gGvYlAHf+an-6^b7zcK?0Km$UlUe$Ljhym z0d=r|fNuKvl7I)R*+)R_O8`UN8t|y?LyGDqQ%HmWGYRj&3i|E`MhPgP2oQ)Nl2Jf6 zNlQ*yFVdTY?T5hT6O(NXR3gIIN)aF;bR*i))iQtZf;A6$Q35Z z4d|Nb+pC-Jnfpc4gGVE@KE1aRJDdm(D1UqXnG5V=Q^89K1tp<<5LkV$^$=p#VUosS z^Yq^K5P2WIKZJQ~bxjXnz_6KM42ohwYFY|r&z}BOcv%RgWi#j9wdC^E38QJBr03@2 zqN~4we?ImnILh}TYFt@F`X!trWzl)l{p~G3bC&PB4r6m@{c)iv_OoZ6an@Bc7oRh# zf)`@q6L7_?ci;~{dJvu4Hz0m`g!1GFLE^l#@;wdJzxM6fb`gNFaG@VNWx*K{4^uf2 z7~{C*!5`5deCwM#TI#EZ#8+AKd1I{^IX`jNSKmGq>-(Z8nL7Qt<=?pJ{E-NX>kkvA z&m^bMm|FMV8~^Lz_Lw2LiV_gl0r&{OsQ1Ht>2Hrcm6kv5tPel@V6twDKBeE8g@CuI z;pgtU!zZ0z;hLxZ_GW5c&J*vg`(Tl<*d{~k=R954b#F`E_dQKjMwJaXFk7Y^PtWr)Bf2}R3S;cxFeg*(rmGoWSC660|5 zMQ2}9-`w%`r+W@RH_Rmt3L_O1*B{De&WW0F=DGJBIdteFPghsPNY^tM#3UwOHuv1~ zFPJ!I{>ZcAVVHK-Ie4>tFW&uZ56+r7@r3iQTr^YJytjOHL(5z1x}4s(BT(W>Ni5>jr_KQ{YOp?GKErMl< zhR)emlxz@?>s)ZDPGlqi0YU!0tby$FV0&3Mq@*O&-3Lf+H@M3NSFw(S=Vj#HDZzQS z1x~vRTdN9cH7>1XpN5j1-C$^g&!V9^I~7h#3}Wp)Q2&*N>Z&BfcQ?TIV~#(xM4=$z z67=v?O#A20(W9EDyzV-P+Lu7a-3YPkLEK!V;r#5wcx%rB%*YE7xPk-i8Foa)TamcE zwave&dd5HQ9sZm713EEJPD(^_LINsT6(}JvVw?nQl5s7?C?~+tG!jE%v8pTz&s`)Ym_7c4+fDP2yir2DF3!&SlPWpNRvP&E&Tv2GGZg7%i;28dz=<~s^u z?5PNBOm7KoFZ+l-WrWW|P1W(Sx(TX!iQ$ghXA^t%b}a2LfUp}6$NJ4CAdJCgx1%6G z54qWq@!1>$h$=dD`cE#n{^l}Ubj(QCaunvByBvGBeTI!2*TIsO4IUMl8s)?kB+OcP zf!5RWj;Fcy-x29FGDx2|XU_MRUwcy)8>CuqI8Zu$7S3LIAzpg^1=z9+phU5w^G}~J8joRIate{5r#rejQpgb85z@RKP4oL3hoZK@ zASp9*d45URs7z2Voi-!=?X~Y&py^3Nu|Cb=IDoM;`arCG{^h%yyBg2(GuCf>IMIpb zD&O~7qza2P);#{`1MRv#o>1Dq%7RkW*U+#(LS>B@9(nfN`)X@zPnsLBQx`7&(aIZd zn>X5i_meWR(3pJ+KHhT#^UCrEw9MjJlj1h)I{3p~N9sRzxm*pyT;dmkB{sHT&N<8O zE}AkeG9F%^1Ls_ERcY1!J->PX<>xQK*cBO+OrAaeJ4-IVGI=zKM*!ny^xR9X!qbmE zjMBVxWTo^!Vv{q5JHNgxbJyXT@4xxUwmksqB2($eASN;KvU$r^Tu?T9-l!tpXPeruoa=q8t{nkj=GuH9zLlxhg_p_+D@$)(^pZsY%>JLtaZKnj1QH+|uc0%rK z$AjZ5@aGi{bhoD?^8pLC)OzsO#~X0TRjDA0n^6CP7r)J`!6n{goW7$ScDE0zPk|#U z3o%+HbZ{{E!Gs6Ss3_!DHUNG*v=$D>mSi;D2ppM|iUTj!Vzu6mZ1NO@?G&g#I1{gb zvJD@s?SRiGfP=pU&Uhb|ia){H-G-Y!_2F*14Kb5b(4F0EY!CzVEGycr7WY;bTYCS! zEfEpy42ZzBTCK=PO@_=FJd}V50!5ZVi2x-6L;xx^tP~if&@|2PNcF4msYjpl^-_gG zKZz3;1D4I`o0_YO$LrC^sAt4kx4JVS1=Kcbf4aX+!0(}dE zyw&?3DJFD-3`S^^!>cigM0)f{?f}7PS_E*$z$gt7n_)C|V18W}ph1c7(M22Ntq8MH zKp!GAKxKyQ=RS<72v{QY+LrKnOyXP+9B=ml0g@MCjCNQdL6NQDf7^>b7hwu$Vt5DB z!1e?e4pSr(8Vq|2U-wZTkYMUvc#-Dk%Cveo>a#=%BuPR-LL5$+JOMV_$a_YP2BhWY z-?ZdwtCkd$O&;k|jtRy%zIM~?D8J)ow60%+)N?OIq=vD@Oqw3+syckXr@8iH0F@Ex zba=t@ipw56|GJx|C#H@_aP@$2&ev9B-`1@-^!^&8UvMR;JS0NS6T+4^UWz?s_SL@D z*0)r5&&Ltz^b4ZBzJ9~n|NZ;Fg_EY-I9k*X0lf6YW6n06*`=76!C#RH0e4;18@`r? zUkyQNgTnp|AK$(9*{4gEuDWJ)_>P!xJ01ATuO4nwGICNt2LIdW@9OAOyE^Uy&^Gw$ zB7?)*K5PN-^hnn+(r9XGast>s(shg$)YjIzN4kcggkn+RB}ExsOqU5cDjJUNngP#G z2tl;XDn(0@)pg?8M+7lZQPK9;xKVl2j&li;Vu=DUstB~t0c-Kp89%z=awIIS!Ty~Guv+#) zOBHDF_;7kT!8JY)Ham4(GGQ-fM#UhlMS^t~Md#HT-q_uagPrXtt@9x>0ccP%5NC=( zDO5nH@W~9H%+H6-<;TLchoJc^AhL#x-^L`*+x~bO%7U;=9kS#NwM}s1_dppp_`XbI>{Q{?iV(L~0+h zAN=44KRD4$gb*}0HDk}-{cwA{pcIf8H3>EfT>!Ey8UCx94$ZV42!uri`L!@bW-o=O z-b-(Kls;WRKnv2eMiV9}8ss7cASfVc82K3PBM`7SAQXxsfir3-hY2zKQNx=V#1(vx z^lpq&!xBN)L&N-!)y%?7O>1y}1$y6ln*74wSx!PRaomy^b*}{a>v{560d*q&PwYNZuqmn%64}nnqa8&Mp z!rRjDhoPwLD}05oFm$LreCQ*_*qM`N&(9c5f5W@m+t9xL1zf#o%7CrOHts&;e)QQl zf3W9B?K{I<-WP_mr>Du)+0MsJKJ~QNq~uX`lKjqppQ>E@?7y$_IGv+Xy?i1hWoF*G z{Hp7(n|{WU$lRg-f=J2A!QKOh;cco$S^kMfgcW3_(vBWy?w%vnRZf?8cLYj|G_1v^ zPW!_ZcYk+bT29_b*K$l)?NNwJO3FC0e{XD8Ys;HB34Pup4E+zUYOl<;&RN8mKkM1D zLwK^wiM?JO4rW{yALt@zYnSn+Q^f(B8-+zyO#WIlNDc6RA2*<`%7-(H%kbTe?TBr) zBYkZlV*D+Tk~|>XAOM*rP1j($ za*%|PnA9W=K>(eG5usuK0&-IUKsPL8jjxqBx)A_G5a^nKuIkWL9YPZjnt-kf2vq=@ z05ly$HpAW;SjXHXc2%ve}6-)9U8=ZLac z5N)+Wkt8Ub_i7f&eB{P*7S6+(6nZXkNR&b*1Qv7I@IEERAae$rBn9WUNZg#4K{4Ow zVf8EKa>g`bkeg=k93^1{Ff*Pr8alQh2u?GI)KE|xqXe9BgM4MZ30KZoh(u-7B(=>x z2nky!0cQjfWssOzN1ykZNz4X_YbmU8LLd>-cp>mvK!~Vj#OOOQJ`S^HPR0EBGr?H@ zcT)S{WF&ACC(fMv*s6Q(pBkH#JkqtC5NSDiaJDvM&qwQF%N-A9jf^OQS*)P8s2opo zLz~vqHI|c2$4y_j_z#!gac_ZQ9sTO_*n~vL635ne-vCcchZH*`eBcQ|7>AOamhEY( zv->;S-i%16UmPAsPshIa#N?$pMJ3TAU5uux`2Nk;G^vT{DMO)>S6wcjyXNqN-uAXp z<0seJP`}ONa-DL@ywfH~%E(`LZg}f;?_2M_=ab?RKGz+|gdo zSDNeVK65!7Gp5Wxy-1SfkuC=SP`Pi9_m#i><>yrg_PspPwR{msk~C}fl4TFCyz$m_ zE{&Rdp~nOv1ZjmucyrC0C{2k%Qe6M1T7(cx8kb|+aj2?rZ$;fYjG>V%1A#%j-!STl z_tflM>gwsqtvR^A#^Z91dN2Pm0ADR>ee=Ti#WDMNoZUrLvE$$*^>ZyYbrnhOSZ$vE7Aqp(@U{q z21RR1G)Q$CylXj9msWtD!=(>Q! znc-Wji=e78^hm-~uLP8Z2t3A2C8hbCGeb>D7y;u9%p?qr_lzb5r%})Vxfe#H8VXes zR9Hg5BxgenLV%cxQA7P{#Get$y*Wg!;rm8wrO@pdw zrYc&8>Q{{*G1I<47a@KdFkbsr9ez!RUlUMu0aX+5Yr64VH;$<$M2I6dIrM-NLLe3` zU@1&Yk6L2-9uPvzWlWVaH5&;LxP(#=YJ5h52--pzSeex}=mRBm9j@}d&v_baAHdNAeMS;` zYfaV1gtD{CX3j|&NflgodmDc7-EX(?wCv=geVsl(eC^FGuKJ1_b&u!Z5R~^7zQR`+ z26VT!l)GKd)RJj4X4_+8NBr;kuC=dYS-L<`R_cJ}7ee4?e}8f3W6!;P6@aect!_x5 zH8s_LqR5tWN~g^n5|8o0!0mM4U%&k6%bVYO>pK|bLcHe| zmDnl|>?y1{bnv7j(nkWdZg-CwN7i5a?Tiag0gWn}EaQ*or^DUGvAx9s07$f1k(|Yl zyViooHrJ!GT}84Y@TUa{&`X_2O9eJGcHuFp70cTa5yx%tHrruIa6?bFqANKUTTY9E zO5Dh;Xa|YvMv9{YUC9=-|FIY;6YIcb6)mZ~Z=^7jJtkh*mui>IHF>FgU0j zHc8Q-mv67W40{S;ZmXv2&~?oSNDK6>=}^sSLYRFE9h%V1=SFQlRW;`C(~P=}bs76C zuwMoG{?mizwdnOakXfdg+YW?VON5>Wjw0=284(C0Bc`ndGgZEn^;Tmu8nCr6$>8Ar zGSuLKI6MIYLKq0;VWh0Fe$dcsN;wE+#&nZhCuTE9a}AoQBu8*NC@5#J+ifVDP>l1I zodwGPRRUo+sR&#}u`OG;@{;?{zT&F*(K7UUAdnRcGIR5=>CIQ*(*bKngo2m}fi*ol z(brg)?`>&(31jSJEIB>vmh-N;{`whbo^2WFT0RdbV<;#s!J)7jbM+7y8jhZ}Ka zv*!MJ)fgk*Q!=yDs`l?qZEI>cX^8ZZgw~|BoOOBP#)S)_E?Z#}QiB|W1}DeH@^+j( zejM((w-9i9@$2`hp_^x>nK3bVyT*a;Bc1q`y&DS(CL-e#3A1vuari|Q@zbi&^UU&r2-Ci6nGDZ&P?GtcYZ1CHSL1Tp_ zR!~nJ4mC~%jV;4#n_k1@cp%=>dfSYPcK+W;?Y99FxQsD0)Hh=PfrIe+e6U*-=z55B zB&H{n7o-8_NVKMIoR= zzz-c7bO^KQFxG4Q3x7w1$lYKX7QzTR1XY^7-!or>gb3&GtgkQxuY7_;X7A}jh@hV< z30oHpKAL1DF>C@XiV~(K?%gEQZh;e+&ne`vCYhEDGNa}^h8kHmmzNoX!YC9TZoj~w za0UxAEFO&4A^QiJ8L#Dly+UxFkSbc{43fkkaSoYt$db`GgZWAjQPzdRrU({;rM>BGT#5;MBQG&->-d8*j@P?RU(N1$%T1;^Pyr>CIQc zV&WkuM8@uePzFnCR=TILCduE?`Wi-;3bZfO?xy-pN>udH@sm$Yh;-*Zj|V@z_4-DU zl9fh=AVf=ZbUR$tm3L}Aoe>}AG*EQ5H0^VAb`?yTJ#U)TJ|yl1p9^dL{SU{+ox2H- zjvYLKECigD2iLl5kKBT>n`ZtMzQUIYzOJ^G?NPDu=N6PriXDjpRKFj4o_!p5o-_4? zio^gKT06u;e|`4<)@|PN+hHzm$kEZ%xXanoT{?Nr{K-m$EWG++_r{NV-g@R=_cT^l zjp~rq<3UmE=bXM`<%8$0{zd|&V`A`MFJu%JW8J#+^;nw{} zHUJotUd1LzX8!o^U3Bwpmz7Q*Tf}=}S~_%H_hpwrpi_3230b28wgXF6)8&rRMj z`*7FSylyYuxDVLg-i@!#NJ8p}4~-^-b75Eek144y4w1 zqk3Evy!PJlG^La5m=fKC=UZ>WBJmc^k8SvA)@^t=()%eK114|*pvU3B)@?iBa=YPE zRcM+HT^EoU10fW;Fm$dy)fl>e6v9-DdLW1_j2sm-FoUU5r38WqfFY>B43Kp}b*D+J zfm73dArNR~26_b==Z5tHH7poH0bnc`S|xMV%L?HrvXmP0$R=^hnd$v%z89K@LtzF1 zDs#hQHb8J1%^*o_k_4;7gCwbyGgu`Kt0ck3IcyS#U6Emxq#y~am`!E`3Zt-uH**~p zDd4TkV3mw!;S^TRVV5P?WeGM(f=!lSlR4~)G0iGTut^+NSqeB{?)LxyAOJ~3K~&aa zlOX%GmZfQ$H26~==Gd4aK?`! zb&Y0DXAH6=L1xA}B_7toUrSPO-Hb6Kl#Eg^ZU&Sw9(+z21u-8fH|7m~NdlyD;E^*} zEDAES(y{XVrASWtLj1JVy8fq#vmvdByQH*53)*tTwc3Zty#4*J(=r5wsR5&X3|I6E4H=-w7 z13`Ud`A0(Niy|E&*Hm4JKmOvU9a3uckPPSbwKUXtYiq93{GR%uSl?Ip3SVLP;p*vW zbal2%BNec<<&|gf_0m{mr3~zxTGcds@6l&Id1}oE*8%VhZ*{{0QG58%N0jk1C(oIe z9%=iW?)El3{m3t#-tp1;pJR02P(B{grz|-A&sW@Y{{(x?h}?4+G#KZI&CJ7^mtMxa zl5AL&{@tP^&QO$-p1A8!O>R|V%j+1MpL>INzwn~(EnRg@;#eBB89>hXVx{&-d11w# zof`psb)GW>c<05|LrdqmDz13XxALRbE&>2Y{0{7`b>g6-cmA`YP@Fd}2M4OUu%m;b zaE1-YN`ZTl7pJ^YiRLna=FDi=w=%r`Vh`S_ap2$E86NHO;<Haa4DqHJgP|?vPFW$BEc%l zu*g!dS!D?}MTS)|!oN6}sW@f95HMMiAcuv4Nv7)62)_z7*$mYRsZUw3StJg{4E<7M z2^NXNYEHAt5|lnISesd|O_pI*WZ29Ws9%u{!c{g2Tba{fAeTWP8_#7*48oXmlWYwT ztHv}dXRymM?6QO?B}CrZ&Gkpg66}f$i%A$8#BT3qS0pGB2WQOOR+G3jx7#3@8FU!O zFyKYZ`ZPi)RDqCf0!SbAEHf<>3|j+wjK+h+uSvL?YTbaff}y}Q$mEdiLYVae4J>0= zDiBj?O-v75VtV2V0Z<+yfEhPPUs;h66%~bvWhGd;WD)om8)AG?5V$dkiK~`ew)*zd zR$LS{ni7mZFBs>@FDk~SH(r6u?Sd`4AYy%6(z9bdjdkO_&Gj#1bf1iojNHQeFTCm2 z%gbiY8GF*(Fc3meIAJ2TzxNJWsw)sRuI!7b=)Vw@lys}Vy`|J$Q?Uj>XGA*vf*6T_ zt|HMbO>JS1{{Pi@5(SLLBA0k}^%^T@-~)zNh*Atm+fobkmG8493l8h&{5 zwGF09T~? z9YXND;h_-KnGvGC3Cj zy1O*gxqQ8662R3rr(@z=3)a8W0U?0W@fMu+gdN^9y&zpWSiB$3Xa$MCvm)1T!G}}* z$Xjeh!Ul>;#fy9^!9rLeB^j68@f|L3O-E;}{kR0K&UEDLRbT$oH}74IQEiPBbioZKO^*sC8y|dw|X8}7Z(m@14r1#zlp_c&Zy=POl?@syr{+OA~h8oCbHyh^Z zV`MWspU>w#Gs*7EYu=yNyD`($-9N)1NXN-pzZ|PrAFxW_vbd>d7#J7^Izqq^B4_y$ z1{@*aK)@0}M+gjxt%06xnmNqEQ_%D*q}FH=K|nw$Q9NTA5U8R%k^o7h?&5GxmlJ{@${x%f z)*UR%A|j$A?z;VE^zPN;TL1RigMiz2#4UGx`QURecQXX}#kSF_gm;caXmBu&Y+egp zbUbw7oqRGb!|9-picNAsW% z)iD{3Io5`T_Zd<(YsfIe^SznCjZNj6X{&@2Pe|+ht`yc8M z$jKurUAp%``k|u;bDGdS;mUrneNy7Ng7WH=V`uVC3X+uXgAlz1*R9{cDSv$a<=>_B z?H|x5El=;JL)?H!%|R+UQr;%+*{({!|*LS_lmwis>!`fB^-elKh$|CC!Lj{z{^vQV>m9Ai0Zoflxs8-Bray$njCgCc0{2 zE?I1pf941S0$ChXYkrX?|531zgrW%MN!3|n5f3YRFsdeBm$BWizvd$3vlp){IeuM66F}x z(W+n~=S=Y&cAMSG3Nt|EeO337Nb>IkQTk*l1*0r11Lzn6ND?GbE~@9Y#|43o z;Sgd7Lbv23-21yb5#HgNlcWM&zzyzw!|<>F^70##;<~2zI~K2z)Uy}LGS4FSa2mpT z_6Om7lYye^(21eE(4DU+J}Elwxjq^6>gY0f+=TBRe&yf&LwzJ{`+}H+L^#bRoZh(w z!O1%vK$!_2@Bt(yd?r>0hsRHv|WM@(3W$I*v~1 ziM1!zZix=|L%z$Pi7bO$StYd2*B){NLxmDRMektfABB=nt0zI0(#b_ zNl^-<9}JU2NB)25W5Ag@t)?K3b8 z58oY+ltU);uPa1Imk*$;D8x^@OR(`^177UqgqaP+nA&2LT6nA}CwQ)p2z@6PT$Lf< z!g%{z1+l?c>eIwK9vx9I2u1dfqgrKgr4jHF2V7EB{ zDvM|=%RmrCS)>I3Dhprgly!BAJ0Xmc(Fs77K;1tx?y2mmAW9%IN~R=~tVzfP(L^ez zc1QpuLLpEJUJ&3CcsO}w5d^rD*LIgnUU(NA>c70a>Ue6l76R5Crgo06`Mnf+H`A z5JkC&8dU^Ok*bB)Bt>8q-PxHsrEr#-y~;36i=HtAAdtWTAc|-#3yJc-s=&-p2^^yw z2`UTGETLcluu4B1fl^pZ&VJ^IET*#ra+WSptqfSVjR4g1qF4y9%KJe&wz24$Vilnl zMbojeD9;fz7Dr=bO9wrph}x0_o5KZ2lDsc!N~)qO~Z2 zP{^+Y@`S|dgZu499 z+}40$7jJ<571v?;$RX!Q?8mX_YJZot% zbssQlY^xR6+V<-b^PcoWqAonbE7k$_f}B0};@rmpxURTy+e4@?D>)Jz-to>JgN8)3 z#sDs-6Yo9!SQ(8;iucCvylAu7tp&MnNEYLEFNCL|q2Wh-RbVSCeIJIA3XJTN((E?h z|FWrI?&{rtv)Ju{T*T>oTy<3yr#p0tyt7-s0j*}}D)2mhn)>0keQQ@e1%Pj@aaxh! zo`Y`q>fu-3yg4p8CGZtM4}wF(;9!GrV8=F07}(>A+34Y+A&80ykI%>}38^sFZ${gn z_0oITq+7rGI(1phunon+$f`7}5a= zQ8tJs18S1GV&Bb)uy?it93X`PhCBjl0PGIQRDPU4Wak|0tE0u|wu1c;Id zp~+Nyu`y$nQaGsuUdcQa)xM~jp-U8zP*UQ6EC@nQu4M=VRc7eWCdDVe*pF{_tQ zz`(H3D;5SsqF~hQRSH0&;0S{bK|u&L7!a&CAV_aOkWP;vy&ge&1N1r_3_3kRbsR#u z^F3r`4_X7uAedueVC2GN29||^mF*PdB4)&0$V{jF%MpNMluT&I76T0A!f&eO0;6O; zv!GxJ1*2pqtJVxURuO-db*v%~bC5Hb?G9eanpHApMR}o;Y<*zoc{JD@5CjRLVu|1q zMDT(HUKHVQ39vbNxOh4HR&Xzp+d_dVF^h_5u5Kqvk}@`hPAA)00FAnuk`Jx?&cSW} z07Z0Fg;{r|G$C?gF62d0laC>5&Z0!&bn$MBkj4yh1_pxxaj`M@?cKK_F`-3Mt^-!U z)#-Gj$K3IokM4Wo*)G2HNb?mT9XcQ?Hio7x|Jlw&#78r&Jicj{9KLjBN?vfPgswnB^ ztgcvzHhwczmY=g1pf?X3J3hhNMJK9Di}BTe->KEbCB=HY(neOz)n^SltA zU$EQl)ef7LN$K71rihqWuczUD_wK)|i!H8jHYm8oAL3LJVa>~2>Z~l8j5hMQrJjC*0o5fP*uvkJ<2MrnDF*2%E zu0ysgU0ASb@q))3Hd}FP^xxVZ(m>`$BraAQgzKnIv`);YeR~U0vZ;S3!s2Y5Zt1wJl&6YXl4YSU&|B}q9n+o=LIO%1r%^88L0r=+sfiD zb>AI`px~+ecfu%sw4M-UD!n9%po+*RTOBmsVGzjKpd5v2rh3u)N0tx-0f18EgOwYr zO#mXV3)brp9Mt%|qGlPZ7bgS&D>xy!1X)lea`r4yvSTS#JZ7l`hEjkKd7tHEQ1_>T zL@5Ntg+uZfj3tde#8k0NP+VmJDvOm2!zi8;vekn_5J3du&W5H`Z7;ue@&e3GLFv!q zOex3FC5W)tov`z&Er@EYK;1sHEe=X^aeNhA-T@uF_WSKoy|nH$^2zB6~3F^hi$Wir&4i+50xo z>C|WV=nw9D;+Y=pC+DnKKU%W;QMLE8crYW1i<@utCvFHQyEVGh9tP&_Su-% zM*YEUTVLxrWZ2>x@4m-thQU;lF!i+;N=a-|yf?&K$?24wrG?XZlPS#$;rW$}g9oOq znmv8|lkb0We@K}3YMLF}yW4r>wWIPW`_kC)4&$SvB*!(N9eN z=(j;3-pzc@Kbzq?uzvNl`s(WAUhUX-+%S0Dgl8t)`#`H@DEk{i2*y3|FxGzk0S2X( zqgU6{!QUN=;O znh8h;0c?#G=+N|g$eAQjGK25`)*D%+UfB^ZbJYTFcz6dSbcsV&W)7ST3qceVe^@Ge z+bTtU#r0$l2PLY2Z>vM_l;;)iNmKxM-Q zwFnl7BC0CpxrD;)TiZD0UWr%PAC?eE3=5vfp0%Lzd(=Y#~%APNJD;~CHW;{r*Qs)D~PwtJpQw-o}z zfCFH6I&p!v;yzxgRf7EbLa|sqo*wNzP6SnabwyEX@;l2AfMHmGB?t=-!?2-)5f-+(3Lyl)`Rn6RyVtLEnKMs=aIDWv%SF4DWmsLD`nTXu z;*z`le%x<=KPaqI`|-WK6eDiAJ!J8BU-b|T!JP@~yCQ8aW2K1%=}*Ga_GkK66y)sM zx^&^Z)P4hBi%aR|m4o!l_utf3IT4}{Gqha2r4+W}oGp&3vQNAaT3bLkv}OIj;=6V4 z_26?a5Aa47oXu>)^pD=J*2gC&dLcdt=6Z{(s{B0wmEP!2LqntOP?D9kVdKJiKc)2P z|3Y*^qSqd5p5D0$_x9?H=!oW3p{JDMtHtY2F5R;KWwaCD+e_fuzjed&i9LJu{QVQp z^!8S#4x1G#XMDHr#Qwcsd#g`h(`)Fk|NiEYCwh8Y*lufthId5I+waGM?JM!YBUgS_ z9uXdjS04V|kdjK{dk0TvKMKHc#YVnmmastA36?1f7SWHVUOmw(Fik zuUa<9nU$XWZhZbPj{y6`O>$$ zm>mHF)}vwLrk)wPjS{zKS8AGfW5##md$MnEu-<@#xL6G6+tY{Xd2NfD($chygZqoe z-0_!h8`x*hb0a_{vvfUXF^w{G~fr{PIx0 z;iHCijPyxCYQM2y%7+diymPQ2^2!x}y@g;kQ&*jFnP{;r_t~H=o;=D^ns&q zY|#x6r4(Ph{;zVOb4(29g+e)06ksdLTj;8-3Ygzt4GoQ}`CsKIQ)(y z=kg~Cg0QI-!@Fww3?1?IZy$N0UC-JCWa0fce|>y#RY~znxu;J2)8Fy5E6gzRg{}v6 z$%ZY^qg!*E1xXCj7B(OxvlGUQ;SpqYpp(uFWB(9j)pbH%a%YI3AU!PzFEPNBs6(9P z1~`j@fBRIwJ?X8vOD*N9J#YcQX0zesiPJEdEpYKX1c`zn1VIKpctL35Ln}$N(c4y( z;1YQ79^R*dC>ILjMFB3wOV`26g~seICoFb5%yv7hb~~&N2P_UdtWF24P6td*J1lm2 zu{!K>;WB06J$+WC#(zbnc$QogODV7=QrT-)6d?$n{;VQILH1&$f&@Vnn)tv{rH~n@ zEV?qFjm6ERrVA)_7Z+2Dk})94BBRAdMir#0Yf+M$jql!n*KFw8Gu&s{n3TerpPAz*FM1q6iEjqIA`PbM%4&&V!hn%u zIqWg_3Piib4;AS z!)Y~6AJ_vf`yigWXTlW=nW>ai88L0i#-mw9Wz*2st|u818<&(aHg&+DcAfP@DaD>O zD~!kX?w;ew)5FAc&&ge6z}P>c{bbQCxgG&rzbSC3Fr1MZ395o&Rw zI5`60*&>Vs43I(rTc{pvz79#Bb%H4(<&oQmeff(ocBv&?lYmP=a4`KS>T2uY;(53K zEiVWVCF&MQJ&TP=R2Ff0i3gQD3ypbtwaTvr^_7R1rwVUG^;KouF0JmUn#Rb0A*!5t z@r9_O<7M(GDd66&X)H~PU%6-QUl5UEWuRCd=vhV)BO4b&;4VPMF{*GYi>552im-Bl zFIMS?V;hBBRe;sAvS@4ISh@Ha$3VxjZZTHJ$^xxAzJX(*=j51lECU^5{2?OF0AGyfFDCd~4jaC{AAz(QcK|uy2 zCnezC-`#HV2o>m1VB2?Gl^Rby$42RNr|E_=pB$4L-7^VC zNq&W^qUd=^6i@kVP%q()0$Vdbc&93_wjm4%&=3FsAOJ~3K~#(l32XU9J(Xa~JGaVF zR{R>;sSj&uUd~=ZaLb@E;}fpsL5i`w44=RIpDJB^a)LJ=Qn>1jMpsGxlY-NJw#A)k zXlS%)yj5W9$l71B!6w|p`+Y6$Iccw4h|Ks}Ij{~q@>$m|3EzZu|%P{OM16xo; z&Qxo}qR&45>BPQWAL1g;eF27GEH67{Gn*z38aqC=rNVYwq^_zG$Cu8+>-XP?hz`wr zSSyGkKAf|>Xz8Z?FA9=$vXw);YHVin2~%DBy=PQ8zHgVfX3q3Ql|=J{f$&5 zl`~P~5HXO4z>v${d&IhQC=POhXXKB)<5d910E1KY$n6ykW1k>Uj|nAw97R>V^^M=( zz2e(e-3c#oO#&{ zf;bjIifF6nWU*Gy$=fibQP6}U6s!H|SO%;|wy&qZE+7l9c3!rcVi;9)RfSF21J~jb z!Ap`X)-sGN!YT#jRG(a@q=>aF3x;9Au$=swWx%j3SWaG4Z(WvQz_4;(EW?0hWdWCA z2^2M4@w)X`7}bVB{+W9E;SwTSZYWj_>b@|F$SYeoG;XWL!7%bZu^fxAun-I!&=>Y_cdWBt0Ln=x5;MvEEZDEn|gwwV7p_IhCV9n3|)@iJm(bB#&G&BN( z%95gkPMdxB;Bgasak{IwQYg*IM3=H-xMNuJtzDOF*rI(gJz(Htvo)AX zV-gc@kMEXx)yA(>lCb3KsfV`yvglC&)>eqmAJo*>)|hoV-S|GkMuvLB7rw0^iUM{l zn2tXVio*@PQkvav*|s$2%oW?duc&Qk3x$s_hG48HKV>zWCk+}qKBm12?>|oYFzwut z^k)Io`#YZYj8rD&lUVi~F_1r8O6t>5S@&@;jWP=baJ-ga;*d@-L%yVfJ^8m2J@|?8#fIsk3q{AWE?{*%jAqV{m?ME<9edguuWk;v#93h21eJ z_5`6i9rRpd2B}5R}Yk zUZUVd33gF}jThk%*Iwa1vkRaUw)}Hv z92F&x0jToLpjVB}SXG(NyBw1Sjh)bm^~$=6(j)trooh{8J?)u4|Gv{>DVB*C2EEnGCs)XN5VJphsX)n%w5&`U|sG*^8 z)rb{k#Rq~7hCBNV8+lcx_zs&Dc`N7O**k}UWt;cWm0MgPelYvjFAkp0o_|fzwgVb! zYjP|mQu^;UDF?T#ui3u*=V$7xsse77&*gC1?PshF^{MeG-EW9ZN^T!F z9{>(-UXQrC9Q?oAM>qREGqbP^?@V8^{m9w8SJ1YvCuj7FUo*}VJDKU_H&VR3;Ed=AcNI2@eun@RIB(RiQ@uFlwh{FbFkPfaO4)xXI z;(x@Q3@G2?YqL-w1huubIDPsI>^2)*f}pHtJj7Nsc}GQho~;py{!m9pnxa=0;S+3z(wWuE(x%UBCNa!8!rpKE=lg+ zB}s5d6gEZB<*9s^#!~_Ta(bW$22Kiygn;2#5RL<*WYQ9j1;cS*bUIL$1E<$Pr`JKR z*Fk5{L#J044mzCH%0*a(acP_njFR7$} zba!`mgM`xE-MMt{@?L!J_xGH?VXt$}^vq|@SX~L>vh;tbP}!K;HyAt2oZWw!%m0Qc z3;X15m@+uzTI+3r1c}{x_2Q_;!J!JFis#bHn8a77t9=S7IMiY=jeyrNuSdxIz3Rmy ziYL%KHP2FFT~98j6KDPDFn;bdH?Ju~Mdhg6U*fqvZH9IudEL#FFzC*vQ)2GcY-!Jh zI)oh)Z7Y5xaPZtXbZ=_uT?^UK~w`QGma;4o;9PO{qJG zM40*Os^pp?o((Y(AUQe;yK`^(6^{D&HgD?bguf=kdt*s}%EdaCpuE4}Ly6vzv z$Ho!rS8*g;$0VrU-GEVO<{G{Xt6*Y|^M+dpCxe*LU6YRW>FJ z=xIIInW%^**`WpZ7`2`SeZj!AT=~V&GWoNi<4Mq}H$rk0VZde?LtDX1AlW#e+a*Z&p)O#p>t$$R zHpd?K(BiJbaP!kpQfGBr<4()W)>b(N^mW8RGMN-bTt*=u74t?Er)+GjVy{hnVMvvw zSczrw887htv`QKW!F$zc+HQ9p;}{&s8IF# z^mU%a=kM2LM6acpLY?8dxh!%j9}S4<1-U+&E@Cil)DuvDHHGS731ZJ*ye^iJWfjZM z_So~F!dLjaWaHr^lAUeISF;-xv`CEfyVq3hw+U2>2FhsT@Eb!zwlg$ZcvDl%ES&To z%iu>8+Q>D0MPuTs$E|-k#-=`^5e;-t3XNBeA770cW}hThrz=MU_1j;}1r~2K%V^I) zju05_2^`X4f#)1qo<>N`^sYap32&Ev#Xy17!t(E1+ag*TBO@R*3`>NKn|LCR+kePX zPuLzK_|!ra5#6ntJzYDeZd{L`rTLx1W-vOV&*hN+v_aSN>daMS_7`1f;`Mb20~rx@ zx6bzEQ~X+SnTue_za8I(f;;OmHHL?|s*Ks;G)|@>nF=4L(B@WJpi$kb4CH{7sknC# z=kVvcx?AOXqFdb#au+_2YqNA&ae|Ci+PWF(bLicKgPPtC0=Me?>2;RB4s>G{q=+u7 z-qT*OwVa%G2SP=y$Qqf6-O{9op4=a{qHuzlqDi8L(a+)rUlyCs#FdFcB40pbxI(S^ zUZe|_)RR~*xo$`y@Uj1(*h`#rvG!(iURyKeUw#@R0)GMmPWDwu)#2R9G4zf`KwR0& z(0L4(rLe>w*_c$+J0+o8Wf9L$uL zNwujIDDi1hjI4l0iN0MLpXju)#yN-)B%!kKX-4&v0%L!2+;CbP?CrlQ{O2)BqV6D8zo(I7^ilLFzIWI^a9znKBE zA5Uo23HpmaqRwHNRlXF#)>UsZ9P{Q#-+)4xH*raYUUzjJk2dsUzsivP`T$*U=k9pA z81(bRcQ#)%%ROG+#5x$S#u`*dj{Br>&J_vN(Vhb8cRf9shDi6(S9HWSQ>dO2AMG=K zSK`7Wc9S*4F0|DRrHDQ@Us>1_n>$A7C;lg#sakY+gI|mZ^+@RCE#!a zHhaevC6(}|RWH4qub<_w`!fBTR*s6x-Oz1jU2>-jOG-rQK-1@7PdqAkM{GNc{SL(l z9*f6(psCxa2R3i=_{wD6+eEIrou{I`ln@vw{f72fyWzgKG1nII4EvE}2mLfIF6jl1 zm0+47z-b&_b$(QcC`uygv^aM==6zVc7Q#;3Eq7d-G-dGGP%~#%&vYsRn7Lqx?8Zq+QlHJ2e$;kYF{9qdp zNb`F`zr3naY5j@#h7Qj@#qDvF8(GyvRJ2z-g7K08=*2OX>nAvlgZ>Ol)^zTKr z;4)42L)S$*_^V$8xdme- z5sQq%6MbS+bKmhbh8eFlW*aMH@wrC5Rekh$xmAb1o4tOi24(vw9qWu>5~=;MbN_OT z)SrkmzWJx7vsd8DAA!!kD+U6iGavEoHHkA{5r@q~D7I-p|LoO6vqG{Nu^V$O>^WWW zc_!S}3$^qHeolxOE4R603Pd0eR@!>vNM9Y&zYvIbhC1d{RCpcHIFs=_!nC8b0PT#A@<%{32Jvf1&8Qc zKbfBOcR((w@!_~TmVd<^v8=rHOt4Q@p#O>_SNy-tVL3YJ@Df$zz+Mra<-+H#ZNQfl zBGzYfE#Bmg@Ra9TVcafuUg0fUDha%=kg-!QwWSjPPXf=eA;tc>tOcu$Ji0uJ!yo=a zNIZW>yI)p1jlgxu8VP~94Jn+*O^#hY1Ax?bJOFZuz!fswoAS}hmm(w)S&)~pJ7 z$1tbuBXGaS*+{=D`cIwKd`)GScq`~aoc{DHBFZy+H@Gh`C@rPha6L5&uq^HL?b^j1 zn@yJIqp5+vAt;fL$0KG9Mf}>F&RqwD`vs0G(g;%Kz%( z6BDDgt*j9ni54`Mkp7PKlexCZ;V<(vmPL%0Fq$e|>|;@PvsV1@hI5Lw_8$_(BAus- zJhUx#?SQRaQgriesNG&t(|gb!*NOMk&3Ald)=UQMig5oz8sd)@l3UiQ5ijRU)QOUb z@MBC#U8Ub=+1)IgbRgK3vH-7QUO7Cm&_1*t2&6@GE)?3<01=sc^EMmX&WXNznMpo@ z^hp@UIp+iukr}3PXi=4QjLqwAiGs-{R9#=b5KYk;d6D30n!a#>H`+S2dLcY&Tenv7_la$?-}&laP?bSV69rLkhM;`D zHTV($L*d`PGRx5I@Lq5I$pk@feMvgI?SJTdSwdc=&rN$=o4hNL@rEtr zG@$LLc%!Sx0{PuQZmSz=AN<)S=rO(B@nY@z&+?)+6)0pQX=S%#zf!Zx=zjK4@njKJ zC+>ei=nR^`Yi+Zfx%nH}abbv;_SWuFqNE71KY_i|$`wb--0or{Ki25Jnw8g6(L@39 z_k1&cJz1^5;SvZqEbsd!*Nl{wT%8%rV)MPiaWw zqa|HbYm)yI4K)5R{f7dJBlPz`wGLqm(!YO3%!8Go!S5CGK*3s_#b@oxL}r@tzyRkH zrZdZU=KdnoN`ag29tbB#Uq|KSv3!j+=$T_IUNOE6n?JcSf6rDU>jKKD9CkBtP458M zIk;Hnd!VT(R*`!rS2z+!a%#v0iWMGPt=`y}IcHx@(8P)sfCadVY=eEU%+&dGtWouS zNFe1c%FXMwn)evbMXUjlPX5=cQfnTr%?=7wDXr&07Rd0s^(k^8X^*l-{gUd_n#f~m z^ieb^8J-G)V3L=VE_0z5{O80fEgfUR?V#C*L698z)$JnnN~t$m?C$Q@4mNnv$XH#1 z`kzngy7J*lDpz0x2Jj`xz})e5c8+kp_mt08`05q4ppcI46RZUsEAWvv+ewdcM1~&o zIy-fGVW7pO1-4P7LS~mNCujk@A3o#yXOGZlzD^ zqGkecDM=+H6foP>P(BFQIgMU}UCXqtSIY3<^pF2oAMx^Dp{ucVEkm-$J3PPDEZWG6 zGqKHAgQeW%mnYO-jFP+_r4qWG`IofHit%Y3a(7vwXhJQ1O}w!Ct64(I%kbNRWKTxq zywm#z!=pUD_bf%^8?uf>w;bhaS*A#~-)K&ncKL1J{x*DVN3lDS`@Q$G=I2;$(P`&% z9=E=lLz7_cdZ6%ltX<4}d2ibw z8qmWcZFs%!8;l2qqg8ImXfhFW<*}1`(Mxmg-v$lK;|_Mr+a}jPy;Kpk#Mcx44q08d z#J-jpI155sX#$nIJy+Pf-WUD5dM6uSA406wx8S04bNeBl zjbi!fi+DCmj}<_Ls;qHS(MLWm%)Bjew2!{PZ4)fFp*y9l#xba@UsJQ4RgcFNNv&IJ zc6}KVQY4zb_nP$Q%JVGqFjG(suL<9W42 z8Uw#udFP`RHei}dU6~8kyvfSRdOJG0e)kh7GLvd2ur*f!uuHsL+}B4?yYhkk+O|EV zw19`F1+T*&=gC4|RpyZUv(oOHF|VcA0H2n0Om4$r=!WC85gYPrlFx3t5T71 zI-0|$6b{TWZfteh8$&eA%EA!!!NmMvr}WbQ1sV$J3y#+>IQFKc@X{1!os_w(w_nU( zko5IPclKakw@OLo#JN4S-K=0w9SwdpvM3bS)K?J|a9+!7#~-hPuNF=((ldhwcB(KPBLsi{aB$pM2DbiXy%X`%uzx5$> zLTSXG^v~MNQ6ut$WS{G=Uq-Gh`dZc7vr>`sa`}&6>zLkG2wK+(qpb>AD(O@9ueWIq z;tpxIT__{CPzO>Kj%}1WK9I&YnXc{G>keHxYh2#-hebf=uMpWvk05QGh-aPvDZaE8;kt<+$6Ipnh=v; zquy_&Qix_Ahv@x_PJ9|i*e;8|evOz?Q^gf-1cO2KlKm0UJv)~B-Lq=y0#>qcHbIJB z_(}&~@UmqM$UzTonL<*r=#}i`{WrkamjLk8bri zxm3jBQh0Ls$?#3V;tDbTZG-AG@0cdDi-@KQSZFuKU=f|TWmpHFGQ;Viy{?3-p5^XL z8G+abeH&zX5Y9`Sw!%?9I)k6TYy|BO)G7a95?+uxp%FyXf*AtRlsSv8+5} zJaqjIS<|gSivhRE{-d0B{kOuB;y>L?PhZ77Z`W!NfNFVUpJ^e1Rid2(!iTNMAM_pq zr@tyEuW~wi&KZ7uyRYsD7#nNEz4L!LVJnq3GF}zAd~qu--nLs+Ak7P;5)xATVD1&9sShL->Gz!hW^uE5k_<9>(=jB7o$ff+TV&}-SasG)ZTaoe z{xBRjKRom6vH0Gi44nI}3K2l2IM#II+UP}&9ksb_Mm8|_PFBb%*rQTCtpyFYM3_8c zO4uAq?@@Qt(mr{tZYnCaK|?^^mMnPFpoeAS(uOist}zBK zg_V=jCj|HlEBYaTR`!%wZCmYxQhPqYWbVT$Ce7Hgb#T$)uv28`IvqQ7NdE|s{I{D? z6D*wvt>O|{viCC$k?4!&*v7Amf#!h{MyTma4UAE z!uoBHD1(rVl^0)O;D5`<(EiGMes)4yQd-!BB%0@OXVDvS5Ku%b)L)-waR;PE1%#fy zdR;!*N}2TUG|A2bT`N`xtxHW-uCS2ZJIOMNY;lXp?gzhctF*B8+pWRq)Y7Llp%mo; zV7j*^y)6(V9b#3LHy<=MWw~^Ba&B%0eEe9k)Q!$^dkN8&R%62n{d$>{{7#Uvawm0u z0BGe8bU9kKD6bGUD=HyhF<$$fPDz{dNQqlWXL#^ck^eP4!{^zen$Zb=)S55VM5)?u zG=}xp@2_$u$AHxcZ;XeEU?Ge`V0CXHJ!ta3T7_z@eqnQxGM5Z~$ioDPivwDa@Y7w{ z|1;7wc^YXiI#y$qVAhb*;t}M&lB}y@CBI`@_F7L{qPV17#J0SGQruu_?#EhXy~<>1 zb|FHT*pr*g$lpzNq{=&CDjXaMLc9MGZD@|ps&RCN8$j|__}23NK2N~ej@mm}Z1`2| z#3D##{{zrem!t`V5Hg70Z_NN8Rq=b)5xa%57_`WgSKDCbpE%gNr!DnRJCt|McsFsQ zoJ6P^HHuJIptyr%aP>D6=pX_X;!ua!-94go=2Jqw^Cr;omW_WK+{(OYX&W5!D~viR zabXgw)el$wI-XJ13w`&($|c1(>F#!QiRe&am$)s&CG~OrLki)FE-pGTDg*f*yIyYm&HH`YN=Bo73hzoE2>wTyE*kSVSk{Y;vN6l#TnMbx{m6`0d_^nqx1Rykx8yVX>t&u84)9&<)Nx$bKIQ&^(cjcr`2>R)X}}b$I^abh=D@? zjyAp7`1QvCoMB5K;v9-ww7jMg7AESvihm&yR?SsVnj&uH<8Iilj|^lv$b=Kv=fA1y zJhtg013j4--agI1#f_g-k(Ru_aBJDj|6ttjY9yF3jf;$MwAv`G)8-UH&zJ`See}v% z{r1J5_vQ!_q&jbGUZ85s9-yJEX+NQ*&TqdqcV>@9O^k=^n>Q)eKrQO>5kpqaLN5-3 z{mmJhMh&;ixic?2!s%$5|9{#-8sThXH{+eszsDC66{Tbx=k+bF`QUjaU|1c`0(vwZ zk@heHM5AB97_iit9S+#g4**Jt9^1~5A}l57%F3nXI7l%p1J-C}ukdBNpivClY~G6b zpMwr=|DP_P_;PgUDJ?;~;`6u#Q;~56`=Ch_jUoe5jg;(L0vz_>v%iuFC-0uH(}_sF z_9|SgC74SscC$uZpQActIft|jTFse8L|+&2Z)3J-ux=F;P|tesi&wRd#jyVdh<<+E z4g~OB%oz^dJx&H@oQtj~_dKHE*9l5nkNr$S|V0!unT1 zX?NQsWfBR}VO2a+8KwL)FJzC!E5V=SN=N%dW7?@Nm%K$Bp(vHZmyWCzMLit_tO~1+ zk4rTO<=V{nKG@Jhk|Ev`&9)87pylT21Y;|69uoP^>9Mg>OaR3bbH%GF>48hNP@wYN zsU-4UC{nxIT~o8A9@idCHpB%HP;pbqt|y?bsZ*x%O{^~e$s`L~4*FjDcX)@Z1MHxL6VOr5*o35Au{#f*x3^dllkZwl zbcJ{lzv9}?yG@BlS=4gt^o3TdxP&=RtdYO_v-e`ShRYoD**U9rL(^+hCLRwC2E21>X2zhSd5XuH>_#{azBcET0ziR*D*NAKIFQVyuGP6p{18KN)4nx(n< zEmlHR>tih7bh(d(6J|T#&$Ixaxqk+*jDiLHr&o0qoA-qT zrT=M^aT*52^dW)E4}%!L-9qH0!VtdI#)uek5j#@me~JrbJ1Ky|o;$et<;&8_ zo_PMjL;But*A6znYJmbgdI>P;`q$z^E6X&YHbXCH7BD1_rkIYMe6{t0I!7!I^a4Ow z9g#mHtZG{SLs;EgkJX3g<(KA45afjf*ix*97;5b@@19-{PgJ`*lKHn>MbHeV7S9+l z{$v&B2DNE?b zev6{0?}1GqE0rzY=)7sRDwQ{$UZq_|y3@Qs1w@GG{d5d<$^M=uhiIRsO*W#0`?H&F z1e)mM+#VkCgz+-|Lhyad>Wr`@ELpCcanlsU+i!5nTt_hwq8W|u@Fr#PthFAnpiWe_ zb$&cNt^YrrUlj~{Ea+GrMJ<&;*9vb@DtyRWC~&>bm&C0~1IIXY`!UiQ9y(sN7U|Uz zZ4D7v$M3h3aliacSJY`#j17HFDk{|Es$Y>2`3y{hobA6SNTC=;3%X^PCiAT+UNT{3 zatk^yXKg1_k=*?D;t{gcgJ6d2w)PD>i|%&nU-33P?3*O*8Yc2f9Gk#l-iw8I8BQ;| z$`HCtvBL@c*K@#aj{99eQmj2xK1Y{!Mpd1Xdv-RGTEI-_qf+qAJ1f;!L~pE)Keobs z2=R$0TARsT3b3K@N*?g^3GL|T=-ADxOeBhy>14y=vg4?!oY}R#A2Wn2lMOZwHX1zO z`l?bVq1qSb;d~LJUP#YE_e#edq#&=ydDvo%(??d}3P1d1Q6F7wxtC)U(6(|%pNWL0 zZFsG>^8Ep^mK}bPW$Ny(Z==QIqps|d?yMT zhd`>rWvE5xvwl57q#{``0R7hvgw+~WxKH{KPP(Uy?@jwI;FY&>7cf+$!j{MHlMmEL zGXb~faA$N$JJtO}#k{=%kmz{7XHLf>lbeoHCFuHtNZappI#YX7x+%kPQ=@1V(0mo~ zmSQ(fEG3|fv0+Y68BRy{!PCRrJ{9O`CRIqWnE=Y*IRa^}ClDaI{0G*m>n2W};EsN| zy4UbM+F)4Jb4gS6T7V~#C7iFj^T9|OvGEWqC2fKW@U_ar5to}+t`}BM+@I1hY0=C` z;czI@?QpoY8DTr*AzYS$t%`dS zxyF-7UAJyfQfX2|TSa5vj^1vQO-a4-7{(;In`MPQR_Y!SjZFIv)ubo=_ zOf#9K7>d$f&4>RK_v4qXw9P;-r_n#_oB^H;z-AFBsoE=Gv zQd9l5lpVpCry+2agO;=0yHA@9;j2@25Hw^ST4qZ;D7dv8lE`l^wZ6V4`Z^2B5SXD! z!SvhZge~(I_nr=L@X-xvuj{(&lq4;D#a0U?9>n_pP4BwmKpTJf?cVg$O^ab^^xf5s zr>*SWaO1iPqTA}{nzZu@rqv}mKhKKhw|Sx(?;!a^A14~Ui~b6@tsTd4w-0ZpjSxGV zG-%m*ZGRMT-o(4ZRk%6m5s z7w{2({GX|cIhd50Sk)AKXhB+WKE_kU1Fy>6ST7pk?I)A%_s+55gIq707vY-ASd3m=W<*u3xe=UR&@p{^P5%S8cj zU#>lb7NdIwDCj&@x-P#Tth)xhEBJPpy{9D#S}p@`%kl^3*qrP_v^`41ETn0~{q~4 z2yM@0to=SE_@5UbzOep4vhINab!P@*D}+MEp(pRj4R`H}5uHWT$9YK$jIyC_L*>-4}t#W55e92}eu z70vIb!#nii$BaWFo~p-m%72dVR(TgR0{pNePm}PA_bPkTqB}ww63y-{hpvAVmD|qy z;T(DkR{1p8@g7s~F}Hi(ggY<@iKXITS(Kf!`SMSPMTAadpcFWkjG_VF9N^ErYko@M zc`PA;d%6029FXF_?MRX7U*UC`lR*%A;H&Li?;RC~$^rGf_bO{=B;t2wjr>LvV@j1K zRHElQ#hR0&b1XY0mgdF0G*+AJx4XJInX|kV3>kFFUNt6?^XV~3Pd@?elx$ISnr?3= zzTDz+XKC!*OT!+NpS4c-A3bwe4Fo+IkB5o4+eJNjNt9dESREAjb0%lkj$)Sh)MiNJb( z^4|e5UNGPuJ}s5_wC$Fkj(vU5;(F0#< z0bWxDls0$44fM`ya8!Ke+d}JC5y0OP@d>;ft9+IFM~2@sQ?&)JMGY#{I$%<5(>P(b8ZXtcNOUul2wd4cVq{*>1h))btS`H zx}Ja526sc`}EGvJsze(OM8KDxJW6`ewx0BbJ zQzV4~=fibM?cH1(J#fd8OTHGZ84T20nGXzJ%%NuZdrg|cWSPhh@hh8)arZmDgNOToNe<=bm` zmvFxV-TY5%{qI?JmBjJUcIn(L_3)@yu0|4-JFoDg#w=&E$9+7Up>C4n-R>dUkjcloK2p)o-aQJ>v>9O}#$=6^RI@70y@@x|xr89Y`zV|-rU?+1wL zl^Xrbg9%U8C-Ta@K3hIB;wAsC_@wtHZL#6OZlj78iqKACL!_S?tVsb|sE|aP^{RI5 z@Q?~CUBwlNcT?ex?%gC6qGc0O z1UzSFXN1I~iC(&G`RX@~_kG&%cn%KNM|P0fNE*!M+qVfMU&6DqO`nvy%jS5TL$S&A z=6q6y*QG19G2s5u(ju_%GeO~1iG+)U;%#4OCS((Jch*X%i)OYiWGmwRrIAE+6%aun#9Mclr~W6I#BDu{U4z5HFn zYAf}Lu7YW?U3Jo%a*?MbbrO+GUoU3>(x5Y$7~#;ZD{;55z2#gg1@AF026p+xoGF_^~mT`0^ z(_haEwwiW&qtq?_l`!g!5J8RgUv0v6n33nk-33Cbuw$~lK7_c%uy=yrx6uiPH>%xM zeiI}vw`4EYr83`BZ_`e7(|^{)JcEN`@I;ov z3`T<%#5J09P6iK1A~1HRPh3~sv`ZM;V3j=hnAN$CyE|-8jx)2^42lA%8~`O1O0~&E zf6Jx+6LMwSA7#Q;^X7Hg$?lM~9oDT9GrgPw@Vt0b4{tvYvhCsav*=EFKJsUP73DZW z8bOK~MoYgHxv^WrwlwF<&**3fSeU+i5#EfTV!~I>wHxHjz!OXS4&MmH&-;hMO3uCh zXZ#PhFuzZ-)BV(#!LVj0rLgyHBT}oD^9yGejCROQ2wfI6~kt*hHB)>FHtBz0X zayP_D+kZ6Qye;}>b9vZz^Q=IfT9DL7wT79k#7dL6!du94KGl?S6hS7S;lQ7jp2-5V z6tdYn7|T3cEe&JFQlu0-`s2Ua-{#05=B-sY%dnxi@JH?wo5^+8vaopC?eXs!8O1(b zGVklhkUu@>{(SD|Nt25)8wxKl7JhtOilQ}sy1nXm0mU4J_0*T*S>i0bidJLDh#;pN z5(FgGq#N3{UaXi7b&!ee@NXzO>8LW@rmxbzFJG=MK(-sI2nhR}*;}UHz7-B=jd@|d z@N<{s+86#v24miP~)JVnyr@uX=QxSl~teaR8vKy`qg*%Q4(4;#+%LW`~t+T^+i1`j@F`k zLuVo)#VjE@Gp*;z0^ zmLK}`ymB)cU7m2{(M4U<7Z?1}_wvn@O;0Q*OI@psdf6~9b!Z42LOPR_*gw8%jeGox zsDuB!m|g-Sg!YCLT2`j>&DVo{M@=<}N1fVv&qu7tef<9p5k@@%CiDanNQ`sE^@+~s z8-n_OA3JXwWNW$&d?&Or2dh3HA;FqSHI*eUP`_z`nlJO57a0sQ(PW)11qD#Q*Je4n zQmT;rbp8(2PU`ue={lG_cX8AqcF=IvVl>Z<{3|OG$l4AuyPi(Dj!ES%anza{d^0jk zlMlK`%zkquTxnJ~OG|SXiPQ+d3TSAeGc;ZGe6G;hMIF?`PCtJ5+AhBt(gH4ampNph zM(&lYM!?4`jLof7w<$z?C69?m{_@}|_%rqt*cNTN=c(ZW(G-^uxR<*;rg>1+^W!eS_KEcY?&b9?UpHX*a_ zs^_}B2BNm6Hq}%soJEo-(AH9IFH_z0mS|F{kox3M0eX7UwbFKy^;xO6&~e`Nd-t)5 z0sn6XplY8f7v)u;8q=)Uc54@OZTdA1298#%Z91NyH{z_+OR6ECz4QLJ6aMW*Uhtz+&43WeQobQc0{ft3gPtomgn*tb z$b*$8+Ohv@tS3R^`!KfcZfyEC($eS4d={bqE|b4MzI>6(5xQ<%FOC)lOkZ6_kGwZ# z97$I+IQLf#1HRtY#f}{MdF<-7NFz`Ea=(?#pvTTUVn8-h2MzvT=>Jah*q1Kiv#kva zjL?ovj7>f4l2+911jY-{(J^d$l)mj4nd7n_sV4DrY@(9;^pWN$bs4>JE~tEc?!}8! zhflc(O8;ZboEUDB3W)s?HTKQ6*>88|S(O}FDcg>Erj8N4)Dl$I)k@gWt>9O2Au{TU zBkd@WgS&QWeYD5LSvc|1qt26}5Q^Ownr{e|7JBEWH+Ntc`FUIa$9!4f*Vs^*^G3K<`*} z7B?5|YwFE*vzf-3EvVc{iP+!6W}CY4*PWW1h{WY1M`n=n*|i`J2mY!MU!6F|mr-MP zyT9M!*W38SP9CzlmF#x{;teixZek#KnA~MNWL_st}uJ32_wmmnuR~2I|4KQSdjW5JTv# zl_<@(${#@d!i15@JLa?>W=KmTk7M@t`q5&3+Cc6Jq#r*A+jQHcqb=YkBo|E!E zLDKct&vF~P;>2fLqWq={yY*`Fw@yRf*;=-Y-p2tr!;ai7lY3kktH(y`HWte!}{XP8xCV0n%0-MU`q(`xx?DE@a9$X_K_!R}#T4?Y9>L}Kxne~H@=5-et&VR&D z`f_j4=f6ufRjlQubYUe|DR!%pL&w6d*>hNQeiVQpDz5q*>hn5G zK3Lp$Bm1yu!rt30QS18#|ByD4-DuH>z3NdioSW&NyS~zhhZoY)h^Zj(?}j3)BP&aw zzCjg0D@BSxBA!DLM8x_h-oXNLr<6B94`*#vrz6z4}HK~YJi@yXn$ksVtH^?O%o z1%(~f93~55{ZCtqXEyb&^66fphiLJZKghQbhqKE*?KInXGQJ{~{+@QAhhD5y{|Zog zy_ZrYO~=U$KAt{`_taf-)IgWGYi zap>pvgm*}dIR`Ukb__H$+aYsv#&7jxEi#eq*vF^{{|pZpt~q8>+l>q+QX@vX?K@)4 zA(o=VBa0(@LbR%MFp7}_eAPO8H7|wn9jF_X~-B{C_;5C#Mwe>7gSqRQd*Wj|X5 zB*Wgovv}Pk8p~a>N5D#5w}UVIwbwPh^-;`bNbw$Bc1hb z=N?w8!PCORU9$!Y!he|;FAeDIsFTpaT_)_;eJ0=4&U;$vIWH>w4qp#G3yY49c@h#d z+xd86JDJ*zKmXvIb1_`@njeIT8S=#^?ZIrR^jIZlwiSUl-xfGlae4)gDNcuDo@Y=Mi^r*mnv@=Y3Yv3d8c0m2?K-h+9_aI*Nv z*7V*^lidzaPE%Ymgh=CR$1W6&e&ksrSsFL)u-f_XUSF<6nfZ!8DDzl?6}X9|e;a)9 z9B%SH|Neu(&6zay;0sF>NBNF!iv;(>+=xf&Gi+ad@UN{8=%nuSGHBq2x@V$|VYn@5 zzU%bipr@8bx3GC;Jh+R|KYvwrzQ|^;qk!Y`vSx!T>0-4;MtS103Rz-y*_QZlQhpFq z8rY&Y6lZZ1&SkY8gdRbuP2%eu_L)O79wxS(tv`(eAK$eOds$X>-pP+HRNu4JP2; zoiRA;v)!K;8XWu?G2xvoqsa!<8y7bdlU4BHG&51I;1jCTyUn$-#r{N@VU^|Gg1bmW zWM76v18{MB;+s^R#Ek(Fx5IiYl}Ntna6iqFRqO5tY4@|v4&8nnjt>^k_Fcs4`g{&g zjP&XuYlOdnhGj^bx2Sa4)fn45wSDcfQ9R)ZJ?8c;K!XhucTVKlvS1s{3gXb69rZ2-dU@BBQJJ56 z>61Xd&L1JUCUkwiIID;|3QJ^q4!=&EMC*~))a4zxj0d$(ohW43#_jM!4rkL*L92Vx z0T$X82D_xmmCe#Fk}JQjsn=#m9ZhpI>MbA9pz4S;Y4tcmeV*(T-Bi2xw*S6y_Xh;Tc1!29%(yMIx%){h1M+Pl=vHjkfH0C zZf10TrH4>HB(eUB0f-08?@K4Q3FRvoBB2DDV@Exb^m)gdya^`I<7U0CVx78BUGW&Te17Mrh?p)619 zo)E~Gs!BZg?~gW$MhwECFgbDGO%DSar3GhOWIK$QVXZ~MS;R)HMpPB6=@h=ip=As? z26Ib>{q2z^j5V7zIu6F=I_$KH95yq@CWgdlR85P}cWy0ywewYe8*B~uX|f`**_Ts-~KkYlKMKDFK}`(55)bkXJgnfsL%GsS-L zWYu83nzJ_5!-fhZ+y_su=K#a)qb70#8pH41E5Ofnv9!_RbHZZ(ZoWKLSSV(!Rrh`e zM$o~GBC;Wr99ZW^&-HR|Xf&T&>it#YgVTkf zm}|y*()D>HjRf`D+g&&D(=QAVb!5>rm$wFV`Kf-|_Cq&WjgCurif9fBOK4vEwKi+h zI=|=v0gLXVUF9pjImHWSJ6o9)FYl;^*RYFv?Aqjgy?s*uS;-Nm-t1!SqPS>A{k!3Y z;#qjHKY7FbvKvv`M*sAK$%skkr}^gdx+aiEX-{N)4G~kV@=A_Xq#YTGqv|O>Dy~_; z(@iamxzzRhywdjDFu%JjSoyjy9AUD#de_(1R;QQb|VdCQCaLG zz9QY2*}-ny4tibQ9!?PdOcO)+>n5vu+f$P0Ybm})Zt#AmW-q)+aTbw3${BduD)EIi z$M)OycgG#Oihj(g*CHTm{iSWK#Ww~N436$tO1Olz&`>6y|I;ZhZnA{JOs2*OSy3>d z@Q_RGF9E-%iq(qFa$IZo$M??3q>y-Jdc$Ndj*uH%o9n-{1-0G~14sX><&C?R-;6Ry zCdTsK@_KCGv;JZFjx={>#bG1KP83{1@W3)*uvcJoV}8%_J;z*-)dV zmN@MLXV=R2r`;Ye{V2Xo0hm_13nl+(<|vgx{$x2y?Wj@t;#q8dqThV$us$5mQU4OK zSMytC6gxHd;&QOHE3sb}iUwhm?bD=qaz#J-Q?K#m-Ym?f{RTUf9c#+X{}|--doWBC zCwN@j)Oa>v^U4&12SoNWq5E95h6M=2%I7;f;bQKW*E77WuES}3>N4@Iuw>>{My*=& zVTsXacDU32fU$;T(1jCk%1XXcxz3H4nlE%pp3ldWCcj5ss7?(tA{R8Z5xa?R^O*h;0`{jK(wHSVEV&E6om zeWFL>ZrY}+?>ml^em~4+mwxd&OIA>+d!p8#=S}+=svr+iO`2*@*y#hU=Dk!`P8{youKE~J7@ zhJWhGH+!9IWwXt36-kXAF9ek_%8jvn}L|^z>`9W0>!( zV`V*ec^zfH2`?V177}ur*m~m7xy}>KGm~scC7LcOG8E)mA9L{(D?W53Y}eY_+-a9v zEZvlom*d`#vWK%*C~v`2v_)0QjOGnu9SNU7jq~uM=La(GT@G8E~bx+}l5E>8R4!KiM}@d12+l zA0Rp<#*1bUPv^G7gO7$;cUQY-EekWPo6RNSbjPE>Kn@xjF-*KGq{rUAn2%W2^=m(E zIXPpHL~KY6$kN{&2(6h-*s>6R{^@I_+kfFG5FtGG|MB+Ke^EBy`@2g^OE;o|NP~2m zNGnL!!V=OT-7H8-sDLbzJ_;y}G)pYqp>!{j63YV8uzc_J{XCyP;X6O@BJSm$GiT<^ z%ynI7CNsl4biUQdGF0YJl`Ll4B&JueB$|JghNwekR}xa{HM0fpylAi3V>vDUTg|l9w~Qn`RtYf)Ze-)h=`8n8i%_emVZrS!B^$xa$cd z|B&1zad5bAI~%&gfVXOz<~yh~HDyfjhQeIIDf#_MQ3PVuZ%vs`uz%Bce|uUdd;a@s zkiq3;?mgcAJ;!xFI$pmFB|7o9au6nDqW!vi=0gP9j5+^<8yVV*s!Mj;adLl;^|;Hn z^@g#S6>#UuC+v8c%b!pG;LZfF!(vKo8`8Ly zQ|_v+t!6xJYqa9)v(zE|#JBgv0cqVCXFjvkU{|*2ZX5CTYEJk3eV>)i+-S|#!p-P{ z4%hjN@!=h&cQu+HfeD)4{RTPOXSTd`U2uH&pMM(1eY7f|Hju`Pm6>W1&-#0oDTKVR z?>E6U5NXJHglKIbu|94zYuftP zlFg@4-lfv@xmJ}%&?I`S;;V4@b{CA>DX4x7?UOwDE`=X3Q2yva zK7C(K;{{tko7u7Ck_;)owMbzOR}u4njP6W+cw&U;6foa)^uVtQ-cyG#;YT;R2dR8- z>WHepMqZJTZgj0;YD)k9$7-4Ul=j1+Jz>BC!?$Z9@x3(W@ZNIG@tjQCfrj8X`{jxZ zYzlpk`WXf00Oeb{+=|epWBHcY8>V%bPJM8ifqe8p8e*ulL=|*iYe2*t$>-O6U9U*` zrZ0F{c1H#c9$2T&C-!9GmLynx_|r}fSxww`R$k*ipr|`6t4$bkv?TY}B8S&5g8_bi zHkP>;35KeQKdSEU@O-j(5dZ*3gAZ$KFh-4jdtD2Gz-$t;GN?764V%4;OB23)z8*ggO3a9{VM zPUgrcq~YDFEE)~DJ1?_KKyA%godm(5oXb;9I9uDsu5pI*&3a2>^SGL$wpmFsQ9=2> zOJtdxBwgno*}I~Wk=+naQMP;zq9O1qya5q*(Si*MO~w+w97WQ5isY9b=ODy6T@S*P z5aMi)Me`U-f9q{5&=MTt z=JrtAp7v5k zn3E~i)B4qZzfQ3w*MREI{ARv<2oKxj*>zOYy#J{+KlU0g_lC%#HKeRbthKdt$cf7x zlngc_*O`upckJNo9y7~=q_jKl*U;-(|H_pJxovorrNYPEnq(PWHUv?&3Ln96c!YKk z8eV>5Tsu!)Ep1OcK*12)&H+n^eU{bC1DK5-PvcR1`8%yi#zKPvr?Z6gwTJc zJrzbzrQ+xld&aF>F8sUJ_zw(~lCDA*=z+Ehx~r4&jFg&u)-5{Hd{l@x-;*?=_LC1` z^4__UU1i1EiL_tFri-T3rrczGAz~YSN1=6A2I|2J69k)pN6pp?Wno{4-CQ(ts~F0s zxyXk1=h~x<&u?lt)*fJD)-EW1-mp_32pU4-}%S1T>V(m(e&|( zquw$F&%GfN<~tv;1a?=qMm`w%Oi6xj==Aa?apTx)88+W<`}&Ril|E*Bm|?4~_^flz z!(1;UJ#{*%rP;X7ZuGaMz0jtwjIgUlDe-l{BFJqW8?=vkrJa1a;@B3-MuhSB0O4lU z$8EDB=zg6}Q0rqnd75A*&8i{R%@v{&Xi7%6V1#E zm1kLOF7UM$4{Z&6yGP2q%%s^1u@r0z%KDZxF^y2kQ&!w++_Z*Fq(S>s&0e22bAl#7 zHBMA`tJHzOCNAHCVHE$Q1)^d+HA=t)*7I=#s@f) ziIDBcWU4G_lTjWbaF7sG%OTV7=X}vVG}t?0#_jP${jJ$=l_ZJT+;&^8+09o5ZEb=R zuG5`;3A6RzElQlrP9I%3D6z`^u01W1KJzRi0!9HpX#WxD7;-%ZG!c0{Q(J@uF!EN~ za`8z!6%E4p#D^ASYMQs1aKRUjtrl{8v3K+kbr=y*mMgXw>4T?kD4ay)1D791EX?0{uAx(pQ%nqTy*0&7M8oa4R(6guw*Sb zmdiPY>Y{P~(;vvq(|{jePWv6E%Y|3f(=N8m{60OH^VQRMqMhE|f96hF1$$BJdGW+5aEn|8XMpMgrTS$iuG~G2bxtd=IjrdR%shD8Gx`fNcT1BX9-K1x&8xpEj^b4jkObp$*? z`|w|;uAYX2F#9X=X8!a>X~lu3ywRT-twkz!Nso()Iz3}NC~kd`)9+V4U!8vBF!`O< zsdoFA?I(+e`E>#kcZ6Y*f9XjD1>YjiI2qvV{Y2y=imDf!vUze`8QG!&kTJDdD^7qCk$X zLFu|xF%6mDeiVrZg|;6x_1-KHWd07@ZGBvC`W+usz3}inP@X=$%~v@aZmQ~?RByYo zT(Jd_oh(d{=M9qcnTctNPRdhjPXOpAV-47b-$RLrw+Y4>SL6S&&Hw%5%M(A%KRp<+(TIClivGB`h2WNR7b|Ps@3L02@!1VwfiqHk zJdMw4hy!!yCF3(HQ#{FH0T6e8oh2hQr}E-4I#ZcR7-&?Yk|&&}d$k5x*Zhi!s|%k4L|cus+b;ugUz| z{9jZ)Hr?|R1d|vEI${qaZZBdc%dgS6Kjv;I#jBgKJ;y-g$HS zHH^C0_NDQsZdLHKk?;Nd?8~t0eyOi>ZuOUC2nC+LR@kTFvaWxt17J9Tc*!lGm;bUv zTe>#juz~kb{lsYiAc0JE7J^4_8cvk_Sg?fQorfoRn!oC;AAT({T}&c7l>7OOq6)N0 zup0IVEn3cQ^o#xcAJ%jd8XW=;)U;X23vqGgjqNH^XtOEoHX*Q$7dH!;#Zd!x$p|U9eVm=jK&AWb$;~E1`jX{awVu{)5?H0wg z6s;CWMA%mES!EIAPdDMF`kB>&JNg>h${uGvWFmafKJ{LH9Nvi%u;FMVqT9%#YGm1X zTpv%M1U5-NR5WE^4y(6+c(|(p)Z-S~(V%GR%hpcG)j0OM#!UdCITg?I`=k*aSn8mA z^+RP4zuP8KwYY|c&=W1(dCn6AD=}%}Y_(C2dcY$}y8*6(I6~40vcl?1L!?0uE5$I( z=y9(y>P#_%<=(XflntZ|lHId3$&K@+XND*c-fNp#YsFyXM&K+}1F!%vWV+-R6Cj$O0iJVvT>gL<) z=;}@wq$}sW2W8D5Y8ch6qO)#hkG^?f$YcaG;!5~Pvwreb^W0(S1np8}xcH*p@q(^z zXV(sas#f}9Y<#FTe(3DoEwe@EPhM|h94|cFM9fqN5?z#Ss05;wZP**NY+;-Qmb-Gk zwK;3bgpDL-M8%#%#;Dq`MQJE-M@qZ1*%5*9)w2+ajktPckTCcoiH`$l?povH3AUG0 zC=C?xq-^MXCEzO_rq?}kX>&(q+B*$nUvg=ToTBJyGBG)I_GE|TLESTc`4)Yf$ zkmexYumNr~t#)dW_B?;*!l;%eQ=O@iUqP+2HR72EYWFcd6GrWe93|B=8Kx;bRv zRk{e)>`WmnmuULg(&(bQ4xC>VFDyA_5#3^MCr#ogvvU*WECTxgo~cg+D1$e8w(Hqh zq+`B``j*B(UH6l(`PMX_%~MU9>+?_1Sw2SwED6`vgxIZPA|z@t%HI{H4)BQ80@Hht z>)^+-!zw{!TG^#ge<5_%V%ek9C1c@(H)hYII-sdO_?%>M-8HqIaov&Rm*+y9|Mn%v zdL22I$6Y3RdAxNDO>{!(M|eW9k$r!WPZZvxx`#sq-#~lkGO@TN9^P6LyE+!LC29=* zyal!dxk&h5N!n{&K@0*|1n7U6@5E!?NT5V>W%3)_N)QR1;s+e=Wuw{g{Lydq;LU%d z(1RP>3v8xA7j5kvrPs*G2N_wD7D6s>YrtxP>JDquIn>T2(tw^HV|auA6V%v;A8l=E zS>s~Qhj_tJyj1OU{87KipsWjL?q74yz1o-XWunO5*fXKm)At6s1U0qhF^I6uYnojE z*qzUdpe(n0@68hS0QFMyt*oS9ApHql<@Bt_x*312h-i56Zm$6R^b6%em)w?7B;U#G z9E)-#x7*i8Z>1`|Rf&VG!|bzsnAargWs>)@Tj?6-3A}Flrgyj2{k0>!(BCFY)pFzK z5+;r*m1>$5&%$&mW01|4l7`I;-yZ`uJk3s>bVA$p)s)mgOTOxFjqh%a`SVXDshdBV zVf{xBa&Op5q1qj6a_%r^D!OG!ey?k6u8B<#mn$XO{oC*wb7U{$V2^+bUqMz3nWh1F z1{yx7FUs~kk2sR6tMZ*ez-_UN*ZS^>hH_4CUQGnv=KZR$IDW;au*xb-cnnpy0A->G zJ0$jn^7Dle=pE{d%SA`M0Xu(apNv;)idoOMS1PKL9=RA}{H&DAZ(8$mFwo8UbhBD( zGxge`NuechNpa5c!dQvNrOD3!km|jjTCkZaGxnvr`bpGBNz1^a!Xg|C?H7L%C?p07 zNsxfZOx`s_Hso{(!l%EMaPY=#)sSz5_0kjR1uXrh==vHqtspSo5_V+;ssAe&6=$XSW9IgX;KK!kclKlJBArarxQ+^KPHVp zTzK!hdJJ+cd?VP;>9uWCKb>Z_A5;Mv9w!3MLf``{VpC*E36G=nS1)8R@(8Ui@mH+L zvKgDb6lY!padJB^HA^N2f)WcXT*z?EEEz-!t8$pfGiCCZGjrgjQX8{CX@sDrfy?Ha zO@`QgTyZ8uj^G;`kaDBPvn-&H$7~1f(^=`diGpd%lj(iD@%FeF-$793iz{*VmcJJ& z%)kAD;x-mXA5e7C>g zK+RM7)Vjwc{e|>tg)!6 zKf1!FVTR#n(>kY9Ej7%aO~eS7Q1IfxwR}x@?eQKf;@-wiMzUCj*OP> zEO+tFt9N&N^`|fUX2HPW?R4%tYo$iMj&sGGyIBhUuBQL`SJm$huaHIK28o)Qz0zKF z=z|ASuh6eV=AF^&<>e1VT<6cSTOjERV_+QUu6(y%nD)t0OpEdhP^mk|@Zo4(XYlqq z)l3(1CKkc%{@hU6ZIxs0{>11P$}nWvq4&e@y6I+I6iHAiRt?GprD*=hw|Y6&;iaxO zMe}ZaH)ULT1?A1oO5%fU9uRM3;~h@+kpsx2WR+VQ)+tMDylDAU8XdUuNFgF5bN}E% zGUL^mYB2B=f9`|psDy-_WECk+mO}k4eYbSDhMsQmx({ZXZD26X(ds*Qk!-gFJWwp- z1yO$s*5*0iatp{+i|c&+RWmZ$*oaBCv6f>d{GW#TCcNBM%o$NVNFQYA7|N z9UEk6(Pr~&ZS1p(Z$U7r5!qba^q32?J5zI-;@5=Jh==;?esbv9({%PITDS9!e+xIrd3J629bMX`oRf#hpRr^hK-lP6hIP@z~BU+A=i2Z1Esv3UR;_MM<(5$8e~V4nC=|I#9?~<%8kT9nQ!(s33B9j=rz+LqOoJgJ0OMKWg|(^V`uMm zKPh+V)~0{wY%8FDa^@suHQ#ta&a7-d{lno$5$>To9XVjkt(=}B@LVOdDR50w_tItd zEa6rin}~Th+3Rty#B~DSUx6+LpXb~SPSj@@o=&BC2k@VQGv}$iuGD|R_(NbQE@>~MhKLvKx$HZr=){WMPL9DKZ z1_dY|(k*s>ZtOitFnrCTt1yvlYQjBn-3nuD=}7k%boJ-c&Ya!bDt>&)SUkhL+f*C6 zqvU?iw#Q8(x@@Wr<_Jh<@loK02(f$jjFh4C;=-{q33Z6yOrUQ|VI0{)z7nQ|w2nZA z0YEvxA}~lkWtOKD_E!0iVb7*(W*>S38J@CbUWi91-GtL=Bgu^IqG!z$&*XKJH@)h-a^ut+%HA~NyzlMwqS~eBhtjYm@1S z2$ZUx>wGYv$hI9Sj~|dXs&Dyh#lS!FCMX9f_|4t~#GQK!BbIC02^Ob5BfNMCP7vQM zNq5gK3)@*MMc?g>b9+)IF@|9~M>WJxGJqBK?iPbTa+?8R1{u^rwqoGXA~E<#Tj}wz zb>E$!-S(+zkB)Rtsr(@fy+Ud@Q#B#tE> zY4@H#u*qbRBlM$q8OOgXI$7^}Hy>9Pd3vGLt#{=kU*8{o`1lr9B6}A&k}Jx!DX7jz zY>iXBOahxSsua~*r=>n=4_e!DNjeQ^X?4y`TeznHKN$-=a^RZqp*Wd|4#6Ak|F}=2 zlCkC4@y|lT#`8ZBTJ3GcVLCF_`*VsC{}?uDVx`Cb8h$H@(0wPZ)@@OWrHeP(?*>K- z*(PRO*gO^Q2A;$CNfr00i(}<^*?g0eoO%-d5!_qKa5Y32#uaV-bE0cLiQoRMQXOJb zp8FbI3MGL>D`BRu{H|qOfrTIf>STx9=e35UNQi>_O@?N)t)-q7#T0xY7^)8xZ5>l7 zd@_?8s1-!bdc3|1o|E%~6i8uZ@?Sp+kjfwEysK$<0%*f{gWi=|o&_FBa!uCI{>2$? zUCAnhEc}!#kfeGCn z_7c~CV4}t)Y1UF&zUXtcE8iaFT55B zkKW@nn~UlNaVGNJtfP3ARMk3b3IBj{6j?TZ83$DtOYuo0fjM&6uZgaCYFyUtiH*oW zi~b@~Boi+4602{-MxS8jLS>-mFEiyl6OW^CQZ5tkr*t5a(LfF9+5K-39EW=-%901< z4F77vAau!o-v-zSxmf;I8s}aVkOOBWZoCDZsOL&1LJ}@YC$S}d8=YaL3oBX4R3;Tf zITNNK_VPkKX%5nxsOF;h9iCGi7`ymP)XYbFShU-qAS-sN03*E5DC@yJ??J1OM+cfX z6YXNx{NTB%n1ZvYPt2UJTz}=BfN!sCQQM`$Dr3w2=VB6GNvnHNl*rBFYfvy5leTT=l=8&DOX zoQwiW-VX^U!3&0BratFqw-AOvqQ}9H9<`RoWiz5}{{wjbQ%e*5EVdORP-2($nE72< zU*-j!mCA|FZgia6zAdse{rN8@JNX~N6@J%hZtn4L2=1UNp`POODde}ekLqK{bb94AFx)27b`{lt}37>eS z!X}Kb`BQj>`(c+=PW(p&jM3aTXUhykie`&d%iv{jYn(J__6pxY-h~S*jFG=3?~+4r z0;v)BRpBi{-L8T7kY??}KFWp57LtspNMj|-6W|c)zZrsVIY7di6kdU+7WwP`Z6I2)Z6IN(aXfVDHBqcuudxsNe*eIr-db4@rwmhO z-rqX>r{a%Mz1a0kYZP_d3^z~rHYyKT{`P;&hA0!jDg)r8lvscEKPoniyE!0jaC8rj zswyFjbaIah{grw$m1t9D#}BHLlR@c^TQc4@=bQ_Zwbly20ACP6QV>ljYJ z21cjz`L)qeFR%!rigGsx zj06bgSdcJC>acu!5lNB2e%uq&)Bm7}y<6|M#TB@jzz2C&MacWMa=5|Gl?f3k3M~E; z@h~IL`-0BStVMCxiT6p2-OjR2>m$$4`*Z9s>KqShdOum!)mllV3lL=zPQaRZ zEitiFhelWAE)#*OgaXQhx#u(jA?^mux_9@oo_s#=ghFoG>Nz0xPsspiBl3qQ6A zyIU1Wl8P`T!1u2oWmBOW?rBx%uKBPqO7eG7?d~nZihN!N+)pGZ^+|U&OQUEci}y}k zY$ar*yR0hpM9rcmhxX1<_qaQCmd}4JqD*a?T1|QEveL&lT_}Upx?1;;@JUhd93MP^ z<&T;q;n%p+GjiF<5E8SLQcDuFEj0IF@lVolDp8lrPPNKs!8J`=urj0?I8wy;4}KMo zFYh3{x4?7J(T^>hV3(M41|Kmlc^}fs_paOG_x3|$Z~OT=uTSa8n&e)+aIZeLKbWx$ z%R_7r^oQ|;XL%kYsZGMdBxq(}=QFZ~o){wc!naj7J zV(!desqS?Ws+tlUz zkYkLX?9sJN1%ISv^PBg+;L7!LWm_ zJlP{-!QBvvOgsH~%#v-)_rE3uVk1JhYOv*^E8G!Exht;V_@n(HTQvplPb1|$pR9g0 zcUN9)^k^wWA*0_r?-)P==rlj zHJ?_hBbYCR5uThI_A}0jJeBsiiDh%pP|xfP!jWe#|FUTm14Oh?R?V!XV%*6yNZq1C z4xbFm2!7<_%lqh+Sx~8l=d8N%2q4LuObS`NQxs4n`-6Xe>%L~#D;8du)Hn^)hicuA zL#Jfi@FdWDVvf}7gImC`mE!>9f-oKkR<@$>A1@R|Z!?R(BJ^wbz7XN+;)*B3*>!ZK zWIr7jj8F=MvuGnB?y8KQ^Kbb3L3ZuP&q~Gk?bqLO?QJ*>is-;w>0Rdg??-T}=Rj5p z2H{oq15x}Vf9Tu;RfHO?N5IJPc?A$?mol^X)ORd?--C*NT?ty&9+e*1%d&sIov$s7 zxK6gPIfJ9P+{UTA1TSzAyjCgaa2SKOp^osfNJYuH^#O%|neRc0M^MjZnR4)GQaUAgdgP~0?YEPmN;+DCJ6DGp;bwvI8)ecz>y5(zxtnBfv*lL>mZDW zU;w7*`KP5GSEm91p-nHH+(nqw0_WkQ_zQISF6d}>BFHGhr=7Q7DaZd_8`=+Mys|(2 z;8i`mV$JTGuu!RFv5Ya~Ve+)^7B!R)W+5W4gquDI{+kJjZ%EvGE`mBWXlN?p`g6Az zwTSzkGecyL?O^wKdp>TuG)`I^+DT*UM-xE{y{mq|OZdu-oB06ks5|VL; z;CJVu-(N8mItjr+t4p9zmW6n*o%~LliluV=G?NbKyM)75>skBkm%;s}fg~6gN{_sb zRd)Eb;)dgS!;LKDBAk6FgAS9>+hF^XlQA<72qb?Cpbh6NjIB&&IUm7B@lW{}nAbo} z0fj=dk2A(_%}~TjTu?}pKk^tpUeCNsYNuCKE7p2^99HI8|D@I&A-Ko{gug4I{BwtG zKPaUgU4=WE7y5vz%XrhVwkxQ{c%I!>E#tC5ki>IsjCA1mD-Bk3g#4i1$7ew~>07$s zfBt*_snO!WjiEM7s?l5``{5K3QzMZPobRavxam@K4Y&ZlV4kyXfg0A3H@xritGgo9 zv)ZyPhgM)P!^bzXbSO z{GVo%p=ZjOwp{^PO%<-fNmFzS0dxt!@9y#tEl=46{|h?OAx#B`%AiY!dsu~R%0W5E z8&O-f8W<#lPxSt-woOn{m(}-lJ%STMs5(QYSC#| zC+n{RT0?7vY;jRMY2}j}^g5@^`m*F3wZO$MGz;ym!rZMoV zo~ugVMJwGG#$4SklJHE=5A4ymo(`!!R~d*2gC>SuTMLU5h|(7;F4`@;twNx=?+R&AOeOFw12bJdymjynCPqp4%8F3IM!Ri19?icf)kT7J1kUz|Z(Q zoK(YF=DN9_58v~RC**uJO9%h$k@==WTOgNwgyIhM7YH)U76n18T;xB|&y{`)83VDS zeW8?6wL5zmcy%qlJjL9h0neqE>>}^(L3@oqOC??j4C#HN&ZNww@@j)TZDl96BanuI z^NZ(*;^WX$f$&w7E}G%Eg{NYK3RyY~`e^rKms;>ysL0Xs1BmlF-BCVEc^AUSC76LoZqO%Y1%A1c~KGtQ{j3* z;^tu~Pu?H4`}TYkuYu$F^5jaJe^jpKr3}&2#A6$v3STz(nZagy)6u){2)1ej)5jf6 zl4OQgNk8oP-tdw4y)B5EVK`AntsfPU4-mvX1}G;~UOH!T1!_;;W?;>Qq%oSP_S#SX zl#4ALv@(h`m+TppfT=qVwzR-f8lA3?ZOZD?WEpFIK0bF^O~Of-*l>9la!?VPgzr$Y zsU!JnmuzM7ZZFe3iM^GppR8V6?+SbX{7Lr@ea!W1ET?i`3^B`eXd*$4S|ZVpJrIjUh>rbUfLL)*dzMkn7Xq_LqFUZ3f2bZM z9!g;EUK~}p+G2G$U z?Zv|cKc0gm+$HX;M(}r1r`7pADRPj`X<3V!rb-mKaDA>Z{ABTT>X!x$Qm!uKJj@e* zTSefw9$@20Q`~xDZwYcMP`nIl+AT2}IdKsb5Jz4wS6Nb<+BwySU!syw(Wubgg*Kzr zup34$V+|?{P^NN@qKGqMtOi0Xt{#>d(=;4suEa-d1 ziO#2*muC<|*lqDrRQM;0SWFN|3VMIqz15GzFA+se=+gElDbn4zK^eAwKv^C0QU7iNhre#pjro~-ifi(nUy}nr7}sFB`*X68FZX_Y zR!!@G;W265st!H^=~iEl2XelTXXcrJGZT}OhnRqXl97z@Eaj?QJIi`LC?eI^TE*r0 zo7of2fo*~MS-xUKmAo0>E!lD{umX>3sn`n6N)nxrA{dqs>vh4G!YIFC|VVt6+Ute%LPB z83MdGsn1YLC*yVGH32v5lef+DnqUqH1DSnkx+huOQJGk07=jje57f&k0;Y z+2a=VUt~U%Y)UJqB_?Zkg}Dr~Cmx3qhG!R5>{A3+2#zhOa0oJ+veik2@68ZMl&d(f zG8Pxb&RZ*AXWmSdWsry84qLBy{58BjLj^0v&|g||?T>G_JOTNy@iy1IMMj(Wvus&- zYS!22R9_h;0kx47m2VNRjLK^t5bhq!3d+b6p2ur@aaEJrq=(yP8OYkXWuz^h(y|ZF z+CTZKE%t)zJoDm#`D8|gpjnH(OwE`3w~N2LzEb_d7UuR!RGM#8Y<(3f2m~YkhQ1?( z=2OMVB-!f6^*?Vv^l^MqAZM5rY+Yt|=wz<*=`2GX2rT=bAN;XhM%nO%~B}>s;=&MGe6cPT@pKmqYD+OoRgZdjg^y^3>_`iA1)o;fwZQq{QL$ zYukBOuiCBaUrSiELlY^TIf-1`#M4@pkfRaX=i#$VXlL#}mXy!pRQTVt8;RblRn+E2 zpMgIdvh{7bhL)pirI)8$Aw#&(n{Kdm0Y2d_#$y6x7w7Olz!_;VPerxcXU5AKY)(+k zC2W)Av!`PVeDquk=dYiysxxt=ko--;;wh#fa)0Q!eG*hQ@HG7hS6Ra8oKDg$PfI=l zw@tOsI%)VMyBA%MrLQ&RE{v_(ZC3{oCMVi1MimXuP;PA3q*=Gl6>AdVUd_V785Nr<;m(f#(`StRs0|w=R=`qwU-=z14wLPW~i5hUxf+O7C0)o25zI zxp8A>!LUIoMc)9Xod->Si&I%%o)S8%cW5av=OtPGb5zxC>si|FSYx+pqjT=xMzV1P z&S}_@o7y?E;0u_!x+Y<8CyUI6FjV#A7%K$_`D^7GBXF&ojRF2nT@%2SGf_Z;u|zfs z=7_S_O;!dolq-c_Qo#=0FX5-LD30ukMC;pPuXLqLscPO@^821^{nMiKcjZwyQ|Zz# z&zHbz(&AUK660HFoX0bn$olF5GQWGC>QVD&ycJR%_Oz7>=$mhaf1{3Nnw^F$y_b>o zem!sxd8it%tEG9@}Yl~kWbQEU#XE><%%R~L*1!tke z!Kl(Vsf{3c%iTy>SMAK#smj=^J02v{t-ucj6*iqn!?)Fby$egYwHD5%*Cg0)l``&kLCJ%1R z!>3i%TtaY#Y?%I4w2Pvk-&V`*5L$zrdo$cHpX%eP+9$G4_;uue4&OC1U;J)mLEU}6 z99~OhtPSy6IA(D$x8B`TkKAT3l~CM)+R`@;4^r$02zqs^KRwY%REQjJO)ywH8*qwM z(yQUAi7^rI4V3)Ae_@}p{C8R8ZMI7_=*AK{g#H*y_T$Ro#V2P6S7zx(tw|}ZtNUHM zrFffU8Ph1t_~vUFGCOIHeK$793EzKTiFkaH84H^C*jTdb8mhfu2WD(% zBtJO6_o7?0F^`GovW-PpWs9Sd?cKQM;r_(Y{FX!XT}2wQ-Ao=z(ZHlMLvR}d<}=60 zbs6wUS8#~{ym&Ov2rE7zXZ7aWX<4K_Tp&gX9U$v&kiTBqiQBQMEmo5)ws|D)8>ndT z>sRfabv(24*sx+bV=_nFf2{my{BG*-9&{%|5`Cc;Ks~p&wa{OKxj4)bL*Q3Eq%;K} z%#@_`5XA2BOsHL7@D^E1*x2w%P;I=qXS*{ApNJ!L0;B|HMb2uJMO`>R~4Yla=r{6^dl+yMxfNNp>V`h^XYnETt$Gvl`14)&TKhn7 zxk6tBj`!^i(+?^>usc*E5}I6YQHQ@~Fc>vo(HI;GmSQ6|r_!Z>LeeyWJn& z0-G?}SamQ3S`HUQ?YE$&=_==XNU1l3+n;&r^l|M4gP`B+&v^?t5&h?0(gXt`v`}s- zGK*^NUAtIQ?RQK1{9SHzooMjFEt(T~k#O8nBgVl})#iT7fB{Xh6Rw#d>dmcBv!?qJ13=A>d4#{Hk%gr~@$Gfu)9!+NQT@JzW z3|uos%NzT7Z>R^V@hL!0-_fSA*2!Yu412gPG;E@Z`88vYYA~6Ii19yv&WXvhpZw|~ zJ@aaZRE6Y~$M>rnm5eajP&9BsT)~`)?o`I7oa6%*Z_Jqv=IaN#Ag*LaH7hV9gH@kg zAB0#LqyhS-(HjLB9xdNCb3-@DjnFbj3HcmyVvX}Fa2?^{Zr1SGSQRI<@RLhoME_2r|Or(ALed zuJ8!k6hluy2e?Xxp{iF!`D_RD6sNAAdI`SGs1L#3-DX#cG&l7uzfRR+w|Puzus-2N zc0};-7UuRYV>X`th2%bp{bIrA?d01#O@K`89bCS3oA=dVkDg=M%*iOnZg52q<-5rX zJVqn?1Wt-R6D&V^`Sa8J+JqSyC6TQGJA<2}M|IBIY-*rdu1^xQO^MdEDT~C#y&Z$Q@`dJS(UUlyiyQRVIuR)uA*Z)w! zkKe@$6|Pb*aJDH$Td-#+eoV7_bYd2=cjp6~++YHxj=-gXlpA*L+YG4Sy%U@I`U9oo zq6{uG87cWyUnmH;No3@k)~}fR^V($=d2{LhKF@&1_`R+@BE}H)yDf0+%GL$Y&Hpks zuBTw;`c>_xX{Q%C(L|G< zKW&==)duH2nEu`lTuq~}zrwlmW_8sAxOwrr1c||^&t*QF#pOwnEh?%}0e`L+Jrxm8 zSVq#y6Jl)0@w>%~DBJd^S3SWts;ma>UTRgzeKzt2+T460Bo>3MxM{NM`LOA+X@)_i zJyzw96;#)aMg%LLhHv0k62{*qw@%h-kZxnmI`x?INxDCmC} zY@}{UVd|5dKH$ zv`86dd+X*fQaV}^bSM|%chN-Q|0TkGy;rEWyx%{>EK?p_NxYZcCpNUPSbu`X>~yC* zRo`UVtq06~+KN9V8DHpG)zsAHfn1p2UfGC-RG>oPYU-LRAKw*>ZOvDVo2!)g4XXks z>?{A5=~n)A4jKIB+hmq>l}D^~?_RdXQ}06kwU5sWyj&-XTZL3~8`tss|I>{Bs>Cc) z!a80bauL%y&pKH`yIcQS@~h`;hs3$JQl(?wenEF2K9}!(%YO|@WHGJV8BMYCW2rGY zuu6n+xBgL^2Yac)d52@uOl=+QOV-^}yb-wnv^ex$-sfJn-m7tlC}tDMA$%sFnk@m8n+TDp8mcff>!O>W4-n z&RpdzMu|i}7d!#}aQvyD)`e7F(n8w#onLsoDR?DyF~X-3HIF#V%*7c1<}=R=8K zqpgrj-qmOJ#>CER?@j{(g(jr?z}p4ew9;9xLkYLw{o7}y`14TG>0?A>1#~`}G_Ioq zt{IV9!BlCZ~xMKG; z@P3{vJ#KM#y5y6P@o7yFy*LL-JNG+@dTK{iwN@;#mf#jBOPo-c7>dj_#{#v5QYr3u zAR|x#N;f3Rz5b#8H?>U~SeS4Kki87s9RxoO+HMU$TeQA^l4V2|82}t8<+ZJv>Nr(B ze*Hu!Y0ZcEtuEEpO6)BtsohdD z_DXFU62$o4dA;B7&*S&=S04`^ckk=EuXC<*p67X9-ZNrNc#yqPRLZ{Uj%x?UP&h1`JFLmh-Ei*dxG~ z$>H>{7S73+9cz8aM5GDk@RKWshph_|j9xUiLnT94l6pszW_Tf7A!1fCHFEqpEoz+0 z8r`{g6!`FnE|l}}md{Mgzm~#d_+r(nVRwFxj!|@`@mgackE$DK%hqM3-jv{b;y&7T z_hv6DxbISl;O(V^`)Mi?`N8feq+0>Epr=pDklH& zCoNCFDBQ7|v$0O|ro+zofS+)=NZa`xzEl zALyoVG|3A`=Hpc4T76OVA0|!-w&End6wF4CPK;8L~R7V zk2g|axkyQ4diG(Ly&yt6eT9@cB1h*AB|r<6`kL!$I?M^r=jx3 zpXgMP+35BDyVEppYd0()mk+|CmHt+7%3s@g_;U0uC~=ZhBSGR^mVVcO*Grw`oDDxc zGcLTiccoY)UjJEyf>1@Usy0JrVs1lWhV7%+RP7v8b_X?%(P{x6i_H%r&Oi3%;P>9n24 zi|z!g^m*dLUQJQK7-byH=H2w{hTg0p`0*O&t5NBf&N(*nUj8+K%=AE@kUfdPmNu~> zmC);xMwN`s5?t_OUX_PV84M>&$=TyBWL+AOtzx=57BoDLvoV;*ts<>)C5 z017A3{zG>)R zX$`I9c3^r)@pO?xV)k8GKp-JiQb|#$wy1yk5iUdG?i)4nJJ$j=RiC`i8o(V{y6teY zB>5hztOaQH<(yk_N4z${X|ll?b5?!GZTyhL5iKk*s@>k}T6F=vvB2w26^nrj`6lBEOD(@IJwY!e%8x?2!mi8C0k+ zN)LL`FQXw+@3L&~PA3<0RDWl=Q(z)p5}jgT4cS?!w-p|%@QO@xm#v3KFE2@`;SM$t z(#3#uLuqMcIthcur)lp0?51KjuW%e9ckneKGpLxa?khmh9ycR#+hS-?^U3}tSK~L# zGg`Mf#Pr%)+YLFm_U9ad5C8m2Exn(pQ(SK+bMTMOvCGIOR;5~LGKqYI>Wc$JYm!?g zj6f?>yK#&~1nfY1nCblj%jtb@&AJbeV#cD~vo@IY{KQ+ETg@)s{R@@ne?Ur4Gom|T zg~t#7Dv5p*RhyI4x&U3JadUCyYg7jn!p7@1kY_eY#s3^Xaz^3k*F~m`{=9Wz!9E@! z^h`2x z{>pyJFmG1}lXl4;-GCTSX#rB^qPpR`Yn&~P2U`Nu6t8ZE_QU0I&?BNgC4Hmiq<_hc zqs_m32Y2Un^5@SxKN5*G3bs4P8)Jv;|1s4#o-?gd6p>DGy|$F1ewQ|Rx6}~*0Xy|S zu)K{3bVpf0k8fV^l1NgZ(A|D-rPk=|Ig#$l+@}mO$E6ax*Il!j!6OWQuJpKw1XxT> z)K|y>eM{-JL$8kR8%PC@U>APe>Wz2(>jI0#y9STaFoR4(Xy~5<$To?_Pt>X`#6MFR zj)fGzriEY+8*ISqLhCt9Rm6%yKDDP$ulW> z`v9WSs5L#%0BMBlHbkAKb@Yr9x|E$L`#m?dqMG5$?{CEOFL%)b*oBmnd@-$kiyVi} zAWySx&?9w~sE^j%p@{~;OQ6|id%e#Z?X_@@PN8LY{hLpgKoc&gd+3hlX^tU;I!cAf z^an&kGqYEyDyw9tQaJ99YWt9$ej=u^tV4yOE?Q_CAiYgL>A#rVc!=LhA~(#EADUOLe-v$NDL+^c z#Jg%$_RpzVNf@cb+{k1gw``w@Lv%SmaM@?y>!2Qw?(n3dOV9tI871t8>J87Cxfz$z zKQN&qBKtQxR1|E5sXyTrk_dbRmwQ=9yn`>ANT_3ddMuBGcF6^wBi0RAw^ zf8oLB(e4x)i9Rr4n3RSep(6$k!sr0qhIv;8;E^0NByqh{AHtw(A@XavANvNM)= z8yl;D!KsGp(7@sipO$C^m1^vi595)%8MS!G-6h|wrhfuI{ixJLxn-XR zV-?8Ov|G28J5{_|%l;bhzSFkJ2ok(~K9MK@bvTPl8nFWZ92ftxa6;xnB`qr@m@|I& zH((kdt%48D7#SNj#8D<_Pv}{Gwlc;fMm-7G)XZZotUGrTpDH zmxk$>=u8GHAe6HuHH?V62v?H?g&v&y_h+l|A>I*R4*Vax_Cac=J^9(wW9U-Tb72vyZ-SYl>c2 zw`SB%ISF9SW^MxcTZ4qg43XTBZINPrq97=ruwanLwNT0UJU&#R0?+*L9}4<#066!O z2iHA3Rte%!RjVr*`umdKV(kf$)k*X+sA~?APPgB=wqLFE9YF%dGe>mwZJPRBc||PB z`K0=m$>^lnv;y*9?BlMziXZI!@Xk(IrOQ9=L=a+e&R?9Nf6q&w?n;38T%*}OjcX(n z>DEBc|EHL~vR%bC`_TkJZB~*wyFjF$WA--q&l&!^-i(upu0j#R?JC+ubPK9YBu;Q9 zgq@Ythl}pB(}}coL2Y+#lK2PwiGyocUIQDbCW>u22BH-W3FD=}ojO;~mPv4dL(s%1 zmGpZNIc_a$%u$Z=&WQ;J_f1Nf(jTo7_5AdM%}g3_n@LR?WhQ8^zXBNWI^RR^i@Pj; zVqIOyWF7r9tc&Nr+tQYzzXkt0Q-&C;GEECFtnwW>KYy(5J=5{Q)w6Ey=>8oezqYMe z|JyD7la$G9c=O+gZ~%LXVj5i&SJFD#B=oq68k-(V*)dU7<0K2uGy3WKQI9i5odegO zb4N>7n8J@!k*)}+rab#@jx~j7#Y3`^89tV^ff7e)c`)|eqw$oChO%MC2`Adlfk%R&8j^*T8C#sd#yeM*XEALWBDYK zWq}RgF-IV(Jlab*`}6SYUD=90LU(LpE*Rd=Qaim5;8|H7Z@S$m$c|TOf*Qq2Lr(Dc z&wC!XuXG+N;KSyJ$^4~2=phl1_l!!?iM78b_a6Og$3M8cC}(VSxR%~`L4mJG>nd;0 zh?jv^ObygYtc+3dyq~bOq@T`Z`l7ux&gsvzGx351-s0aer=(N*;?lJ)NUnpvinQ4O zxB!T4k}9}pe+|-vxspIzzKh2nQVK?LC z0XTDW;7b#IPcq4tOBh8JDmkfj<%4J7_1RC^Q~ zZNuU?_chxhFQ}dCd9)Gj+CI`*?$`qhJYknNL_aGQXb(gO@Sc$OMTL4q=_}ZKqDdLk zKXO)%#L2%zv`1ec&jIMjg)y~SM%HpADL2-CRp%EIL>mzK$Mcl@kgc4-{iD1MyQlxy z9&E;!6i?K?uv660eUR~teRCwQDm!YqNy*C3IA!4mDVrL>q%=G3(c{vw)M_5fHv@XV z`;G}Fk-woXqGNQF`E>D?M$zv+0|;#<*e5#HNyEx%KvwSpwrE@gXnkty^EO0vY+kU{ zn=QFSvb(b%OB!kTx6au%`=e$}!!*pVzj4GgrDzxv{<55r!XdI4OV)$^?$S;8^!vId z3k%0W+@9-1(&=EivnVjZB>12FvQe+a@jBLNd^wDa2!I;^ZzZd8#)5?^_XilIkvC-* zzemPoHc>ODi=J$N#bw)bcAi4fN|qXqA{3-fg&D;zr^B z{ly-oAwZuV1_UWblqyaH<;l_n1s&i5oEu5*`~MZFJ5#hVv0f0;GTFFbO%r^& zBjBrW80UY3V$lc*C>43K+tmcAb7n14_o18pSk__^u@a*+J+_B;DqHHN<}9D?{@=qY zX7~{`BodR`z*NBOPwu?z1|&cWyWe6pY_AQ?vXB-Gv*28AtjJ`?N6oz_%-EFwjaLY9 zUXuiFDr%($0?a(4{z%!za}-1!P7BEADc%FGkUZYVz1GBd;_dYxWnaW$JQmb1>grI+ zl&njec*pYAn5Yfj*Y61ZXMUB%AMc6gwG#2DiLlVgpL$Xk7yI(Bxv~E-F8Rhc$XQq* z+MD*DXy$(u?z6!i$-a(=zwEHMj1sG_@M+O2S_#>mxmNEZ*7!qchySi)fgQ8>@_(Ce z+b8#?U!VM4tT5OUe`VnGM62|XWoN#2ZG`d1a1FYIut;h@r0o9x;rhj{Kvq#&x44Vq z6U8O;(8ulmc?q|jF}om_p`b0L$O{lQQbDHwn;BNzz593uKCuT7=mCR{y48o%_*p3iTWbQ zw0dM^m3Wx<-z2{LXh+G`lJkDv%TpHrUgw|xe^oeYxx!y0o;99a^pmomK1w6|9~}NH z8&KfUcI|%cvXd8M#BIg?XI9VSdlGgmRw?oL8EV)+Vv6I)M+?_7hMP2%E ziD^XyGT^^hJ_2|K#c<_0r+MvG>Wa1g;g{ywXNyf0sDe$H7rc=AtXEZMTzfb~ryGXC zWXO;6ebWpku4pAEny=}<^KV+U?)*>P;gs(gjpB-#O0ufn+&kaneah#2ec;`qmA59z zlG~LOt}b&&89#5a1fo6lAa>sF^%y^xv?+eZ-+A8ZU%+{cV5vJCoSvxviB&pfNL}p3^CZAUPkT zf$}6mfqwx%%ISYhzHEJ>@F(Y_s)XzotFzDRic={k8aXQNzh5pCS$CgG?pEs%&bcKL#2Lu5gMz-OHZ&OumXLQ4@ zvIlo^jQ+oMD@W)_r#qzKs&$Isoob(cc8g^ZxquB@`I=B@+UR>o zXBIFK$>|i~?dWB>i}Xoh{7eYI$1V>&t{FY=p# z9GZ3i?0)Z5zp>>y{95Ngxw_xQpInz#nyay*8uA^;5g$C|Af4WVHJUB-RUF9Y ze!QWdDfzn6?0>;aGd-rNVGYtMGM`)x7_P0DpKY6U& zb09jB!qJ=f-wKiJ4*(aj(2LiGe@zfDt36G%`)rO=?3_D?7qAFa5$4@P&2}^~@71k*C-lI+O$bG9 zw)3CJ(g5)+2eut7Sx?J#a`Urf68Rjdn`GtSQ9C9Svd5p zAPzGQ4soX4CL;CA1@8lvRo;r4n9WuVc+~x-ch?j?cckV-`1QW$iTl)()la`}*rm%m zsKB@27XjDTU19#M>WI=;(|781-~n!>Hb^ca<^joPQhthtsfl@yh~Sy73^OuwlwlcN ze{TY(PB<-DUuP$Et;{AhO)Kv5SyryYm`Ha>^=Ey28Gkwp^Uv3?nCMiGIEKul*6}O| za{ck^g@dVBhCkTy*cxb7is>Z5)>$Ye2911ZriLpw6AsVQUKb-@=KoZh9BCGbVZ-;* zPD(-f{YnXSHy~K`aZ&AG$6IRO_o{nnnXbJ6GxRckBnXPZ=Y>1 zo#Lf}yLK$Ime6N}y5q6Ed!U9BUNm?&1SyXyloZqu3Kjn|=X09C;Ni)$&+UAfM0ZCi zKxqx|V4uFMJ|8&nSnPd0`buQxlMQUdtEVqU?c4p0zb0l|`asqA$l|#M(6m^J{dBJ| z54~2S@9R__HB_*86wyMxWh4P2znG~>Sr#TE^4i$KB zxSBu8pwo$CV2y;_UH4Z>ze2-ml$XR{|M3?c09-N>9?S*@G#lBdf;DS|Yej%h;hW*h zp~JpQ-wj~wS#Mj*oiA9XCbiNWsVuF>=+tAC z6O3OPrS?n%>3G1DRhhhg$b_2RxCZ7W>(iH}gac(C{wI>b)1#oo_M`}26!gFw8$dqb zfiUiV9E;dwOlpfdpL!h|U$&T;>MpYUu?;4#k%NnedCP1lX0X{+}#l-Kz>sQYkv>QSizFwj*1YJ)_og z6<_vWz5@JG5sJ@YISEsT4xl1JIKwvLUJ~y=471GXVVQM~o8hxk;LE`}R>UVN{7276 zbb%S)!sz0`-c}zpb`u8iQzV`q4_{m$z?E@~_$Z*wqCB9?4;LyDno_JP@98X*S(u6m z-n<9pNIzK7AAz(n`4vHhN~R{si&bY?SIcnS^t)~4CK^ma1b0v?K7u(a_ZZ0lu=vW` z@b!VcIk~o+^6j%B3jF(h>zA!Y=3roCuE1NED>oKIxPX3j-Vr}Z7($+CUB4HL@qEzKgys{d{TII&*SClS6=g%PDMS!ZgkCaF*x_vAAy3^{Ldz+_X5)aELdx_iQ6y zs?LKk>#HTmh3s^{A2lxXF)8f*bC6-3jUYfCEz=Y2)x$Hkaa73DFk3Q{M(?!F2436o z7$C*o6rU|K?qpm0Mb9}MUJ&So-E#racBFJ&{TbXu5ZvnuwTrqOKecm10Zsx{V+A1U z0a8VBGe0n`b}btaE5)(X;Si3&!V5nKyvsU0nBrf>FE5uJswC+F(D(KMk}CvDLOD-w>UoG7m)-e=9fsU_T-rHY!WhW$nd zi<4Qh-fbbAJ?_Kk{>36gw#|`RpBI8`8Tzk*+PyH2!+d3=dVK08>6q%OpCjAEuzQ}H zCgupYHXzV2&s1-6+~2&mL8@eeRl#5qv^|XQAKqJStF6tvA9tGCTp183*M#Ud7axl* z`7`o-xzHdeZ_c%$88zpTzll?Ei`fwFHGC-gz>Gn?e&Z%6$nA#KbB5W9d4(9RVk5kJ z9;xDKSzrAdtfa>V^TW+U_Pt7Rfd1~-(_eQi%KDcPuaQ~9()9S;Sk*jdWkzR|A2ob# z{586RfdhWd=A&EHSN`S*KUWhzeOIG_WJ2!X!oJH~gaFt(TMQT5e#q`+Uw9iG3!|nk z%yM$H_Q;vYZO4uqi1lXyr&aV;PraYJ&P_)%^nYjyYioHnL?1$lcqfl~XAeGRFMj@R zMj$UZ{!+^D@X*PnZe@|;oR}Fm?sekV!YSo{W{mU_^L00RTYvRNNx{5l9(S%SyBqTC zDw>?~(PF8$Jtw>A|X>tJD7UqIz zJ6_2?A@MS+jGG;}v*=~}aZ?Rf_{?duNV2de!^R{P(B6b>5f2z!E(ZsFYPCZyZ)6XP z|NQ8X*me@a_G0w`;dLG^1e}*C=(RzWT9mzh#(g=9$opyL>hWO$#(rtUSK7+1Qpbw5 zMyY!H0gSvyKl@K{l7SoeopAR+bxH9Q@G zR|FF$Ih$?6I_^wOEOpJOe06tU*ALAEni6BTL~g99`w~iGoe;sA3f}(v)4-vy$n20o zW_Q~P!UbpmB(Qw~yMZmR zNx}#S()Tii)5&75LurIOpLAXq1-EP12Y(2`ls>LVZ$jbXBqChB#nYGU*;w_gUqJP6 zVG|5H>J?6yHD<6;9XK9#Fx-ApQn(ClgiORZ#B*4E{zz|i@q#?VF?H{mKLIE8L)v9` zQs!0^`;6|s;LI_4X*%91bLRc6n2D*BqAZGMYID_NS^cev_I+-kv2e1{S#frYF1{AA zj2GrF+dom4lpm&&pJE~QpjscT7;DK5{kdjCrrG`SGqZ=-Fa_nEKS7)hAyejB`OXij zp|p5kl*San>^Zb065F+@7lV8>=3;-0>Ql~f3VX*;Eof)eSo1hicnQ-CQVhW#BM~>1 zZ(l`Es^*tMj^~P>kShauj*>FUkY+v+G(rNdJ*By0YBu6MjvGnCHpy`{!2w_&>m$~& zXA0%%^f?Bdx4NTu6u0>|f@B#oIg_uZW<*nsB7^yCN@WEn|HaP-7yIk{`nm;0A_y`7 z#C@{OO3V*~w*5Kmx>Hy4a-3`zvOWBb{k6QqbD&&j3P1>f8xTiTg2Du4XK+hQVr@&8 z>F24&^F?1h4qU_;Nej)h(L87RGo(J5XX?4PY3$@BtT}+jW8X+l5@;^7v3hXQouf%a zpP!Bs?DszF7sy{$LpM>oF@p}^{ zgp~c!af%3r_kUSQE8EnI9Q@wMJUt>+4vx7^&wruEOnuwAIJi__wN8=$yZ4(H%57OR zSJ-!KRW46e=%yvHR=MJoutXm`?W0tG=Zd>3GijtNFPE$1VL{F}>Rw>INdRT;_LZTd zr3|W;_y;xT`+rRXiOa1#_+L8}i{@+!p{^(YVgbZ|i<2_c5- zD&ix=yGXNdf^2zpeg=V1e_3eC9uWl%QK^vav*2enT#xhn{G$(q?cS~5D4s60W(SnI zGa8zNYc=9=4Ja(gX9J~#=HbpNtFyo|gS9Jfe;%!-;jHs!3Kc3+UGEc7igEomy&AS@ zyIui)rYMOv8f6Bv)@iqv)!fFaVM89mPowlfA)(c7G-O`LrM@D*Z5oozqw3e#jW9Z( zze`K4(?dk#d-=nP1#PeaJO8IB;fR)LWDvuw6P9nYnv=pUS$5J#)g~t$_+{qi1y^>l zE?AjoDf^iCFiM=-?`}+Fi)HSS4v(2&5gC6qJP{8U%(Vdw>)rGFr@R)Itm~zS`~+R)P4$+gZ7cj`s|O#ZR-+2sN)mId*Aco5jL{gI(5c!;R(MOz+(-GXd? z6GH)c_G%3yYg}wv9D^(;D8o4`KA$EAbMEUe+Zfjn#}^E-2<+-hEBdQEwfr2g0%p?U zEChOO))@;2U&ixtab*)EO+}hPPfj( z*6GBUN^zjBngB2CJ`hHZ8#&Nj!Ik^UgOos=uu((*^~vyxY2S`g3E<}FiWkYRkWx_g zZZm<6D0a2CmqKcv?C}mXH9=P`2{~uGM4g;BrfTx7^^T$eHb>!;F03^-&R-K@ zRW}!3ri<5Z29W@7AvK_-y?x*Vk6Qnxr5T1O>>bIC$OB4EL#4SE=koDiEf=663b%R* zMCHI~$@*#^M|f}Y8vV?PEz#2|P5Gfr5I4A4^l7A{loF6f7~#H@ zMH^i5#vjkhavE>sy*?TIeVQP#9;x6*2)f*R!j3Lpga)#F7DXZVGZwutn!x=giF5ew z#lP(AZ23TI;ZgWpI+Krr-;>M6TGFI^+os=m)=P@pA)TC%$q^aIUJ zNP3*}`cJ)k;yqiBJ_?QQPO zux0i*vK9((x31$FIRZ1M>p!PX!;Vo@W-!X*nCgSLQj7hR7_7C5y+DxLF3y*f&I6xT z(!YAOWU8ShBG7udA#HvYJJ-GzbxPd2`eJqD&(AMrdtM47Id9WDdCMBj^OH*+k5)#F zopjwv_+4t1U_;a|fc4yd4R!>7(<;L^=4$7KFMV`fQ#ZeOBx(pe+v29{TH=2cXN>gT zRR4`HA?qErHI^Yx)FRe)nwuWWNWhEeW1nm* zVe_N)V;%$bCa-w`c-|>M%)b0}wc>PP%OQ9iByalM;?0LAFOxy6kAFiWuk5hgOSss1 zDZ%9f<1eX^$1W~^FYVv|kicz1Bmaf@`8(vh!Bj~((~0sX^b3U+{mrc2EZ2#V@vP&< zQcuPHUN|8q!mUMhG$5Zc>BPtUun<4I z50O=P^(+BJ9`SPNeW&-mld&|lt4qJXcf8E&WV@nd2=!4-k19@bMd%y$g^wY!x)jgg zoD3`tSls(Xc)34LH)X)CaxL^;!T@b{$QF!@y6{iapGI5p_2_#sMrL09+C}P&BGxuG zT{#RUDUs#w1Q>SHR-8(bd`oZn--%3DuD(sp7RRe-%}u5rM@Vbt{{Y@0C)OlO-4&Fp zU0Je+a&d9dY%p|lj6(3~nr#_0Sjp<)6ewOM2WiBa{2IdSuNGRqs{gzxi}8P-`k-6e zu~I=-rflYA1+`fu5-*6B8$&cVMOTF9^gnezUR?)f^z^w8t7IMY=($qYkLw82MQlSZ zR^){TO}$lUh+f`a9a z3hsFLmSM%(&cWeoC2S`3N%I6Evo$h2H2RVf;XT1ge|w_5O0`=~u6ksJdOD<5zcQ6R zGwKUsI-!R%iqMqX*X+%)QF(=p@CuiOWL%zO?UiG{aQ>~*=^yMF1w7)``c>fjN>@|L zNaBy$`*lwv*Y}q4-+*l@RyyX(%TrdD-T^PjGdv&7$t`Yye2={htzDbpNG34RGToRQ zy^l>f*0BaH(uH9ip}c5X2<>YtZ4Z_jQs_WdAi9qJCCe^{dclwl4UJgVotxJl+_$H> zgN5o~*y-vu^G@~9ifsOBk9d){kYxoWQz>dpwzbuXs1J&3OS8n-~Ql9xd*kP>yQEVV!FFo`)ys7chT#=T^ATfD3;G6 z2mbUvi)z{*o#$JhjPN6WGi}&xCz4TACsK7u_I~7srq(q(v#DL)lQUl?c;y)$v+m;V zcZJCLG5P8Gv7*r&$qIW#O)0olkLll5!e%FmU!F|;e$-Ku5GwaN1J)I0`I~Akj=C~0 zRuRMv{d!G3b@k8JI6{}crygx)9q=XU0TQqtWm3S~RdLC(OmbuS&l%#80Z{FcZYUiI zH>O_Pcg?$r{b*z$(0@#ttWQ@;$AfwJ7rw5tk+C+rZ-FpIDsA^>u|x3D=IuhSO&GS- zrZL{2=I;$JqC?q&y;>4q)c_BFVKWG<~VzK5yC^9>LDiD*KKXXmcCy+{MZ=2loBkmKAAtxw{QeoT|3oxBt$kZ})>xS=n#!#^_7B4TP z=BG!U0e>5X#F7o*p@N~8C$HVi97*2TMc<-wQmzGU{oX7bH5bx%{f%^FzaPH#vkIoY zSxb7AiYpJ?nre(V-58tM1^!ZUm`9ey9_fe$6=(br#U@|wxTnSERp(t{DjE@L%ztJoso@s{uptJG432no2dJHCt|i& z4i<>A3a#mXyZ{p^-47HcANL(NV;`@(>Br@wcdT2dxINc?ih2(1@S&fsI>`PM7o4BK z$(D|afktR%=)=4td+!5x{9D0SSK-)QVa4n*IeS`r&2YbpJv`Yy=)6MUEi0c^&$;I} zfG;CyEhX(Y)f_K28bID zlv-|cmF}eIFTRHk0jW>BCNX&Cf&EaTrB9 z{`md+!&mghjAnsTr&`-7Gz<4J`3*wpf5c25UhGt4JYme?gZBEblZhW`V2rc~hJG>; zer}s)8!RJJEkm<)5ZcFEnmsgwsr$3bI$H8g+d;XmgeJVcninND_96BHyfK(>yCqby z>z@EoicILM_dZ!;@UV7V)MR+Wd|tG)&#?`|(Ye#(qgR-lW!iJcs_VwIh>OlLgtxS} zu$LqQ^PWF5S{U?b(>fMwT089N_ep)tRec_~6>6851fEQy*YGyJB}Xo-BlT4ODfKY5 z-r$~ypD+nGP;&E;WW8b|(lWL_vW$bI#lFv0v>Y^$at5rmT0Fg$A{`p3#S3AbOp*z+ zi<5rX?Lg*5)Blt!ey)DD33F1s`P8EThJf-Ri0G$Qmhwot(v4r(aS4$DhXR)Lu?YR| znrrvZZNqf*$)~h*$4MJBjnQuJE49&S;;GAqSnW_5-$e9`+qpdQ2Zr>Adv0gcm2$iA zl8r^*v|VIwEzeQD-?$-+tTOeN@h!4qN}jlE+AS2Z}FD=~l=vX-;ddYY%5N z_I2u=N?Uf8wDGJpi!hXSq|qY=_bT=WxwTj3^9ohbatPo|O+3>oiXh;l{P!4m5A(;> zCNV!tEzg9QH^6`VIB62cn*F3wC7*&Vcx!z&&~p9W`{q(NDnI$W~3 zI3NQlVhmaGlrR3Uc@E0mEZ}4OogWrx%@xIT#ATwGd*&03#_WplRj#4{@7sQ5&I;_0 z8XQO2Ov>4DJe5#gRDM9m`U6x*)%Ko*$ktVz{L~B-FJNvG#n^Azt#XP2(5Yu6te1` z->H`>x*MMgNapE`j)fL~h$`^(5+NP1{HEJJzx~BiTmds+A2CV_gQ$pFix9UfjlXzk zk@RK{g_dDkHE9uf_3}ZdbiM3c03F51Xnua)Lg}3LerM6e7iMQdz&1>yty6|cKtC(1#gNx`tzQxk*WoRqzH>G$+FluWv5iaK!n=*PT zY(6-im9r$F1f3={s@d5`52RvGEj!Cv(~_p6EyWw;e-3o&1vWRvN5=ODY_yNx zukYO(D+rwku56c!Iu7G9|641bo)q#nc5juT;lung4F$k;SS$M&M#d5 z%Kcb#NHObY_}}eos_5nu>K!4$VhsurNq@q!7YutwX`&xXaIlIpo{F1%EE?!lv!^Xr zo4pP0trXgqZWXBc_BPamadN))R9NTE$8W(<-J~fWR*6mxj8w6bG~`u(pLO)Aunu33 z12bIq0HVXP!+xdNq`n7Z@_UM}aCGjDUUK_kZFG~;=-sA{qI0}%5iedyB$2CVY@Bpj z)_B0bY*q<-O3uSeP-0j(Gp^X2h~YioT>L$7P?Fn|!JoBRza};m5!}C5G4OF8;hVGB z8ECOQNVCw5Nf+PT`syBPmXw4eir$T`(o6Uq222%tVYvQoT6eP!w)*5N)|m|DZLMPgih_ZU65HW4%UTrfVe^`9|%zv{`pY71MGpk zC>~MpXamGZvw0DQ+s+RSpva^{Kt=tmm5*OVz|Z$f6}5OgbmQ@So3Ct{Pt3T&QF8$@ zKaz`%IAij>DY{T;cM1Z!YM~|Xpd__jaC&0D7&_$wMZDbU=cPS4)X{hi4FtOXDeUjg zW5;rnHzppe#T+|Mb}hW8KgrWgBJ1SFxaHNi;J2hI>6-xiFz~j!=&+}scKc{M;v-mk2Dr@f}%j#F3r-aSI#sj(I>Z(mp65L)j|J}hI$P~Od{?0U;bkZ1B{g&7&m!5yd@NUp!KC4*H5yn~G^^p6yX?*=*RVv?M^@Po=P`ROY=fIZ) z&QU+FOMLq6Xyc=C2<170rO#$qy1}-*SUPP=UG)^PvSRIIEmWot2-ZEm5uS3>xlM)d z#pb%eghL#6-?DaIbh_#@#-5OnQ0350Rn32kd~7yb&))t@kGL(x_8~zv^^IkFWX^N9 zxpKBfO0booA&#UGWf(@8z)W>*T}tC!40GFaZp>FcfV43e%dB$3lj=a`(Vog91C`1R z;&xD0o&1$ZND++_Yu~L`Fs!%;d7ypb%qKc08bs@%EYr90ubYj4P{Tt5beK&(Xb;D* zC05ls!KrD!O&{K(NM8**uF7wlFtU%2w93&S1bvmgmds9yuwR-89vEtRI&x|Y+?AP6 zxsSuA5ahiKPM?|2J0TW{K$s|cUui`z$}gX3=fnjwMwCiSzh4)&(ZfJ-~inP62rQkiLHDM*In%Ni-z5i_nx@mNxh(MAm^$- zO${4mkd zN)VPMs!U#W=BvR#%JLajU^}-46gpmhr zHtmI@#^&Z@;5Iu1;)K{WQJCXnY^cYo)-2m7sbP%L+#iIvynRzM+T(l&HUPY{|7>B$ zq$sIqvr*)kLM216#T?X>?t251KkT$wbapIC>Brc848!zwZaN*#UB4-(q+>B4gAtG3 zQvv2#eJ#z*%hjGH5#^PPM1NLz*22DGf=euFJtz2X818KypTGK*O3~MQD*yg&!rlhk zo>gvarWuX7OGd|O{@UKJi~J^`{{-leF5R_FjBMT-Yc7bRKvD{Ef5ssxg9eI>S8J<> zFtKUpx@)i=qrsfT0fA@p^4f%vO2U`(-ez(DMyK~|Pf4NUTi;aVE#Fr1b?;w~P_Tv@ zZwOYJ)n%aQHv~=ja%+o**x8(oJLf2_xe6k96u%Z-M9TFI<$aS`<55xwmVHd;*hz=@ zTPp*w%ImK(1vA3CY6GK4F+{@}X1#iUVeK#Gy;U>fA^tTSg=VaJfPvq9`_@m|PrsFi z{{3_wtAC5Q%dmY7FMN+=q;}S%y5CQSq`sYEyGfP>AFyxhLjnrw&tPJcC-bm@T~90( zkosDir!jHn)h)AQd2u20n+)e_-iLnU??HYIwY|Ge7qu!#;k;g!UM!#D%=$o=HL0v4 z%9cqS6k0Z&W3^Ogj&w-&Co_zh>o=N1b$I7@j?aWfF4v}26Z?xk; zmaLw@Jo1kwIdz^DDzxhqbB^-nG(Nj;SKM8}>Sz9jaPmwVfu~tOjw17&`Ko=U>?t8- zPY{{g_Ny&iMI$~a%hNjEF==d35WLtd)ae7qbfQKF?AX5OaEv>{Zn*h9IWQpmr3PB> za|^w#^ReMTd&rw$Rp^HlTyDlTJ7Lk}Fc=gMZ{+YYtEUM2w!QkIrp%j2u>rzt^Io>^ z6sZBcWnLNmW^j|3SAV)o;PAn8a(mR)W_}>c_C5B6VEmaySWCsuSR2%L?%3h()2bNe zngXmt>4p#_F(%fsGpRlNMopUw$CE6A?3hlFk{mfg$8yW3jMkj4#$_g`tUmc(P(QG@ znjIXg;~UdL_Y0F&{KJE6%Qbuy(s=74CYB?7x{ zqEo|m1@&Q3ledh2%TsWQQlTjmYdf2*=ZyHbnV=k14d3xADF(jQZ2k}xvRHB9sxz2- zh}R^u1J;%Gjl<T0k|H55{-fLk6q7$XGIj@*7IOgg?QI1sTb5)6{O8?;vu$`7-N3+ZSY z@NXox|Mm*nFp;lkXq1v{ak5LU$!r zH@B!f`2=X{p`p3ZWr3nU9&+;EW26l=pb2j@zEHk3oheRPy}jP#%__A(30MtS=Xvb( z|GK*JcqrE|F7Cb34Zq{;ug5fXk#SsNMKG*M(r*(%M#wOlP2>ma+D z+_Epj$d(v$F?SeK7&FFw-!k|2`TU+gXFlgW&pFTcInR6E@8_Hc>MOF`2+va9^OWv8 z2`w`~qJk4DfUCi74smB@_Z~AhA*q`Q>!qr-yUqp#iG+#j1YE3q`9X@ZQhG+oC(R>% zyL65v;Coj;+2xM1ud?V*O(8BWf*L+HZfG(_t14SW+?S01TQ9mp>yBzKyu8GcN$Ns^)z#sLx2 z1*acQx#KoWXkD$PP@E>JtRCM`m%%jOrr~92t?a=r5{aa6-%uX#fJmD)`&EEC{z^)B zmAP{R^r^v*whpdi%GgPaBz-6XjZ%PBS=_!^1r>Ig&>SgsZKuK&OAQ|j*uBX*g{k^s zZSXKBSy;Vent+Fs{(Ic@Y~$NotS2MkO)`$R=(0bANDWR(X_@M{+RNCT9A%BM-J-Hz z6aHd|rI&RqL%mbr^{Q}9$+CmmIf*k#vy1VVL{t*?^Xf@W7rA97?rnZ@>DPAIk=x-f z7vO#idS!(*LZjV88O+0F&o1`yx7&5MNI9u>(bnxRu~V!V-@P1}WVI3D)dOLN?~NV1 z`hK7yY9k5Ahq$lxY24)>cNOVv4|sZ5YdXgopPqhVvxXn?ML7YRTfZH>75vxq7=r8xum>+5kTQOG>LsH7H6P zIDf~1BIw=Jc?kG1**rg;>>kPEX|SLxF!itXA%XKR%gW~2^=Ce?qvkT&AV7I65S@xM zQ*!osKvMSSQa<}Ab^HW=;21G?b0fuMI6?e zWP-U1kotV@GG+d3=x�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%0DH0g8QJG$>HHYF>2W9p{;O1SREOQ$?- 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 literal 0 HcmV?d00001 diff --git a/eo-flow/requirements-dev.txt b/eo-flow/requirements-dev.txt new file mode 100644 index 0000000..9fe6bf0 --- /dev/null +++ b/eo-flow/requirements-dev.txt @@ -0,0 +1,4 @@ +pytest>=4.0.0 +pytest-cov +codecov +pylint \ No newline at end of file diff --git a/eo-flow/requirements.txt b/eo-flow/requirements.txt new file mode 100644 index 0000000..19556b1 --- /dev/null +++ b/eo-flow/requirements.txt @@ -0,0 +1,8 @@ +eo-learn-core +munch +tensorflow>=2.1.0 +tensorflow-addons +numpy +marshmallow +matplotlib +h5py diff --git a/eo-flow/setup.py b/eo-flow/setup.py new file mode 100644 index 0000000..ea60fe7 --- /dev/null +++ b/eo-flow/setup.py @@ -0,0 +1,29 @@ +import os +from setuptools import setup, find_packages + + +def parse_requirements(file): + return sorted( + ( + { + line.partition('#')[0].strip() + for line in open(os.path.join(os.path.dirname(__file__), file)) + } + - set('') + ) + ) + + +setup( + name='eo-flow', + python_requires='>=3.7', + version='1.2.0', + description='Tensorflow wrapper built for prototyping and deploying earth observation deep models.', + author='Sinergise EO research team', + author_email='eoresearch@sinergise.com', + packages=find_packages(), + install_requires=parse_requirements('requirements.txt'), + extras_require={ + 'DEV': parse_requirements('requirements-dev.txt') + } +) diff --git a/eo-flow/tests/test_layers.py b/eo-flow/tests/test_layers.py new file mode 100644 index 0000000..3ee19e2 --- /dev/null +++ b/eo-flow/tests/test_layers.py @@ -0,0 +1,47 @@ +import unittest + +import numpy as np +import tensorflow as tf +from eoflow.models.layers import ResConv2D, PyramidPoolingModule + + +class TestLayers(unittest.TestCase): + def test_res_conv_layer(self): + input_shape = (4, 28, 28, 3) + + x = tf.ones(input_shape) + + for npar in range(1, 4): + y = ResConv2D(3, kernel_size=[npar]*npar, num_parallel=npar, padding='SAME')(x) + self.assertEqual(y.shape, input_shape) + + y = ResConv2D(3, kernel_size=[npar]*npar, dilation=[npar]*npar, num_parallel=npar, padding='SAME')(x) + self.assertEqual(y.shape, input_shape) + + y = ResConv2D(3, dilation=[npar]*npar, num_parallel=npar, padding='SAME')(x) + self.assertEqual(y.shape, input_shape) + + with self.assertRaises(ValueError): + ResConv2D(filters=3, kernel_size=[3, 3], padding='SAME', num_parallel=3) + ResConv2D(filters=3, dilation=[3, 3], padding='SAME', num_parallel=3) + + def test_ppm_layer(self): + batch_size, height, width, nchannels = 1, 64, 64, 1 + input_shape = (batch_size, height, width, nchannels) + filters = 4 + bins = (1, 2, 4, 8) + + x = np.arange(np.prod(input_shape)).reshape(input_shape).astype(np.float32) + + ppm = PyramidPoolingModule(filters=filters, bins=bins, interpolation='nearest') + + y = ppm(x) + + self.assertEqual(y.shape, (batch_size, height, width, filters+nchannels)) + np.testing.assert_array_equal(y[..., 0], x[..., 0]) + for nbin, bin_size in enumerate(bins): + self.assertLessEqual(np.unique(y[..., nbin+1]).size, bin_size**2) + + +if __name__ == '__main__': + unittest.main() diff --git a/eo-flow/tests/test_losses.py b/eo-flow/tests/test_losses.py new file mode 100644 index 0000000..415c34d --- /dev/null +++ b/eo-flow/tests/test_losses.py @@ -0,0 +1,115 @@ +import unittest +import numpy as np + +from eoflow.models.losses import CategoricalCrossEntropy, CategoricalFocalLoss +from eoflow.models.losses import JaccardDistanceLoss, TanimotoDistanceLoss + + +class TestLosses(unittest.TestCase): + def test_shapes(self): + for loss_fn in [CategoricalFocalLoss(from_logits=True), CategoricalCrossEntropy(from_logits=True)]: + + ones_1 = np.ones((1, 1024, 2)) + ones_2 = np.ones((1, 32, 32, 2)) + + val1 = loss_fn(ones_1, 1-ones_1).numpy() + val2 = loss_fn(ones_2, 1-ones_2).numpy() + + # Values should be scalars + self.assertEqual(val1.shape, ()) + self.assertEqual(val2.shape, ()) + + # Loss values should be equal as they represent the same data, just in different shapes + self.assertAlmostEqual(val1, val2, 10) + + def test_focal_loss_values(self): + ones = np.ones((32, 32)) + zeros = np.zeros((32, 32)) + mixed = np.concatenate([ones[:16], zeros[:16]]) + + # Predict everything as class 1 + y_pred = np.stack([zeros, ones], axis=-1) + + y_true1 = np.stack([ones, zeros], axis=-1) # All class 0 + y_true2 = np.stack([zeros, ones], axis=-1) # All class 1 + y_true3 = np.stack([mixed, 1-mixed], axis=-1) # Half class 1, half class 0 + + for loss_fn in [CategoricalFocalLoss(from_logits=False), + CategoricalFocalLoss(from_logits=False, class_weights=np.array([0, 1]))]: + + # Compute loss values for different labels + val1 = loss_fn(y_true1, y_pred).numpy() # Should be biggest (all are wrong) + val2 = loss_fn(y_true2, y_pred).numpy() # Should be 0 (all are correct) + val3 = loss_fn(y_true3, y_pred).numpy() # Should be in between (half are correct) + + self.assertAlmostEqual(val2, 0.0, 10) + + self.assertGreaterEqual(val3, val2) + self.assertGreaterEqual(val1, val3) + + def test_jaccard_loss(self): + loss_fn = JaccardDistanceLoss(from_logits=False, smooth=1) + + y_true = np.zeros([1, 32, 32, 3]) + y_true[:, :16, :16, 0] = np.ones((1, 16, 16)) + y_true[:, 16:, :16, 1] = np.ones((1, 16, 16)) + y_true[:, :, 16:, 2] = np.ones((1, 32, 16)) + + y_pred = np.zeros([1, 32, 32, 3]) + y_pred[..., 0] = 1 + + val_1 = loss_fn(y_true, y_true).numpy() + val_2 = loss_fn(y_true, y_pred).numpy() + y_pred[..., 0] = 0 + y_pred[..., 1] = 1 + val_3 = loss_fn(y_true, y_pred).numpy() + y_pred[..., 1] = 0 + y_pred[..., 2] = 1 + val_4 = loss_fn(y_true, y_pred).numpy() + + self.assertEqual(val_1, 0.0) + self.assertAlmostEqual(val_2, 2.743428, 5) + self.assertAlmostEqual(val_3, 2.743428, 5) + self.assertAlmostEqual(val_4, 2.491730, 5) + + loss_fn = JaccardDistanceLoss(from_logits=False, smooth=1, class_weights=np.array([0, 1, 1])) + + val_1 = loss_fn(y_true, y_true).numpy() + val_2 = loss_fn(y_true, y_pred).numpy() + y_pred[..., 0] = 0 + y_pred[..., 1] = 1 + val_3 = loss_fn(y_true, y_pred).numpy() + y_pred[..., 1] = 0 + y_pred[..., 2] = 1 + val_4 = loss_fn(y_true, y_pred).numpy() + + self.assertEqual(val_1, 0.0) + self.assertAlmostEqual(val_2, 1.495621, 5) + self.assertAlmostEqual(val_3, 1.248781, 5) + self.assertAlmostEqual(val_4, 1.495621, 5) + + def test_tanimoto_loss(self): + + y_true = np.zeros([1, 32, 32, 2], dtype=np.float32) + y_true[:, 16:, :16, 1] = np.ones((1, 16, 16)) + y_true[..., 0] = np.ones([1, 32, 32]) - y_true[..., 1] + + y_pred = np.zeros([1, 32, 32, 2], dtype=np.float32) + y_pred[..., 0] = 1 + + self.assertEqual(TanimotoDistanceLoss(from_logits=False)(y_true, y_true).numpy(), 0.0) + self.assertEqual(TanimotoDistanceLoss(from_logits=False)(y_pred, y_pred).numpy(), 0.0) + self.assertAlmostEqual(TanimotoDistanceLoss(from_logits=False)(y_true, y_pred).numpy(), 1.25, 5) + self.assertAlmostEqual(TanimotoDistanceLoss(from_logits=False, normalise=True)(y_true, y_pred).numpy(), + 1.2460148, 5) + self.assertAlmostEqual(TanimotoDistanceLoss(from_logits=False, class_weights=np.array([1, 0]))(y_true, + y_pred).numpy(), + 0.25, 5) + + y_true = np.zeros([1, 32, 32, 2], dtype=np.float32) + y_true[..., 0] = np.ones([1, 32, 32]) - y_true[..., 1] + self.assertEqual(TanimotoDistanceLoss(from_logits=False, normalise=True)(y_true, y_pred).numpy(), 0.) + + +if __name__ == '__main__': + unittest.main() \ No newline at end of file diff --git a/eo-flow/tests/test_metrics.py b/eo-flow/tests/test_metrics.py new file mode 100644 index 0000000..d7c4413 --- /dev/null +++ b/eo-flow/tests/test_metrics.py @@ -0,0 +1,239 @@ +import unittest +import numpy as np + +from eoflow.models.metrics import MeanIoU, MCCMetric +from eoflow.models.metrics import GeometricMetrics +from scipy import ndimage + +class TestMeanIoU(unittest.TestCase): + def test_not_initialized(self): + metric = MeanIoU() + + y_true = np.zeros((1, 32, 32, 3)) + y_pred = np.zeros((1, 32, 32, 3)) + + # Errors should be raised (because not initialized) + self.assertRaises(ValueError, metric.update_state, y_true, y_pred) + self.assertRaises(ValueError, metric.result) + self.assertRaises(ValueError, metric.reset_states) + self.assertRaises(ValueError, metric.get_config) + + metric.init_from_config() + + # Test that errors are not raised + metric.update_state(y_true, y_pred) + metric.result() + metric.reset_states() + metric.get_config() + + def test_iou_results(self): + metric = MeanIoU() + metric.init_from_config({'n_classes': 3}) + + ones = np.ones((32, 32)) + zeros = np.zeros((32, 32)) + mixed = np.concatenate([ones[:16], zeros[:16]]) + + # Predict everything as class 1 + y_pred = np.stack([zeros, ones], axis=-1) + + y_true1 = np.stack([ones, zeros], axis=-1) # All class 0 + y_true2 = np.stack([zeros, ones], axis=-1) # All class 1 + y_true3 = np.stack([mixed, 1 - mixed], axis=-1) # Half class 1, half class 0 + + # Check each one seperately + metric.update_state(y_true1, y_pred) + self.assertAlmostEqual(metric.result().numpy(), 0.0, 10) + + metric.reset_states() + metric.update_state(y_true2, y_pred) + self.assertAlmostEqual(metric.result().numpy(), 1.0, 10) + + metric.reset_states() + metric.update_state(y_true3, y_pred) + self.assertAlmostEqual(metric.result().numpy(), 0.25, 10) # Class 1 IoU: 0.5, Class 2 IoU: 0.0 + + # Check aggregation + metric.reset_states() + metric.update_state(y_true1, y_pred) + metric.update_state(y_true2, y_pred) + metric.update_state(y_true3, y_pred) + self.assertAlmostEqual(metric.result().numpy(), 0.25, 10) # Class 1 IoU: 0.5, Class 2 IoU: 0.0 + + +class TestMCC(unittest.TestCase): + def test_not_initialized(self): + metric = MCCMetric() + + y_true = np.zeros((1, 32, 32, 3)) + y_pred = np.zeros((1, 32, 32, 3)) + + # Errors should be raised (because not initialized) + self.assertRaises(ValueError, metric.update_state, y_true, y_pred) + self.assertRaises(ValueError, metric.result) + self.assertRaises(ValueError, metric.reset_states) + self.assertRaises(ValueError, metric.get_config) + + metric.init_from_config({'n_classes': 3}) + + # Test that errors are not raised + metric.update_state(y_true, y_pred) + metric.result() + metric.reset_states() + metric.get_config() + + def test_wrong_n_classes(self): + metric = MCCMetric() + + n_classes = 3 + y_true = np.zeros((1, 32, 32, n_classes)) + y_pred = np.zeros((1, 32, 32, n_classes)) + + metric.init_from_config({'n_classes': 1}) + + # Test that errors are raised + with self.assertRaises(Exception) as context: + metric.update_state(y_true, y_pred) + self.assertTrue((f'Input to reshape is a tensor with {np.prod(y_true.shape)} values, ' + f'but the requested shape has {np.prod(y_true.shape[:-1])}') in str(context.exception)) + + def test_mcc_results_binary_symmetry(self): + metric = MCCMetric() + metric.init_from_config({'n_classes': 2}) + + y_pred = np.random.randint(0, 2, (32, 32, 1)) + y_pred = np.concatenate((y_pred, 1-y_pred), axis=-1) + + y_true = np.random.randint(0, 2, (32, 32, 1)) + y_true = np.concatenate((y_true, 1 - y_true), axis=-1) + + metric.update_state(y_true, y_pred) + results = metric.result().numpy() + self.assertAlmostEqual(results[0], results[1], 7) + + def test_mcc_single_vs_binary(self): + metric_single = MCCMetric() + metric_single.init_from_config({'n_classes': 1}) + + y_pred = np.random.randint(0, 2, (32, 32, 1)) + y_true = np.random.randint(0, 2, (32, 32, 1)) + metric_single.update_state(y_true, y_pred) + result_single = metric_single.result().numpy()[0] + + metric_binary = MCCMetric() + metric_binary.init_from_config({'n_classes': 2}) + + y_pred = np.concatenate((y_pred, 1-y_pred), axis=-1) + y_true = np.concatenate((y_true, 1 - y_true), axis=-1) + metric_binary.update_state(y_true, y_pred) + result_binary = metric_binary.result().numpy()[0] + + self.assertAlmostEqual(result_single, result_binary, 7) + + def test_mcc_results(self): + # test is from an example of MCC in sklearn.metrics matthews_corrcoef + y_true = np.array([1, 1, 1, 0])[..., np.newaxis] + y_pred = np.array([1, 0, 1, 1])[..., np.newaxis] + metric = MCCMetric() + metric.init_from_config({'n_classes': 1}) + metric.update_state(y_true, y_pred) + self.assertAlmostEqual(metric.result().numpy()[0], -0.3333333, 7) + + def test_mcc_threshold(self): + y_true = np.array([1, 1, 1, 0])[..., np.newaxis] + y_pred = np.array([0.9, 0.6, 0.61, 0.7])[..., np.newaxis] + metric = MCCMetric() + metric.init_from_config({'n_classes': 1, 'mcc_threshold': 0.6}) + metric.update_state(y_true, y_pred) + self.assertAlmostEqual(metric.result().numpy()[0], -0.3333333, 7) + + +class TestGeometricMetric(unittest.TestCase): + + def detect_edges(self, im, thr=0): + sx = ndimage.sobel(im, axis=0, mode='constant') + sy = ndimage.sobel(im, axis=1, mode='constant') + sob = np.hypot(sx, sy) + return sob > thr + + def test_equal_geometries(self): + + metric = GeometricMetrics(edge_func=self.detect_edges) + + y_true = np.zeros((2, 32, 32)) + y_pred = np.zeros((2, 32, 32)) + + y_true[0, 10:20, 10:20] = 1 + y_pred[0, 10:20, 10:20] = 1 + + y_true[1, 0:10, 0:10] = 1 + y_pred[1, 0:10, 0:10] = 1 + + y_true[1, 15:20, 15:20] = 1 + y_pred[1, 15:20, 15:20] = 1 + + metric.update_state(y_true, y_pred) + overseg_err, underseg_err, border_err, fragmentation_err = metric.result() + + self.assertEqual(overseg_err, 0., "For equal geometries oversegmentation should be 0!") + self.assertEqual(underseg_err, 0., "For equal geometries undersegmentation should be 0!") + self.assertEqual(fragmentation_err, 0., "For equal geometries fragmentation error should be 0!") + self.assertEqual(border_err, 0., "For equal geometries border error should be 0!") + + def test_empty_geometries(self): + + metric = GeometricMetrics(edge_func=self.detect_edges) + + y_true = np.ones((1, 32, 32)) + y_pred = np.zeros((1, 32, 32)) + + metric.update_state(y_true, y_pred) + overseg_err, underseg_err, border_err, fragmentation_err = metric.result() + + self.assertEqual(overseg_err, 1., "For empty geometries oversegmentation should be 1!") + self.assertEqual(underseg_err, 1., "For empty geometries undersegmentation should be 1!") + self.assertEqual(fragmentation_err, 0., "For empty geometries fragmentation error should be 0!") + self.assertEqual(border_err, 1., "For empty geometries border error should be 1!") + + def test_quarter(self): + metric = GeometricMetrics(edge_func=self.detect_edges) + + # A quarter of measurement covers a quarter of reference + y_true = np.zeros((1, 200, 200)) + y_pred = np.zeros((1, 200, 200)) + + y_true[0, :100, :100] = 1 + y_pred[0, 50:150, 50:150] = 1 + + metric.update_state(y_true, y_pred) + overseg_err, underseg_err, border_err, fragmentation_err = metric.result() + + self.assertEqual(overseg_err, 0.75) + self.assertEqual(underseg_err, 0.75) + self.assertEqual(fragmentation_err, 0.) + self.assertAlmostEqual(border_err, 0.9949494949494949) + + def test_multiple(self): + metric = GeometricMetrics(edge_func=self.detect_edges) + + # A quarter of measurement covers a quarter of reference + y_true = np.zeros((1, 200, 200)) + y_pred = np.zeros((1, 200, 200)) + + y_true[0, 10:20, 20:120] = 1 + y_true[0, 30:40, 20:120] = 1 + y_true[0, 50:60, 20:120] = 1 + + y_pred[0, 15:33, 20:120] = 1 + y_pred[0, 36:65, 20:120] = 1 + + metric.update_state(y_true, y_pred) + + overseg_err, underseg_err, border_err, fragmentation_err = metric.result() + self.assertEqual(overseg_err, 0.3666666666666667) + self.assertEqual(underseg_err, 0.7464878671775222) + self.assertEqual(fragmentation_err, 0.000333667000333667) + self.assertAlmostEqual(border_err, 0.9413580246913581) + +if __name__ == '__main__': + unittest.main() From e6d22d23372f65948c234b38f382ed0dc737c4e3 Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 3 Feb 2022 12:16:50 +0100 Subject: [PATCH 03/21] add eo-crops --- eo-crops | 1 + eo-flow/.gitignore | 17 - eo-flow/LICENSE | 23 - eo-flow/MODELS.md | 40 -- eo-flow/README.md | 74 -- eo-flow/checkpoint | 2 - eo-flow/configs/example.json | 29 - eo-flow/configs/example_val.json | 38 - eo-flow/configs/fcn_example.json | 43 -- eo-flow/configs/tfcn_example.json | 44 -- eo-flow/configs/tfcn_example_real_eval.json | 50 -- eo-flow/configs/tfcn_example_real_pred.json | 50 -- eo-flow/configs/tfcn_example_real_train.json | 58 -- .../tfcn_example_real_train_and_eval.json | 78 --- eo-flow/eoflow/__init__.py | 1 - eo-flow/eoflow/base/__init__.py | 5 - eo-flow/eoflow/base/base_custom_training.py | 141 ---- eo-flow/eoflow/base/base_input.py | 8 - eo-flow/eoflow/base/base_task.py | 28 - eo-flow/eoflow/base/base_training.py | 157 ----- eo-flow/eoflow/base/configuration.py | 74 -- eo-flow/eoflow/execute.py | 47 -- eo-flow/eoflow/input/__init__.py | 0 eo-flow/eoflow/input/eopatch.py | 117 ---- eo-flow/eoflow/input/hdf5.py | 44 -- eo-flow/eoflow/input/numpy.py | 102 --- eo-flow/eoflow/input/operations.py | 210 ------ eo-flow/eoflow/input/random.py | 76 -- eo-flow/eoflow/models/__init__.py | 4 - eo-flow/eoflow/models/callbacks.py | 91 --- eo-flow/eoflow/models/embeddings.py | 29 - eo-flow/eoflow/models/layers.py | 407 ----------- eo-flow/eoflow/models/losses.py | 234 ------- eo-flow/eoflow/models/metrics.py | 335 --------- eo-flow/eoflow/models/pse_tae_layers.py | 176 ----- .../models/segmentation_task/__init__.py | 0 .../segmentation_task/segmentation_base.py | 164 ----- .../segmentation_task/segmentation_unets.py | 651 ----------------- .../eoflow/models/tempnets_task/__init__.py | 0 .../models/tempnets_task/cnn_tempnets.py | 349 --------- .../models/tempnets_task/mlp_tempnets.py | 182 ----- .../models/tempnets_task/rnn_tempnets.py | 232 ------ .../models/tempnets_task/tempnets_base.py | 173 ----- .../models/transformer_encoder_layers.py | 193 ----- eo-flow/eoflow/tasks/__init__.py | 3 - eo-flow/eoflow/tasks/evaluate.py | 28 - eo-flow/eoflow/tasks/predict.py | 21 - eo-flow/eoflow/tasks/train.py | 61 -- eo-flow/eoflow/utils/__init__.py | 2 - eo-flow/eoflow/utils/tf_utils.py | 21 - eo-flow/eoflow/utils/utils.py | 34 - eo-flow/examples/exporting_data.ipynb | 196 ------ eo-flow/examples/input.py | 122 ---- eo-flow/examples/models.py | 39 -- .../examples/notebook_classification.ipynb | 662 ------------------ eo-flow/examples/pretraining.py | 0 eo-flow/examples/remove_file.py | 11 - eo-flow/examples/test_cnns.py | 105 --- eo-flow/figures/fcn-architecture.png | Bin 148643 -> 0 bytes eo-flow/figures/rfcn-architecture.png | Bin 172044 -> 0 bytes eo-flow/figures/tfcn-architecture.png | Bin 174574 -> 0 bytes eo-flow/requirements-dev.txt | 4 - eo-flow/requirements.txt | 8 - eo-flow/setup.py | 29 - eo-flow/tests/test_layers.py | 47 -- eo-flow/tests/test_losses.py | 115 --- eo-flow/tests/test_metrics.py | 239 ------- 67 files changed, 1 insertion(+), 6523 deletions(-) create mode 160000 eo-crops delete mode 100644 eo-flow/.gitignore delete mode 100644 eo-flow/LICENSE delete mode 100644 eo-flow/MODELS.md delete mode 100644 eo-flow/README.md delete mode 100644 eo-flow/checkpoint delete mode 100644 eo-flow/configs/example.json delete mode 100644 eo-flow/configs/example_val.json delete mode 100644 eo-flow/configs/fcn_example.json delete mode 100644 eo-flow/configs/tfcn_example.json delete mode 100644 eo-flow/configs/tfcn_example_real_eval.json delete mode 100644 eo-flow/configs/tfcn_example_real_pred.json delete mode 100644 eo-flow/configs/tfcn_example_real_train.json delete mode 100644 eo-flow/configs/tfcn_example_real_train_and_eval.json delete mode 100644 eo-flow/eoflow/__init__.py delete mode 100644 eo-flow/eoflow/base/__init__.py delete mode 100644 eo-flow/eoflow/base/base_custom_training.py delete mode 100644 eo-flow/eoflow/base/base_input.py delete mode 100644 eo-flow/eoflow/base/base_task.py delete mode 100644 eo-flow/eoflow/base/base_training.py delete mode 100644 eo-flow/eoflow/base/configuration.py delete mode 100644 eo-flow/eoflow/execute.py delete mode 100644 eo-flow/eoflow/input/__init__.py delete mode 100644 eo-flow/eoflow/input/eopatch.py delete mode 100644 eo-flow/eoflow/input/hdf5.py delete mode 100644 eo-flow/eoflow/input/numpy.py delete mode 100644 eo-flow/eoflow/input/operations.py delete mode 100644 eo-flow/eoflow/input/random.py delete mode 100644 eo-flow/eoflow/models/__init__.py delete mode 100644 eo-flow/eoflow/models/callbacks.py delete mode 100644 eo-flow/eoflow/models/embeddings.py delete mode 100644 eo-flow/eoflow/models/layers.py delete mode 100644 eo-flow/eoflow/models/losses.py delete mode 100644 eo-flow/eoflow/models/metrics.py delete mode 100644 eo-flow/eoflow/models/pse_tae_layers.py delete mode 100644 eo-flow/eoflow/models/segmentation_task/__init__.py delete mode 100644 eo-flow/eoflow/models/segmentation_task/segmentation_base.py delete mode 100644 eo-flow/eoflow/models/segmentation_task/segmentation_unets.py delete mode 100644 eo-flow/eoflow/models/tempnets_task/__init__.py delete mode 100644 eo-flow/eoflow/models/tempnets_task/cnn_tempnets.py delete mode 100644 eo-flow/eoflow/models/tempnets_task/mlp_tempnets.py delete mode 100644 eo-flow/eoflow/models/tempnets_task/rnn_tempnets.py delete mode 100644 eo-flow/eoflow/models/tempnets_task/tempnets_base.py delete mode 100644 eo-flow/eoflow/models/transformer_encoder_layers.py delete mode 100644 eo-flow/eoflow/tasks/__init__.py delete mode 100644 eo-flow/eoflow/tasks/evaluate.py delete mode 100644 eo-flow/eoflow/tasks/predict.py delete mode 100644 eo-flow/eoflow/tasks/train.py delete mode 100644 eo-flow/eoflow/utils/__init__.py delete mode 100644 eo-flow/eoflow/utils/tf_utils.py delete mode 100644 eo-flow/eoflow/utils/utils.py delete mode 100644 eo-flow/examples/exporting_data.ipynb delete mode 100644 eo-flow/examples/input.py delete mode 100644 eo-flow/examples/models.py delete mode 100644 eo-flow/examples/notebook_classification.ipynb delete mode 100644 eo-flow/examples/pretraining.py delete mode 100644 eo-flow/examples/remove_file.py delete mode 100644 eo-flow/examples/test_cnns.py delete mode 100644 eo-flow/figures/fcn-architecture.png delete mode 100644 eo-flow/figures/rfcn-architecture.png delete mode 100644 eo-flow/figures/tfcn-architecture.png delete mode 100644 eo-flow/requirements-dev.txt delete mode 100644 eo-flow/requirements.txt delete mode 100644 eo-flow/setup.py delete mode 100644 eo-flow/tests/test_layers.py delete mode 100644 eo-flow/tests/test_losses.py delete mode 100644 eo-flow/tests/test_metrics.py diff --git a/eo-crops b/eo-crops new file mode 160000 index 0000000..faed907 --- /dev/null +++ b/eo-crops @@ -0,0 +1 @@ +Subproject commit faed90720f1bb622cf9520f51b4edf31e0b47c1e diff --git a/eo-flow/.gitignore b/eo-flow/.gitignore deleted file mode 100644 index de40ef9..0000000 --- a/eo-flow/.gitignore +++ /dev/null @@ -1,17 +0,0 @@ -# pyc files -*.pyc - -# VS files -.vscode/ - -# temp output folder -temp/ - -# pycharm files -.idea/ - -# egg folder -*.egg-info/ - -# Jupyter checkpoints -.ipynb_checkpoints \ No newline at end of file diff --git a/eo-flow/LICENSE b/eo-flow/LICENSE deleted file mode 100644 index 3664919..0000000 --- a/eo-flow/LICENSE +++ /dev/null @@ -1,23 +0,0 @@ - -MIT License - -Copyright (c) 2017-2020 Matej Aleksandrov, Matej Batič, Matic Lubej, Grega Milčinski (Sinergise) -Copyright (c) 2017-2020 Devis Peressutti, Jernej Puc, Anže Zupanc, Lojze Žust, Jovan Višnjić (Sinergise) - -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. diff --git a/eo-flow/MODELS.md b/eo-flow/MODELS.md deleted file mode 100644 index 21fe27b..0000000 --- a/eo-flow/MODELS.md +++ /dev/null @@ -1,40 +0,0 @@ -# Models - -## Fully-Convolutional-Network (FCN) - -The vanilla architecture as in the following figure is implemented. Convolutions are run along spatial dimensions of input tensor, which is supposed to have `[M, H, W, D]` shape, where M is the mini-batch size, and H, W and D are the height, width and number of bands (i.e. depth) of the input image tensor. The 2d convolutions perform a `VALID` convolution, therefore the output tensor size is smaller than the input size. - -![FCN](./figures/fcn-architecture.png "FCN") - -An example training script is provided. To run it execute the `configs/fcn_example.json` configuration: -``` -python -m eoflow.execute configs/fcn_example.json -``` - -The example configuration can be used as a base to run your own experiments. - -## Temporal Fully-Convolutional-Network (TFCN) - -Similarly to the RFCN, the TFCN works with time-series of input shape `[M, T, H, W, D]`. This network performs 3d convolutions along the tempo-spatial dimensions, i.e. the convolutional kernels are 3d `k x k x k`. As default, the temporal dimension is not pooled. For temporal pooling, enough time-frames need to be available in the input tensors. At the bottom of the TFCN and along the skip connections, a 1d convolution along the temporal dimension is performed to linearly combine the temporal features. The resulting tensors are 4d of shape `[M, H, W, D]`. The decoding path is as in FCN. - -![TFCN](./figures/tfcn-architecture.png "TFCN") - -An example training script is provided. To run it execute the `configs/tfcn_example.json` configuration: -``` -python -m eoflow.execute configs/tfcn_example.json -``` - -The example configuration can be used as a base to run your own experiments. - -## Recurrent Fully-Convolutional-Network (RFCN) - -A recurrent version of the **FCN** is implemented as in below figure. The input tensor in this case is 5d with shape `[M, T, H, W, D]`, where `T` is the number of temporal acquisitions. As for the FCN, the 2d convolutions operate along the `H` and `W` dimensions. The recurrent layers are applied along the skip connections and the bottom layers to model the temporal relationship between the features extracted by the 2d convolutions. The output of the recurrent layers is a 4d tensor of shape `[M, H, W, D]` (the height, width and depth of the tensors will vary along the network). The decoding path is as in **FCN**. The 2d convolutions perform a `VALID` convolution, therefore the output tensor size is smaller than the input size. - -![RFCN](./figures/rfcn-architecture.png "RFCN") - -An example training script is provided. To run it execute the `configs/rfcn_example.json` configuration: -``` -python -m eoflow.execute configs/rfcn_example.json -``` - -The example configuration can be used as a base to run your own experiments. diff --git a/eo-flow/README.md b/eo-flow/README.md deleted file mode 100644 index fa47fec..0000000 --- a/eo-flow/README.md +++ /dev/null @@ -1,74 +0,0 @@ -# EOFlow - -This repository provides code and examples for creation of Earth Observation (EO) projects using TensorFlow. The code uses TensorFlow 2.0 with Keras as the main model building API. - -Common model architectures, layers, and input methods for EO tasks are provided in the package `eoflow`. Custom models and input methods can also be implemented building on top of the provided abstract classes. This package aims at seamlessly integrate with [`eo-learn`](https://github.com/sentinel-hub/eo-learn), and favours both creation of models for prototypying as well as production of EO applications. - -Architectures and examples for land cover and crop classification using time-series derived from satellite images are provided. - -## Installation - -The package can be installed by running the following command. -``` -$ pip install git+https://github.com/sentinel-hub/eo-flow -``` - -You can also install the package from source. Clone the repository and run the following command in the root directory of the project. -``` -$ pip install . -``` - -## Getting started - -The `eoflow` package can be used in two ways. For best control over the workflow and faster prototyping, the package can be used programmatically (in code). The [example notebook](examples/notebook.ipynb) should help you get started with that. It demonstrates how to prepare a dataset pipeline, train the model, evaluate the model and make predictions using the trained model. - -An alternate way of using `eoflow` is by writing configuration `json` files and running them using `eoflow`'s execute script. Configuration files specify and configure the task (training, evaluation, etc.) and contain the configurations of the model and input methods. Example configurations are provided in the `configs` directory. Once a configuration file is created it can be run using the execute command. - -A simple example can be run using the following command. More advanced configurations are also provided. -``` -$ python -m eoflow.execute configs/example.json -``` - -This will create an output folder `temp/experiment` containing the tensorboard logs and model checkpoints. - -To visualize the logs in TensorBoard, run -``` -$ tensorboard --logdir=temp/experiment -``` - -## Writing custom code - -To get started with writing custom models and input methods for `eoflow` take a look at the example implementations ([`examples` folder](examples/)). Custom classes use schemas to define the configuration parameters in order to work with the execute script and configuration files. Since eoflow builds on top of TF2 and Keras, model building is very similar. - -## Package structure - -The subpackages of `eoflow` are as follows: -* `base`: this directory contains the abstract classes to build models, inputs and tasks. Any useful abstract class should go in this folder. -* `models`: classes implementing the TF models (e.g. Fully-Convolutional-Network, GANs, seq2seq, ...). These classes inherit and implement the `BaseModel` abstract class. The module also contains custom losses, metrics and layers. -* `tasks`: classes handling the configurable actions that can be applied to each TF model, when using the execute script. These actions may include training, inference, exporting the model, validation, etc. The tasks inherit the `BaseTask` abstract class. -* `input`: building blocks and helper methods for loading the input data (EOPatch, numpy arrays, etc.) into a tensoflow Dataset and applying different transformations (data augmentation, patch extraction) -* `utils`: collection of utility functions - -### Examples and scripts - -Project also contains other folders: -* `configs`: folder containing example configurations for different models. Config parameters are stored in .json files. Results of an experiment should be reproducible by re-running the same config file. Config files specify the whole workflow (model, task, data input if required). -* `examples`: folder containing example implementations of custom models and input functions. Also contains a jupyter notebook example. - -## Implemented architectures - -Segmentation models for land cover semantic segmentation: -* **Fully-Convolutional-Network (FCN, a.k.a. U-net)**, vanilla implementation of method described in this [paper](https://arxiv.org/abs/1505.04597). This network expects 2D MSI images as inputs and predicts 2D label maps as output. -* **Temporal FCN**, where the whole time-series is considered as a 3D MSI volume and convolutions are performed along the temporal dimension as well spatial dimension. The output of the network is a 2D label map as in previous cases. More details can be found in this [paper](https://www.researchgate.net/publication/333262625_Spatio-Temporal_Deep_Learning_An_Application_to_Land_Cover_Classification). -* **ResUNet-a**, architecture proposed in Diakogiannis et al. ["ResUNet-a: A deep learning framework for semantic segmetnation of remotely sensed data"](https://www.sciencedirect.com/science/article/abs/pii/S0924271620300149). Original `mxnet` implementation can be found [here](https://github.com/feevos/resuneta). - -Classification models for crop classification using time-series: -* **TCN**: Implementation of the TCN network taken from the [keras-TCN implementation by Philippe Remy](https://github.com/philipperemy/keras-tcn). -* **TempCNN**: Implementation of the TempCNN network taken from the [temporalCNN implementation of Charlotte Pelletier](https://github.com/charlotte-pel/temporalCNN). -* **Recurrent NN**: Implementation of (bidirectional) Recurrent Neural Networks for the classification of time-series. Implementation allows to use either `SimpleRNN`, `GRU` or `LSTM` layers as building blocks of the architecture. -* **TransformerEncoder**: Implementation of a time-series classification architecture based on [self-attention](https://arxiv.org/abs/1706.03762) layers. This implementation follows [this PyTorch implementation of Marc Russwurm](https://github.com/MarcCoru/crop-type-mapping). -* **PSE+TAE**: Implementation of the Pixel-Set Encoder and temporal Self-attention proposed in Garnot V. _et al._ -["Satellite Image Time Series Classification with Pixel-Set Encoders and Temporal Self-Attention"](https://hal.archives-ouvertes.fr/hal-02879223/document). -This implementation is adapted from the [Pytorch version](https://github.com/VSainteuf/pytorch-psetae). - -Descriptions and examples of semantic segmentation architectures are available [here](MODELS.md). diff --git a/eo-flow/checkpoint b/eo-flow/checkpoint deleted file mode 100644 index a6e034f..0000000 --- a/eo-flow/checkpoint +++ /dev/null @@ -1,2 +0,0 @@ -model_checkpoint_path: "model" -all_model_checkpoint_paths: "model" diff --git a/eo-flow/configs/example.json b/eo-flow/configs/example.json deleted file mode 100644 index 22f4046..0000000 --- a/eo-flow/configs/example.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "model": { - "classname": "examples.models.ExampleModel", - "config": { - "output_size": 10, - "hidden_units": 256, - "learning_rate": 0.001 - } - }, - "task": { - "classname": "eoflow.tasks.TrainTask", - "config": { - "num_epochs": 10, - "model_directory": "./temp/experiment", - "input_config":{ - "classname": "examples.input.ExampleInput", - "config": { - "input_shape": [512], - "num_classes": 10, - "batch_size": 20, - "batches_per_epoch": 200 - } - }, - "iterations_per_epoch": 200, - "save_steps": 400, - "summary_steps": 50 - } - } - } diff --git a/eo-flow/configs/example_val.json b/eo-flow/configs/example_val.json deleted file mode 100644 index a4e5f3f..0000000 --- a/eo-flow/configs/example_val.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "model": { - "classname": "examples.models.ExampleModel", - "config": { - "output_size": 10, - "hidden_units": 256, - "learning_rate": 0.01 - } - }, - "task": { - "classname": "eoflow.tasks.TrainAndEvaluateTask", - "config": { - "num_epochs": 10, - "iterations_per_epoch": 1000, - "model_directory": "./temp/experiment", - "train_input_config":{ - "classname": "examples.input.ExampleInput", - "config": { - "input_shape": [512], - "num_classes": 10, - "batch_size": 20, - "batches_per_epoch": 200 - } - }, - "val_input_config":{ - "classname": "examples.input.ExampleInput", - "config": { - "input_shape": [512], - "num_classes": 10, - "batch_size": 1, - "batches_per_epoch": 200 - } - }, - "save_steps": 400, - "summary_steps": 50 - } - } - } diff --git a/eo-flow/configs/fcn_example.json b/eo-flow/configs/fcn_example.json deleted file mode 100644 index cfb86cf..0000000 --- a/eo-flow/configs/fcn_example.json +++ /dev/null @@ -1,43 +0,0 @@ -{ - "model": { - "classname": "eoflow.models.FCNModel", - "config": { - "learning_rate": 0.0001, - "n_layers": 3, - "n_classes": 3, - "keep_prob": 0.8, - "features_root": 32, - "conv_size": 3, - "conv_stride": 1, - "deconv_size": 2, - "add_dropout": true, - "add_batch_norm": false, - "bias_init": 0.0, - "padding": "VALID", - "pool_size": 2, - "pool_stride": 2, - "loss": "focal_loss", - "metrics": ["accuracy"] - } - }, - "task": { - "classname": "eoflow.tasks.TrainTask", - "config": { - "num_epochs": 2, - "model_directory": "./temp/experiment_fcn", - "input_config":{ - "classname": "eoflow.input.random.RandomSegmentationInput", - "config": { - "input_shape": [128, 128, 13], - "output_shape": [128, 128], - "num_classes": 3, - "batch_size": 2, - "batches_per_epoch": 200 - } - }, - "iterations_per_epoch": 50, - "save_steps": 100, - "summary_steps": 50 - } - } - } diff --git a/eo-flow/configs/tfcn_example.json b/eo-flow/configs/tfcn_example.json deleted file mode 100644 index 94f497d..0000000 --- a/eo-flow/configs/tfcn_example.json +++ /dev/null @@ -1,44 +0,0 @@ -{ - "model": { - "classname": "eoflow.models.TFCNModel", - "config": { - "learning_rate": 0.0001, - "n_layers": 3, - "n_classes": 2, - "keep_prob": 0.8, - "features_root": 16, - "conv_size": 3, - "conv_stride": 1, - "deconv_size": 2, - "add_dropout": true, - "add_batch_norm": false, - "bias_init": 0.0, - "padding": "VALID", - "pool_size": 2, - "pool_stride": 2, - "pool_time": false, - "single_encoding_conv": true, - "conv_size_reduce": 3, - "loss": "cross_entropy" - } - }, - "task": { - "classname": "eoflow.tasks.TrainTask", - "config": { - "num_epochs": 2, - "model_directory": "./temp/experiment_tfcn", - "input_config":{ - "classname": "eoflow.input.random.RandomSegmentationInput", - "config": { - "input_shape": [10, 128, 128, 13], - "output_shape": [128, 128], - "num_classes": 2, - "batch_size": 1, - "batches_per_epoch": 100 - } - }, - "save_steps": 100, - "summary_steps": 50 - } - } - } diff --git a/eo-flow/configs/tfcn_example_real_eval.json b/eo-flow/configs/tfcn_example_real_eval.json deleted file mode 100644 index f7ae912..0000000 --- a/eo-flow/configs/tfcn_example_real_eval.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "model": { - "classname": "eoflow.models.TFCNModel", - "config": { - "learning_rate": 0.0001, - "n_layers": 3, - "n_classes": 10, - "keep_prob": 0.8, - "features_root": 16, - "conv_size": 3, - "conv_stride": 1, - "deconv_size": 2, - "add_dropout": true, - "add_batch_norm": false, - "bias_init": 0.0, - "padding": "VALID", - "pool_size": 2, - "pool_stride": 2, - "pool_time": false, - "single_encoding_conv": true, - "conv_size_reduce": 3 - } - }, - "task": { - "classname": "eoflow.tasks.EvaluateTask", - "config": { - "model_directory": "./temp/tfcn_svn_lulc", - "input_config":{ - "classname": "examples.input.EOPatchInputExample", - "config": { - "data_dir": "/storage/jupyter/data/svn_lulc/data/train-val-linear-v01-aws/test", - "input_feature_type": "data", - "input_feature_name": "FEATURES", - "input_feature_axis": [1,2], - "input_feature_shape": [23, -1, -1, 9], - "labels_feature_type": "mask_timeless", - "labels_feature_name": "LULC_RABA", - "labels_feature_axis": [0,1], - "labels_feature_shape": [-1, -1, 1], - "patch_size": [128, 128], - "interleave_size": 3, - "batch_size": 1, - "num_classes": 10, - "cache_file": "./temp/tfcn_svn_lulc/dataset/cache_val", - "num_subpatches": 5 - } - } - } - } - } diff --git a/eo-flow/configs/tfcn_example_real_pred.json b/eo-flow/configs/tfcn_example_real_pred.json deleted file mode 100644 index 4185114..0000000 --- a/eo-flow/configs/tfcn_example_real_pred.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "model": { - "classname": "eoflow.models.TFCNModel", - "config": { - "learning_rate": 0.0001, - "n_layers": 3, - "n_classes": 10, - "keep_prob": 0.8, - "features_root": 16, - "conv_size": 3, - "conv_stride": 1, - "deconv_size": 2, - "add_dropout": true, - "add_batch_norm": false, - "bias_init": 0.0, - "padding": "VALID", - "pool_size": 2, - "pool_stride": 2, - "pool_time": false, - "single_encoding_conv": true, - "conv_size_reduce": 3 - } - }, - "task": { - "classname": "eoflow.tasks.PredictTask", - "config": { - "model_directory": "./temp/tfcn_svn_lulc", - "input_config":{ - "classname": "examples.input.EOPatchInputExample", - "config": { - "data_dir": "/storage/jupyter/data/svn_lulc/data/train-val-linear-v01-aws/test", - "input_feature_type": "data", - "input_feature_name": "FEATURES", - "input_feature_axis": [1,2], - "input_feature_shape": [23, -1, -1, 9], - "labels_feature_type": "mask_timeless", - "labels_feature_name": "LULC_RABA", - "labels_feature_axis": [0,1], - "labels_feature_shape": [-1, -1, 1], - "patch_size": [128, 128], - "interleave_size": 3, - "batch_size": 1, - "num_classes": 10, - "cache_file": "./temp/tfcn_svn_lulc/dataset/cache_val", - "num_subpatches": 5 - } - } - } - } - } diff --git a/eo-flow/configs/tfcn_example_real_train.json b/eo-flow/configs/tfcn_example_real_train.json deleted file mode 100644 index a551bf7..0000000 --- a/eo-flow/configs/tfcn_example_real_train.json +++ /dev/null @@ -1,58 +0,0 @@ -{ - "model": { - "classname": "eoflow.models.TFCNModel", - "config": { - "learning_rate": 0.0001, - "n_layers": 3, - "n_classes": 10, - "keep_prob": 0.8, - "features_root": 16, - "conv_size": 3, - "conv_stride": 1, - "deconv_size": 2, - "add_dropout": true, - "add_batch_norm": false, - "bias_init": 0.0, - "padding": "SAME", - "pool_size": 2, - "pool_stride": 2, - "pool_time": false, - "single_encoding_conv": true, - "conv_size_reduce": 3, - "loss": "focal_loss", - "metrics": ["accuracy", "iou"], - "prediction_visualization": true - } - }, - "task": { - "classname": "eoflow.tasks.TrainTask", - "config": { - "num_epochs": 50, - "iterations_per_epoch": 10, - "model_directory": "./temp/tfcn_svn_lulc", - "input_config":{ - "classname": "examples.input.EOPatchInputExample", - "config": { - "data_dir": "/home/devis/Desktop/train-val-linear-v01-aws/train", - "input_feature_type": "data", - "input_feature_name": "FEATURES", - "input_feature_axis": [1,2], - "input_feature_shape": [23, -1, -1, 9], - "labels_feature_type": "mask_timeless", - "labels_feature_name": "LULC_RABA", - "labels_feature_axis": [0,1], - "labels_feature_shape": [-1, -1, 1], - "patch_size": [128, 128], - "interleave_size": 3, - "batch_size": 2, - "num_classes": 10, - "cache_file": "./temp/tfcn_svn_lulc/dataset/cache", - "num_subpatches": 5, - "data_augmentation": true - } - }, - "save_steps": 100, - "summary_steps": 1 - } - } - } diff --git a/eo-flow/configs/tfcn_example_real_train_and_eval.json b/eo-flow/configs/tfcn_example_real_train_and_eval.json deleted file mode 100644 index ad58b21..0000000 --- a/eo-flow/configs/tfcn_example_real_train_and_eval.json +++ /dev/null @@ -1,78 +0,0 @@ -{ - "model": { - "classname": "eoflow.models.TFCNModel", - "config": { - "learning_rate": 0.0001, - "n_layers": 3, - "n_classes": 10, - "keep_prob": 0.8, - "features_root": 16, - "conv_size": 3, - "conv_stride": 1, - "deconv_size": 2, - "add_dropout": true, - "add_batch_norm": false, - "bias_init": 0.0, - "padding": "SAME", - "pool_size": 2, - "pool_stride": 2, - "pool_time": false, - "single_encoding_conv": true, - "conv_size_reduce": 3, - "loss": "focal_loss", - "metrics": ["accuracy", "iou"], - "prediction_visualization": true - } - }, - "task": { - "classname": "eoflow.tasks.TrainAndEvaluateTask", - "config": { - "num_epochs": 100, - "iterations_per_epoch": 10, - "model_directory": "./temp/tfcn_svn_lulc", - "train_input_config":{ - "classname": "examples.input.EOPatchInputExample", - "config": { - "data_dir": "/home/devis/Desktop/train-val-linear-v01-aws/train", - "input_feature_type": "data", - "input_feature_name": "FEATURES", - "input_feature_axis": [1,2], - "input_feature_shape": [23, -1, -1, 9], - "labels_feature_type": "mask_timeless", - "labels_feature_name": "LULC_RABA", - "labels_feature_axis": [0,1], - "labels_feature_shape": [-1, -1, 1], - "patch_size": [128, 128], - "interleave_size": 3, - "batch_size": 2, - "num_classes": 10, - "cache_file": "./temp/tfcn_svn_lulc/dataset/cache_train", - "num_subpatches": 5, - "data_augmentation": true - } - }, - "val_input_config":{ - "classname": "examples.input.EOPatchInputExample", - "config": { - "data_dir": "/home/devis/Desktop/train-val-linear-v01-aws/test", - "input_feature_type": "data", - "input_feature_name": "FEATURES", - "input_feature_axis": [1,2], - "input_feature_shape": [23, -1, -1, 9], - "labels_feature_type": "mask_timeless", - "labels_feature_name": "LULC_RABA", - "labels_feature_axis": [0,1], - "labels_feature_shape": [-1, -1, 1], - "patch_size": [128, 128], - "interleave_size": 3, - "batch_size": 2, - "num_classes": 10, - "cache_file": "./temp/tfcn_svn_lulc/dataset/cache_val", - "num_subpatches": 5 - } - }, - "save_steps": 10, - "summary_steps": 1 - } - } - } diff --git a/eo-flow/eoflow/__init__.py b/eo-flow/eoflow/__init__.py deleted file mode 100644 index b9863c0..0000000 --- a/eo-flow/eoflow/__init__.py +++ /dev/null @@ -1 +0,0 @@ -name = 'eoflow' diff --git a/eo-flow/eoflow/base/__init__.py b/eo-flow/eoflow/base/__init__.py deleted file mode 100644 index ced878a..0000000 --- a/eo-flow/eoflow/base/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -from .configuration import Configurable -from .base_input import BaseInput -from .base_task import BaseTask -from .base_training import BaseModelTraining -from .base_custom_training import BaseModelCustomTraining \ No newline at end of file diff --git a/eo-flow/eoflow/base/base_custom_training.py b/eo-flow/eoflow/base/base_custom_training.py deleted file mode 100644 index 1b9836b..0000000 --- a/eo-flow/eoflow/base/base_custom_training.py +++ /dev/null @@ -1,141 +0,0 @@ -import tensorflow as tf -from sklearn.utils import shuffle -import numpy as np -import pickle - -import os - -import tensorflow as tf - -from . import Configurable - - -class BaseModelCustomTraining(tf.keras.Model, Configurable): - def __init__(self, config_specs): - tf.keras.Model.__init__(self) - Configurable.__init__(self, config_specs) - - self.net = None - self.init_model() - - def init_model(self): - """ Called on __init__. Keras self initialization. Create self here if does not require the inputs shape """ - pass - - def build(self, inputs_shape): - """ Keras method. Called once to build the self. Build the self here if the input shape is required. """ - pass - - def call(self, inputs, training=False): - pass - - def prepare(self, optimizer=None, loss=None, metrics=None, - epoch_loss_metric = None, - epoch_val_metric = None, - **kwargs): - """ Prepares the self for training and evaluation. This method should create the - optimizer, loss and metric functions and call the compile method of the self. The self - should provide the defaults for the optimizer, loss and metrics, which can be overriden - with custom arguments. """ - - raise NotImplementedError - - @tf.function - def train_step(self, - train_ds): - # pb_i = Progbar(len(list(train_ds)), stateful_metrics='acc') - - for x_batch_train, y_batch_train in train_ds: # tqdm - with tf.GradientTape() as tape: - y_preds = self.call(x_batch_train, - training=True) - cost = self.loss(y_batch_train, y_preds) - - grads = tape.gradient(cost, self.trainable_variables) - self.optimizer.apply_gradients(zip(grads, self.trainable_variables)) - self.loss_metric.update_state(cost) - self.metric.update_state(y_batch_train+1, y_preds+1) - - # Function to run the validation step. - @tf.function - def val_step(self, val_ds): - for x, y in val_ds: - y_preds = self.call(x, training=False) - cost = self.loss(y, y_preds) - self.loss_metric.update_state(cost) - self.metric.update_state(y +1, y_preds+1) - - def fit(self, - dataset, - val_dataset, - batch_size, - num_epochs, - model_directory, - iterations_per_epoch=10, - function=np.min): - - train_loss, val_loss, val_acc = ([np.inf] for i in range(3)) - - x_train, y_train = dataset - n, t, d = x_train.shape - - x_val, y_val = val_dataset - val_ds = tf.data.Dataset.from_tensor_slices((x_val, y_val)).batch(batch_size) - - _ = self(tf.zeros([n, t, d])) - - - for epoch in range(num_epochs + 1): - - x_train, y_train = shuffle(x_train, y_train) - train_ds = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(batch_size) - - self.train_step(train_ds) - - # End epoch - loss_epoch = self.loss_metric.result().numpy() - train_loss.append(loss_epoch) - self.loss_metric.reset_states() - - if epoch % iterations_per_epoch == 0: - self.val_step(val_ds) - val_loss_epoch = self.loss_metric.result().numpy() - val_acc_result = self.metric.result().numpy() - print( - "Epoch {0}: Train loss {1}, Val loss {2}, Val acc {3}".format( - str(epoch), - str(loss_epoch), - str(round(val_loss_epoch, 4)), - str(round(val_acc_result, 4)), - )) - - if val_acc_result < function(val_acc): - self.save_weights(os.path.join(model_directory, 'model')) - - val_loss.append(val_loss_epoch) - val_acc.append(val_acc_result) - self.loss_metric.reset_states() - self.metric.reset_states() - - # History of the training - losses = dict(train_loss_results=train_loss, - val_loss_results=val_acc - ) - with open(os.path.join(model_directory, 'history.pickle'), 'wb') as d: - pickle.dump(losses, d, protocol=pickle.HIGHEST_PROTOCOL) - - - def train_and_evaluate(self, - train_dataset, - val_dataset, - num_epochs, - iterations_per_epoch, - model_directory, - **kwargs): - - return self.fit(train_dataset, - val_dataset, - num_epochs=num_epochs, - model_directory=model_directory, - iterations_per_epoch=iterations_per_epoch, - **kwargs) \ No newline at end of file diff --git a/eo-flow/eoflow/base/base_input.py b/eo-flow/eoflow/base/base_input.py deleted file mode 100644 index f3abf0e..0000000 --- a/eo-flow/eoflow/base/base_input.py +++ /dev/null @@ -1,8 +0,0 @@ -from . import Configurable - - -class BaseInput(Configurable): - def get_dataset(self): - """Builds and returns a tensorflow Dataset object for reading the data.""" - - raise NotImplementedError diff --git a/eo-flow/eoflow/base/base_task.py b/eo-flow/eoflow/base/base_task.py deleted file mode 100644 index 60e0c31..0000000 --- a/eo-flow/eoflow/base/base_task.py +++ /dev/null @@ -1,28 +0,0 @@ -from . import Configurable, BaseInput -from ..utils import parse_classname - - -class BaseTask(Configurable): - def __init__(self, model, config_specs): - super().__init__(config_specs) - - self.model = model - - @staticmethod - def parse_input(input_config): - """ Builds the input dataset using the provided configuration. """ - - classname, config = input_config.classname, input_config.config - - cls = parse_classname(classname) - if not issubclass(cls, BaseInput): - raise ValueError("Data input class does not inherit from BaseInput.") - - model_input = cls(config) - - return model_input.get_dataset() - - def run(self): - """Executes the task.""" - - raise NotImplementedError diff --git a/eo-flow/eoflow/base/base_training.py b/eo-flow/eoflow/base/base_training.py deleted file mode 100644 index dbd5dce..0000000 --- a/eo-flow/eoflow/base/base_training.py +++ /dev/null @@ -1,157 +0,0 @@ -import os - -import tensorflow as tf - -from . import Configurable - - -class BaseModelTraining(tf.keras.Model, Configurable): - def __init__(self, config_specs): - tf.keras.Model.__init__(self) - Configurable.__init__(self, config_specs) - - self.net = None - - self.init_model() - - def init_model(self): - """ Called on __init__. Keras model initialization. Create model here if does not require the inputs shape """ - pass - - def build(self, inputs_shape): - """ Keras method. Called once to build the model. Build the model here if the input shape is required. """ - pass - - def call(self, inputs, training=False): - pass - - def prepare(self, optimizer=None, loss=None, metrics=None, **kwargs): - """ Prepares the model for training and evaluation. This method should create the - optimizer, loss and metric functions and call the compile method of the model. The model - should provide the defaults for the optimizer, loss and metrics, which can be overriden - with custom arguments. """ - - raise NotImplementedError - - def load_latest(self, model_directory): - """ Loads weights from the latest checkpoint in the model directory. """ - - checkpoints_path = os.path.join(model_directory, 'checkpoints', 'model.ckpt') - return self.load_weights(checkpoints_path).expect_partial() - - - def _fit(self, - dataset, - num_epochs, - model_directory, - iterations_per_epoch, - val_dataset=None, - save_steps=100, - summary_steps='epoch', - callbacks=[], - **kwargs): - """ Trains and evaluates the model on a given dataset, saving the model and recording summaries. """ - logs_path = os.path.join(model_directory, 'logs') - checkpoints_path = os.path.join(model_directory, 'checkpoints', 'model.ckpt') - - # Tensorboard callback - tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logs_path, - update_freq=summary_steps, - profile_batch=0) - - # Checkpoint saving callback - checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(checkpoints_path, - save_best_only=True, - save_freq=save_steps, - save_weights_only=True) - return self.fit(dataset, - validation_data=val_dataset, - epochs=num_epochs, - steps_per_epoch=iterations_per_epoch, - callbacks=[tensorboard_callback, checkpoint_callback] + callbacks, - **kwargs) - - def train(self, - dataset, - num_epochs, - model_directory, - iterations_per_epoch=None, - save_steps=100, - summary_steps='epoch', - callbacks=[], - **kwargs): - """ Trains the model on a given dataset. Takes care of saving the model and recording summaries. - - :param dataset: A tf.data Dataset containing the input training data. - The dataset must be of shape (features, labels) where features and labels contain the data - in the shape required by the model. - :type dataset: tf.data.Dataset - :param num_epochs: Number of epochs. One epoch is equal to one pass over the dataset. - :type num_epochs: int - :param model_directory: Output directory, where the model checkpoints and summaries are saved. - :type model_directory: str - :param iterations_per_epoch: Number of training steps to make every epoch. - Training dataset is repeated automatically when the end is reached. - :type iterations_per_epoch: int - :param save_steps: Number of steps between saving model checkpoints. - :type save_steps: int - :param summary_steps: Number of steps between recording summaries. - :type summary_steps: str or int - :param callbacks: Customised Keras callbacks to use during training/evaluation - :type callbacks: tf.keras.callbacks - - Other keyword parameters are passed to the Model.fit method. - """ - - return self._fit(dataset if iterations_per_epoch is None else dataset.repeat(), - num_epochs=num_epochs, - model_directory=model_directory, - iterations_per_epoch=iterations_per_epoch, - save_steps=save_steps, - summary_steps=summary_steps, - callbacks=callbacks, - **kwargs) - - def train_and_evaluate(self, - train_dataset, - val_dataset, - num_epochs, - iterations_per_epoch, - model_directory, - save_steps=100, summary_steps='epoch', - callbacks=[], - **kwargs): - """ Trains the model on a given dataset. At the end of each epoch an evaluation is performed on the provided - validation dataset. Takes care of saving the model and recording summaries. - - :param train_dataset: A tf.data Dataset containing the input training data. - The dataset must be of shape (features, labels) where features and labels contain the data - in the shape required by the model. - :type train_dataset: tf.data.Dataset - :param val_dataset: Same as for `train_dataset`, but for the validation data. - :type val_dataset: tf.data.Dataset - :param num_epochs: Number of epochs. Epoch size is independent from the dataset size. - :type num_epochs: int - :param iterations_per_epoch: Number of training steps to make every epoch. - Training dataset is repeated automatically when the end is reached. - :type iterations_per_epoch: int - :param model_directory: Output directory, where the model checkpoints and summaries are saved. - :type model_directory: str - :param save_steps: Number of steps between saving model checkpoints. - :type save_steps: int - :param summary_steps: Number of steps between recodring summaries. - :type summary_steps: str or int - :param callbacks: Customised Keras callbacks to use during training/evaluation - :type callbacks: tf.keras.callbacks - - Other keyword parameters are passed to the Model.fit method. - """ - return self._fit(train_dataset.repeat(), - num_epochs, - model_directory, - iterations_per_epoch, - val_dataset=val_dataset, - save_steps=save_steps, - summary_steps=summary_steps, - callbacks=callbacks, - **kwargs) diff --git a/eo-flow/eoflow/base/configuration.py b/eo-flow/eoflow/base/configuration.py deleted file mode 100644 index 50532d7..0000000 --- a/eo-flow/eoflow/base/configuration.py +++ /dev/null @@ -1,74 +0,0 @@ -from abc import ABC -import inspect -import json - -from marshmallow import Schema, fields -from munch import Munch - - -def dict_to_munch(obj): - """ Recursively convert a dict to Munch. (there is a Munch.from_dict method, but it's not python3 compatible) - """ - if isinstance(obj, list): - return [dict_to_munch(element) for element in obj] - if isinstance(obj, dict): - return Munch({k: dict_to_munch(v) for k, v in obj.items()}) - return obj - - -class ObjectConfiguration(Schema): - classname = fields.String(required=True, description="Class to instantiate.") - config = fields.Dict(required=True, descripton="Configuration used for instantiation of the class.") - - -class Configurable(ABC): - """ Base class for all configurable objects. - """ - - def __init__(self, config_specs): - self.schema = self.initialize_schema() - self.config = self._prepare_config(config_specs) - - @classmethod - def initialize_schema(cls): - """ A Schema should be provided as an internal class of any class that inherits from Configurable. - This method finds the Schema by traversing the inheritance tree. If no Schema is provided or inherited - an error is raised. - """ - for item in vars(cls).values(): - if inspect.isclass(item) and issubclass(item, Schema): - return item() - - if len(cls.__bases__) > 1: - raise RuntimeError('Class does not have a defined schema however it inherits from multiple ' - 'classes. Which one should schema be inherited from?') - - parent_class = cls.__bases__[0] - - if parent_class is Configurable: - raise NotImplementedError('Configuration schema not provided.') - - return parent_class.initialize_schema() - - def _prepare_config(self, config_specs): - """ Collects and validates configuration dictionary - """ - - # if config_specs is a path - if isinstance(config_specs, str): - with open(config_specs, 'r') as config_file: - config_specs = json.load(config_file) - - return Config(self.schema.load(config_specs)) - - def show_config(self): - print(json.dumps(self.config, indent=4)) - - -class Config(Munch): - """ Config object used for automatic object creation from a dict. - """ - def __init__(self, config): - config = dict_to_munch(config) - - super().__init__(config) diff --git a/eo-flow/eoflow/execute.py b/eo-flow/eoflow/execute.py deleted file mode 100644 index 39d73de..0000000 --- a/eo-flow/eoflow/execute.py +++ /dev/null @@ -1,47 +0,0 @@ -import argparse -import json - -from marshmallow import Schema, fields - -from .base import BaseModelTraining, BaseTask -from .base.configuration import ObjectConfiguration, Config -from .utils import parse_classname - - -class ExecutionConfig(Schema): - model = fields.Nested(ObjectConfiguration, required=True, description='Model configuration') - task = fields.Nested(ObjectConfiguration, required=True, description='Task configuration') - - -def execute(config_file): - """Executes a workflow defined in a config file.""" - - with open(config_file) as file: - config = json.load(file) - - config = Config(ExecutionConfig().load(config)) - - # Parse model config - model_cls = parse_classname(config.model.classname) - if not issubclass(model_cls, BaseModelTraining): - raise ValueError("Model class does not inherit from BaseModel.") - model = model_cls(config.model.config) - - # Parse task config - task_cls = parse_classname(config.task.classname) - if not issubclass(task_cls, BaseTask): - raise ValueError("Task class does not inherit from BaseTask.") - task = task_cls(model, config.task.config) - - # Run task - task.run() - - -if __name__ == '__main__': - parser = argparse.ArgumentParser(description='Executes a workflow described in a provided config file.') - - parser.add_argument('config_file', type=str, help='Path to the configuration file.') - - args = parser.parse_args() - - execute(config_file=args.config_file) diff --git a/eo-flow/eoflow/input/__init__.py b/eo-flow/eoflow/input/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/eo-flow/eoflow/input/eopatch.py b/eo-flow/eoflow/input/eopatch.py deleted file mode 100644 index 42e1630..0000000 --- a/eo-flow/eoflow/input/eopatch.py +++ /dev/null @@ -1,117 +0,0 @@ -import os -import numpy as np -import tensorflow as tf -from marshmallow import fields, Schema -from marshmallow.validate import OneOf -from eolearn.core import EOPatch, FeatureType - -from ..base import BaseInput - -_valid_types = [t.value for t in FeatureType] - - -def eopatch_dataset(root_dir_or_list, features_data, fill_na=None): - """ Creates a tf dataset with features from saved EOPatches. - - :param root_dir_or_list: Root directory containing eopatches or a list of eopatch directories. - :type root_dir_or_list: str or list(str) - :param features_data: List of tuples containing data about features to extract. - Tuple structure: (feature_type, feature_name, out_feature_name, feature_dtype, feature_shape) - :type features_data: (str, str, str, np.dtype, tuple) - :param fill_na: Value with wich to replace nan values. No replacement is done if None. - :type fill_na: int - """ - - if isinstance(root_dir_or_list, str): - file_pattern = os.path.join(root_dir_or_list, '*') - dataset = tf.data.Dataset.list_files(file_pattern) - else: - dataset = tf.data.Dataset.from_tensor_slices(root_dir_or_list) - - def _read_patch(path): - """ TF op for reading an eopatch at a given path. """ - def _func(path): - path = path.numpy().decode('utf-8') - - # Load only relevant features - features = [(data[0], data[1]) for data in features_data] - patch = EOPatch.load(path, features=features) - - data = [] - for feat_type, feat_name, out_name, dtype, shape in features_data: - arr = patch[feat_type][feat_name].astype(dtype) - - if fill_na is not None: - arr[np.isnan(arr)] = fill_na - - data.append(arr) - - return data - - out_types = [tf.as_dtype(data[3]) for data in features_data] - data = tf.py_function(_func, [path], out_types) - - out_data = {} - for f_data, feature in zip(features_data, data): - feat_type, feat_name, out_name, dtype, shape = f_data - feature.set_shape(shape) - out_data[out_name] = feature - - return out_data - - dataset = dataset.map(_read_patch) - return dataset - - -class EOPatchSegmentationInput(BaseInput): - """ An input method for basic EOPatch reading. Reads features and segmentation labels. For more complex behaviour - (subpatch extraction, data augmentation, caching, ...) create your own input method (see examples). - """ - - class _Schema(Schema): - data_dir = fields.String(description="The directory containing EOPatches.", required=True) - - input_feature_type = fields.String(description="Feature type of the input feature.", required=True, validate=OneOf(_valid_types)) - input_feature_name = fields.String(description="Name of the input feature.", required=True) - input_feature_axis = fields.List(fields.Int, description="Height and width axis for the input features", required=True, example=[1,2]) - input_feature_shape = fields.List(fields.Int, description="Shape of the input feature. Use -1 for unknown dimesnions.", - required=True, example=[-1, 100, 100, 3]) - - labels_feature_type = fields.String(description="Feature type of the labels feature.", required=True, validate=OneOf(_valid_types)) - labels_feature_name = fields.String(description="Name of the labels feature.", required=True) - labels_feature_axis = fields.List(fields.Int, description="Height and width axis for the labels", required=True, example=[1,2]) - labels_feature_shape = fields.List(fields.Int, description="Shape of the labels feature. Use -1 for unknown dimesnions.", - required=True, example=[-1, 100, 100, 3]) - - batch_size = fields.Int(description="Number of examples in a batch.", required=True, example=20) - num_classes = fields.Int(description="Number of classes. Used for one-hot encoding.", required=True, example=2) - - def _parse_shape(self, shape): - shape = [None if s < 0 else s for s in shape] - return shape - - def get_dataset(self): - cfg = self.config - - # Create a tf.data.Dataset from EOPatches - features_data = [ - (cfg.input_feature_type, cfg.input_feature_name, 'features', np.float32, self._parse_shape(cfg.input_feature_shape)), - (cfg.labels_feature_type, cfg.labels_feature_name, 'labels', np.int64, self._parse_shape(cfg.labels_feature_shape)) - ] - dataset = eopatch_dataset(self.config.data_dir, features_data, fill_na=-2) - - # One-hot encode labels and return tuple - def _prepare_data(data): - features = data['features'] - labels = data['labels'][...,0] - - labels_oh = tf.one_hot(labels, depth=self.config.num_classes) - - return features, labels_oh - - dataset = dataset.map(_prepare_data) - - # Create batches - dataset = dataset.batch(self.config.batch_size) - - return dataset diff --git a/eo-flow/eoflow/input/hdf5.py b/eo-flow/eoflow/input/hdf5.py deleted file mode 100644 index f634f1b..0000000 --- a/eo-flow/eoflow/input/hdf5.py +++ /dev/null @@ -1,44 +0,0 @@ -import os - -import h5py -import tensorflow as tf - -def hdf5_dataset(path, features): - """ Creates a tf.data.Dataset from a hdf5 file - - :param path: path to the hdf5 file, - :type path: str - :param features: dict of (`dataset` -> `feature_name`) mappings, where `dataset` is the dataset name in the hdf5 file - and `feature_name` is the name of the feature it is saved to. - :type features: dict - - :return: dataset containing examples merged from files - :rtype: tf.data.Dataset - """ - - fields = list(features.keys()) - feature_names = [features[f] for f in features] - - # Reads dataset row by row - def _generator(): - with h5py.File(path, 'r') as file: - datasets = [file[field] for field in fields] - for row in zip(*datasets): - yield row - - # Converts a database of tuples to database of dicts - def _to_dict(*features): - return {name: feat for name, feat in zip(feature_names, features)} - - # Reads hdf5 metadata (types and shapes) - with h5py.File(path, 'r') as file: - datasets = [file[field] for field in fields] - - types = tuple(ds.dtype for ds in datasets) - shapes = tuple(ds.shape[1:] for ds in datasets) - - # Create dataset - ds = tf.data.Dataset.from_generator(_generator, types, shapes) - ds = ds.map(_to_dict) - - return ds diff --git a/eo-flow/eoflow/input/numpy.py b/eo-flow/eoflow/input/numpy.py deleted file mode 100644 index 1afb15a..0000000 --- a/eo-flow/eoflow/input/numpy.py +++ /dev/null @@ -1,102 +0,0 @@ -import os - -import numpy as np -import tensorflow as tf - -def numpy_dataset(np_array_dict): - """ Creates a tf.data Dataset from a dict of numpy arrays. """ - - # Unpack - feature_names = list(np_array_dict.keys()) - np_arrays = [np_array_dict[name] for name in feature_names] - - # Check that arrays match in the first dimension - n_samples = np_arrays[0].shape[0] - assert all(n_samples == arr.shape[0] for arr in np_arrays) - - # Extract types and shapes form np arrays - types = tuple(arr.dtype for arr in np_arrays) - shapes = tuple(arr.shape[1:] for arr in np_arrays) - - def _generator(): - # Iterate through the first dimension of arrays - for slices in zip(*np_arrays): - yield slices - - ds = tf.data.Dataset.from_generator(_generator, types, shapes) - ds = ds.take(n_samples) - - # Converts a database of tuples to database of dicts - def _to_dict(*features): - return {name: feat for name, feat in zip(feature_names, features)} - - ds = ds.map(_to_dict) - - return ds - -def _read_numpy_file(file_path, fields): - """ Reads a single npz file. """ - - data = np.load(file_path) - np_arrays = [data[f] for f in fields] - - # Check that arrays match in the first dimension - n_samples = np_arrays[0].shape[0] - assert all(n_samples == arr.shape[0] for arr in np_arrays) - - return tuple(np_arrays) - -def npz_dir_dataset(file_dir_or_list, features, num_parallel=5): - """ Creates a tf.data.Dataset from a directory containing numpy .npz files. Files are loaded - lazily when needed. `num_parallel` files are read in parallel and interleaved together. - - :param file_dir_or_list: directory containing .npz files or a list of paths to .npz files - :type file_dir_or_list: str | list(str) - :param features: dict of (`field` -> `feature_name`) mappings, where `field` is the field in the .npz array - and `feature_name` is the name of the feature it is saved to. - :type features: dict - :param num_parallel: number of files to read in parallel and intereleave, defaults to 5 - :type num_parallel: int, optional - - :return: dataset containing examples merged from files - :rtype: tf.data.Dataset - """ - - files = file_dir_or_list - - # If dir, then list files - if isinstance(file_dir_or_list, str): - files = [os.path.join(file_dir_or_list, f) for f in os.listdir(file_dir_or_list)] - - fields = list(features.keys()) - feature_names = [features[f] for f in features] - - # Read one file for shape info - file = next(iter(files)) - data = np.load(file) - np_arrays = [data[f] for f in fields] - - # Read shape and type info - types = tuple(arr.dtype for arr in np_arrays) - shapes = tuple((None,) + arr.shape[1:] for arr in np_arrays) - - def _data_generator(files, fields): - """ Returns samples from one file at a time. """ - for f in files: - yield _read_numpy_file(f, fields) - - # Converts a database of tuples to database of dicts - def _to_dict(*features): - return {name: feat for name, feat in zip(feature_names, features)} - - # Create dataset - ds = tf.data.Dataset.from_generator(lambda:_data_generator(files, fields), types, shapes) - - # Prefetch needed amount of files for interleaving - ds = ds.prefetch(num_parallel) - - # Unbatch and interleave - ds = ds.interleave(lambda *x: tf.data.Dataset.from_tensor_slices(x), cycle_length=num_parallel) - ds = ds.map(_to_dict) - - return ds diff --git a/eo-flow/eoflow/input/operations.py b/eo-flow/eoflow/input/operations.py deleted file mode 100644 index 988dd93..0000000 --- a/eo-flow/eoflow/input/operations.py +++ /dev/null @@ -1,210 +0,0 @@ -import os -import numpy as np -import tensorflow as tf - -from ..utils import create_dirs - - -def extract_subpatches(patch_size, spatial_features_and_axis, random_sampling=False, num_random_samples=20, - grid_overlap=0.2): - """ Builds a TF op for building a dataset of subpatches from tensors. Subpatches sampling can be random or grid based. - - :param patch_size: Width and height of extracted patches - :type patch_size: (int, int) - :param spatial_features_and_axis: List of features from which subpatches are extracted and their height and width axis. - Elements are tuples of (feature_name, (axis_h, axis_w)). - :type spatial_features_and_axis: list of (string, (int, int)) - :param random_sampling: If True random sampling is used. Else grid based sampling is used. - :type random_sampling: bool - :param num_random_samples: Defines the number of subpatches to sample, when random sampling is used. - :type num_random_samples: int - :param grid_overlap: Amount of overlap between subpatches extracted from a grid - :type grid_overlap: float - """ - - patch_w, patch_h = patch_size - - def _fn(data): - feat_name_ref, axis_ref = spatial_features_and_axis[0] - ay_ref, ax_ref = axis_ref - # Get random coordinates - - def _py_get_random(image): - x_space = image.shape[ax_ref]-patch_w - if x_space > 0: - x_rand = np.random.randint(x_space, size=num_random_samples, dtype=np.int64) - else: - x_rand = np.zeros(num_random_samples, np.int64) - - y_space = image.shape[ay_ref]-patch_h - if y_space > 0: - y_rand = np.random.randint(y_space, size=num_random_samples, dtype=np.int64) - else: - y_rand = np.zeros(num_random_samples, np.int64) - - return x_rand, y_rand - - # Get coordinates on a grid - def _py_get_gridded(image): - - # alpha is overlaping ratio (w.r.t. patch size) - alpha = grid_overlap - - img_height = image.shape[ay_ref] - img_width = image.shape[ax_ref] - - # number of patches in x and y direction - nx = int(np.ceil((img_width - alpha * patch_w) / (patch_w * (1 - alpha)))) - ny = int(np.ceil((img_height - alpha * patch_h) / (patch_h * (1 - alpha)))) - - # total number of patches - N = nx * ny - # allocate output vectors (top-left patch coordinates) - tl_x = np.zeros(N, dtype=np.int64) - tl_y = np.zeros(N, dtype=np.int64) - - # calculate actual x and y coordinates - for yi in range(ny): - if yi == 0: - # the highest patch has x0 = 0 - y_ = 0 - elif yi == ny - 1: - # the lowest patch has y0 = H - patch_h - y_ = img_height - patch_h - else: - # calculate top-left y coordinate and take into account overlaping, too - y_ = np.round(yi * patch_h - yi * alpha * patch_h) - - for xi in range(nx): - if xi == 0: - # the left-most patch has x0 = 0 - x_ = 0 - elif xi == nx - 1: - # the right-most patch has x0 = W - patch_w - x_ = img_width - patch_w - else: - # calculate top-left x coordinate and take into account overlaping, too - x_ = np.round(xi * patch_w - xi * alpha * patch_w) - - id = yi * nx + xi - tl_x[id] = np.int64(x_) - tl_y[id] = np.int64(y_) - - return tl_x, tl_y - - if random_sampling: - x_samp, y_samp = tf.py_function(_py_get_random, [data[feat_name_ref]], [tf.int64, tf.int64]) - else: - x_samp, y_samp = tf.py_function(_py_get_gridded, [data[feat_name_ref]], [tf.int64, tf.int64]) - - def _py_get_patches(axis): - ay, ax = axis - # Extract patches for given coordinates - - def _func(image, x_samp, y_samp): - patches = [] - - # Pad if necessary - x_pad = max(0, patch_w - image.shape[ax]) - y_pad = max(0, patch_h - image.shape[ay]) - - if x_pad > 0 or y_pad > 0: - pad_x1 = x_pad//2 - pad_x2 = x_pad - pad_x1 - pad_y1 = y_pad//2 - pad_y2 = y_pad - pad_y1 - - padding = [(0,0) for _ in range(image.ndim)] - padding[ax] = (pad_x1,pad_x2) - padding[ay] = (pad_y1,pad_y2) - image = np.pad(image, padding, 'constant') - - # Extract patches - for x, y in zip(x_samp, y_samp): - # Slice on specified axis - slicing = [slice(None) for _ in range(image.ndim)] - slicing[ax] = slice(x, x+patch_w) - slicing[ay] = slice(y, y+patch_h) - - patch = image[slicing] - patches.append(patch) - return np.stack(patches) - - return _func - - data_out = {} - # TODO: repeat the rest of the data - for feat_name, axis in spatial_features_and_axis: - ay, ax = axis - shape = data[feat_name].shape.as_list() - patches = tf.py_function(_py_get_patches(axis), [data[feat_name], x_samp, y_samp], data[feat_name].dtype) - - # Update shape information - shape[ax] = patch_w - shape[ay] = patch_h - shape = [None] + shape - patches.set_shape(shape) - - data_out[feat_name] = patches - - # TODO: shuffle subpatches - return tf.data.Dataset.from_tensor_slices(data_out) - - return _fn - - -def augment_data(features_to_augment, brightness_delta=0.1, contrast_bounds=(0.9,1.1)): - """ Builds a function that randomly augments features in specified ways. - - param features_to_augment: List of features to augment and which operations to perform on them. - Each element is of shape (feature, list_of_operations). - type features_to_augment: list of (str, list of str) - param brightness_delta: Maximum brightness change. - type brightness_delta: float - param contrast_bounds: Upper and lower bounds of contrast multiplier. - type contrast_bounds: (float, float) - """ - - def _augment(data): - contrast_lower, contrast_upper = contrast_bounds - - flip_lr_cond = tf.random.uniform(shape=[]) > 0.5 - flip_ud_cond = tf.random.uniform(shape=[]) > 0.5 - rot90_amount = tf.random.uniform(shape=[], maxval=4, dtype=tf.int32) - - # Available operations - operations = { - 'flip_left_right': lambda x: tf.cond(flip_lr_cond, lambda: tf.image.flip_left_right(x), lambda: x), - 'flip_up_down': lambda x: tf.cond(flip_ud_cond, lambda: tf.image.flip_up_down(x), lambda: x), - 'rotate': lambda x: tf.image.rot90(x, rot90_amount), - 'brightness': lambda x: tf.image.random_brightness(x, brightness_delta), - 'contrast': lambda x: tf.image.random_contrast(x, contrast_lower, contrast_upper) - } - - for feature, ops in features_to_augment: - # Apply specified ops to feature - for op in ops: - operation_fn = operations[op] - data[feature] = operation_fn(data[feature]) - - return data - - return _augment - - -def cache_dataset(dataset, path): - """ Caches dataset into a file. Each element in the dataset will be computed only once. """ - - # Create dir if missing - directory = os.path.dirname(path) - create_dirs([directory]) - - # Cache - dataset = dataset.cache(path) - - # Disable map and batch fusion to prevent a bug when caching - options = tf.data.Options() - options.experimental_optimization.map_and_batch_fusion = False - dataset = dataset.with_options(options) - - return dataset diff --git a/eo-flow/eoflow/input/random.py b/eo-flow/eoflow/input/random.py deleted file mode 100644 index dc53647..0000000 --- a/eo-flow/eoflow/input/random.py +++ /dev/null @@ -1,76 +0,0 @@ -import numpy as np -import tensorflow as tf -from marshmallow import fields, Schema - -from ..base import BaseInput - - -class RandomClassificationInput(BaseInput): - """ Class to create random batches for classification tasks. Can be used for prototyping. """ - - class _Schema(Schema): - input_shape = fields.List(fields.Int, description="Shape of a single input example.", required=True, example=[784]) - num_classes = fields.Int(description="Number of classes.", required=True, example=10) - - batch_size = fields.Int(description="Number of examples in a batch.", required=True, example=20) - batches_per_epoch = fields.Int(required=True, description='Number of batches in epoch', example=20) - - def _generate_batch(self): - for i in range(self.config.batches_per_epoch): - input_shape = [self.config.batch_size] + self.config.input_shape - input_data = np.random.rand(*input_shape) - - onehot = np.eye(self.config.num_classes) - output_shape = [self.config.batch_size] - classes = np.random.randint(self.config.num_classes, size=output_shape) - labels = onehot[classes] - - yield input_data, labels - - def get_dataset(self): - input_shape = [self.config.batch_size] + self.config.input_shape - output_shape = [self.config.batch_size, self.config.num_classes] - - dataset = tf.data.Dataset.from_generator( - self._generate_batch, - (tf.float32, tf.float32), - (tf.TensorShape(input_shape), tf.TensorShape(output_shape)) - ) - - return dataset - - -class RandomSegmentationInput(BaseInput): - """ Class to create random batches for segmentation tasks. Can be used for prototyping. """ - - class _Schema(Schema): - input_shape = fields.List(fields.Int, description="Shape of a single input example.", required=True, example=[512,512,3]) - output_shape = fields.List(fields.Int, description="Shape of a single output mask.", required=True, example=[128,128]) - num_classes = fields.Int(description="Number of segmentation classes.", required=True, example=10) - - batch_size = fields.Int(description="Number of examples in a batch.", required=True, example=20) - batches_per_epoch = fields.Int(required=True, description='Number of batches in epoch', example=20) - - def _generate_batch(self): - for i in range(self.config.batches_per_epoch): - input_shape = [self.config.batch_size] + self.config.input_shape - input_data = np.random.rand(*input_shape) - - onehot = np.eye(self.config.num_classes) - output_shape = [self.config.batch_size] + self.config.output_shape - classes = np.random.randint(self.config.num_classes, size=output_shape) - labels = onehot[classes] - - yield input_data, labels - - def get_dataset(self): - input_shape = [self.config.batch_size] + self.config.input_shape - output_shape = [self.config.batch_size] + self.config.output_shape + [self.config.num_classes] - - dataset = tf.data.Dataset.from_generator( - self._generate_batch, - (tf.float32, tf.float32), - (tf.TensorShape(input_shape), tf.TensorShape(output_shape)) - ) - - return dataset diff --git a/eo-flow/eoflow/models/__init__.py b/eo-flow/eoflow/models/__init__.py deleted file mode 100644 index a7525a8..0000000 --- a/eo-flow/eoflow/models/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from eoflow.models.segmentation_task.segmentation_unets import FCNModel, TFCNModel -from eoflow.models.tempnets_task.cnn_tempnets import TCNModel, TempCNNModel -from eoflow.models.tempnets_task.rnn_tempnets import BiRNN, ConvLSTM -#from eoflow.models.tempnets_task.mlp_tempnets import TransformerEncoder, PseTae, MLP \ No newline at end of file diff --git a/eo-flow/eoflow/models/callbacks.py b/eo-flow/eoflow/models/callbacks.py deleted file mode 100644 index 14657f3..0000000 --- a/eo-flow/eoflow/models/callbacks.py +++ /dev/null @@ -1,91 +0,0 @@ -import tensorflow as tf -import numpy as np -import matplotlib as mpl -import matplotlib.pyplot as plt - -from ..utils.tf_utils import plot_to_image - - -class VisualizationCallback(tf.keras.callbacks.Callback): - """ Keras Callback for saving prediction visualizations to TensorBoard. """ - - def __init__(self, val_images, log_dir, time_index=0, rgb_indices=[2, 1, 0]): - """ - :param val_images: Images to run predictions on. Tuple of (images, labels). - :type val_images: (np.array, np.array) - :param log_dir: Directory where the TensorBoard logs are written. - :type log_dir: str - :param time_index: Time index to use, when multiple time slices are available, defaults to 0 - :type time_index: int, optional - :param rgb_indices: Indices for R, G and B bands in the input image, defaults to [0,1,2] - :type rgb_indices: list, optional - """ - super().__init__() - - self.val_images = val_images - self.time_index = time_index - self.rgb_indices = rgb_indices - - self.file_writer = tf.summary.create_file_writer(log_dir) - - @staticmethod - def plot_predictions(input_image, labels, predictions, n_classes): - # TODO: fix figsize (too wide?) - fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5)) - - scaled_image = np.clip(input_image*2.5, 0., 1.) - ax1.imshow(scaled_image) - ax1.title.set_text('Input image') - - cnorm = mpl.colors.NoNorm() - cmap = plt.cm.get_cmap('Set3', n_classes) - - ax2.imshow(labels, cmap=cmap, norm=cnorm) - ax2.title.set_text('Labeled classes') - - img = ax3.imshow(predictions, cmap=cmap, norm=cnorm) - ax3.title.set_text('Predicted classes') - - plt.colorbar(img, ax=[ax1, ax2, ax3], shrink=0.8, ticks=list(range(n_classes))) - - return fig - - def prediction_summaries(self, step): - images, labels = self.val_images - preds_raw = self.model.predict(images) - - pred_shape = tf.shape(preds_raw) - - # If temporal data only use time_index slice - if images.ndim == 5: - images = images[:, self.time_index, :, :, :] - - # Crop images and labels to output size - labels = tf.image.resize_with_crop_or_pad(labels, pred_shape[1], pred_shape[2]) - images = tf.image.resize_with_crop_or_pad(images, pred_shape[1], pred_shape[2]) - - # Take RGB values - images = images.numpy()[..., self.rgb_indices] - - num_classes = labels.shape[-1] - - # Get class ids - preds_raw = np.argmax(preds_raw, axis=-1) - labels = np.argmax(labels, axis=-1) - - vis_images = [] - for image_i, labels_i, pred_i in zip(images, labels, preds_raw): - # Plot predictions and convert to image - fig = self.plot_predictions(image_i, labels_i, pred_i, num_classes) - img = plot_to_image(fig) - - vis_images.append(img) - - n_images = len(vis_images) - vis_images = tf.concat(vis_images, axis=0) - - with self.file_writer.as_default(): - tf.summary.image('predictions', vis_images, step=step, max_outputs=n_images) - - def on_epoch_end(self, epoch, logs=None): - self.prediction_summaries(epoch) diff --git a/eo-flow/eoflow/models/embeddings.py b/eo-flow/eoflow/models/embeddings.py deleted file mode 100644 index c24c133..0000000 --- a/eo-flow/eoflow/models/embeddings.py +++ /dev/null @@ -1,29 +0,0 @@ -from sklearn.base import BaseEstimator,RegressorMixin -from sklearn.exceptions import NotFittedError - -class EmbeddingEstimator(BaseEstimator,RegressorMixin): - def __init__(self, model): - self.model = model - self.estimator_fitted = False - - def get_embeddings(self, x): - self.model.predict(x) - return self.model.get_feature_map(inputs=x) - - def define_estimator(self, estimator): - self.estimator = estimator - return self - - def fit(self, x,y): - x = self.get_embeddings(x) - self.estimator.fit(x, y) - self.estimator_fitted = True - return self - - def predict(self, x): - if not self.estimator_fitted: - raise NotFittedError( - 'The estimator must be fitted before calling predict(...).' - ) - x = self.get_embeddings(x) - return self.estimator.predict(x) \ No newline at end of file diff --git a/eo-flow/eoflow/models/layers.py b/eo-flow/eoflow/models/layers.py deleted file mode 100644 index bc07bca..0000000 --- a/eo-flow/eoflow/models/layers.py +++ /dev/null @@ -1,407 +0,0 @@ -import tensorflow as tf - -from tensorflow.keras.layers import Activation, SpatialDropout1D, Lambda, UpSampling2D, AveragePooling2D -from tensorflow.keras.layers import Conv1D, BatchNormalization, LayerNormalization - - -class ResidualBlock(tf.keras.layers.Layer): - """ Code taken from keras-tcn implementation on available on - https://github.com/philipperemy/keras-tcn/blob/master/tcn/tcn.py#L140 """ - def __init__(self, - dilation_rate, - nb_filters, - kernel_size, - padding, - activation='relu', - dropout_rate=0, - kernel_initializer='he_normal', - kernel_regularizer = 0, - use_batch_norm=False, - use_layer_norm=False, - last_block=True, - **kwargs): - - """ Defines the residual block for the WaveNet TCN - - :param dilation_rate: The dilation power of 2 we are using for this residual block - :param nb_filters: The number of convolutional filters to use in this block - :param kernel_size: The size of the convolutional kernel - :param padding: The padding used in the convolutional layers, 'same' or 'causal'. - :param activation: The final activation used in o = Activation(x + F(x)) - :param dropout_rate: Float between 0 and 1. Fraction of the input units to drop. - :param kernel_initializer: Initializer for the kernel weights matrix (Conv1D). - :param use_batch_norm: Whether to use batch normalization in the residual layers or not. - :param use_layer_norm: Whether to use layer normalization in the residual layers or not. - :param last_block: Whether to add a residual connection to the convolution layer or not. - :param kwargs: Any initializers for Layer class. - """ - - self.dilation_rate = dilation_rate - self.nb_filters = nb_filters - self.kernel_size = kernel_size - self.padding = padding - self.activation = activation - self.dropout_rate = dropout_rate - self.use_batch_norm = use_batch_norm - self.use_layer_norm = use_layer_norm - self.kernel_initializer = kernel_initializer - self.kernel_regularizer = kernel_regularizer - self.last_block = last_block - self.residual_layers = [] - self.shape_match_conv = None - self.res_output_shape = None - self.final_activation = None - - super(ResidualBlock, self).__init__(**kwargs) - - def _add_and_activate_layer(self, layer): - """Helper function for building layer - Args: - layer: Appends layer to internal layer list and builds it based on the current output - shape of ResidualBlocK. Updates current output shape. - """ - self.residual_layers.append(layer) - self.residual_layers[-1].build(self.res_output_shape) - self.res_output_shape = self.residual_layers[-1].compute_output_shape(self.res_output_shape) - - def build(self, input_shape): - - with tf.keras.backend.name_scope(self.name): # name scope used to make sure weights get unique names - self.res_output_shape = input_shape - - for k in range(2): - name = f'conv1D_{k}' - with tf.keras.backend.name_scope(name): # name scope used to make sure weights get unique names - self._add_and_activate_layer(Conv1D(filters=self.nb_filters, - kernel_size=self.kernel_size, - dilation_rate=self.dilation_rate, - padding=self.padding, - name=name, - kernel_regularizer = tf.keras.regularizers.l2(self.kernel_regularizer), - kernel_initializer=self.kernel_initializer)) - - if self.use_batch_norm: - self._add_and_activate_layer(BatchNormalization()) - elif self.use_layer_norm: - self._add_and_activate_layer(LayerNormalization()) - - self._add_and_activate_layer(SpatialDropout1D(rate=self.dropout_rate)) - self._add_and_activate_layer(Activation('relu')) - - - if not self.last_block: - # 1x1 conv to match the shapes (channel dimension). - name = f'conv1D_{k+1}' - with tf.keras.backend.name_scope(name): - # make and build this layer separately because it directly uses input_shape - self.shape_match_conv = Conv1D(filters=self.nb_filters, - kernel_size=1, - padding='same', - name=name, - kernel_regularizer = tf.keras.regularizers.l2(self.kernel_regularizer), - kernel_initializer=self.kernel_initializer) - - else: - self.shape_match_conv = Lambda(lambda x: x, name='identity') - - self.shape_match_conv.build(input_shape) - self.res_output_shape = self.shape_match_conv.compute_output_shape(input_shape) - - self.final_activation = Activation(self.activation) - self.final_activation.build(self.res_output_shape) # probably isn't necessary - - # this is done to force keras to add the layers in the list to self._layers - for layer in self.residual_layers: - self.__setattr__(layer.name, layer) - - super(ResidualBlock, self).build(input_shape) # done to make sure self.built is set True - - def call(self, inputs, training=None): - """ - Returns: A tuple where the first element is the residual model tensor, and the second - is the skip connection tensor. - """ - x = inputs - for layer in self.residual_layers: - if isinstance(layer, SpatialDropout1D): - x = layer(x, training=training) - else: - x = layer(x) - - x2 = self.shape_match_conv(inputs) - res_x = tf.keras.layers.add([x2, x]) - return [self.final_activation(res_x), x] - - def compute_output_shape(self, input_shape): - return [self.res_output_shape, self.res_output_shape] - - - -class Conv2D(tf.keras.layers.Layer): - """ Multiple repetitions of 2d convolution, batch normalization and dropout layers. """ - - def __init__(self, filters, kernel_size=3, - strides=1, dilation=1, padding='VALID', - add_dropout=True, - dropout_rate=0.2, activation='relu', batch_normalization=False, use_bias=True, num_repetitions=1): - super().__init__() - - repetitions = [] - - for _ in range(num_repetitions): - layer = [ - tf.keras.layers.Conv2D( - filters=filters, - kernel_size=kernel_size, - strides=strides, - dilation_rate=dilation, - padding=padding, - use_bias=use_bias, - activation=activation, - ) - ] - - if batch_normalization: - layer.append(tf.keras.layers.BatchNormalization()) - - if add_dropout: - layer.append(tf.keras.layers.Dropout(rate=dropout_rate)) - - layer = tf.keras.Sequential(layer) - - repetitions.append(layer) - - self.combined_layer = tf.keras.Sequential(repetitions) - - def call(self, inputs, training=False): - return self.combined_layer(inputs, training=training) - - -class ResConv2D(tf.keras.layers.Layer): - """ - Layer of N residual convolutional blocks stacked in parallel - - This layer stacks in parallel a sequence of 2 2D convolutional layers and returns the addition of their output - feature tensors with the input tensor. N number of convolutional blocks can be added together with different kernel - size and dilation rate, which are specified as a list. If the inputs are not a list, the same parameters are used - for all convolutional blocks. - - """ - - def __init__(self, filters, kernel_size=3, strides=1, dilation=1, padding='VALID', add_dropout=True, - dropout_rate=0.2, activation='relu', use_bias=True, batch_normalization=False, num_parallel=1): - super().__init__() - - if isinstance(kernel_size, list) and len(kernel_size) != num_parallel: - raise ValueError('Number of specified kernel sizes needs to match num_parallel') - - if isinstance(dilation, list) and len(dilation) != num_parallel: - raise ValueError('Number of specified dilation rate sizes needs to match num_parallel') - - kernel_list = kernel_size if isinstance(kernel_size, list) else [kernel_size]*num_parallel - dilation_list = dilation if isinstance(dilation, list) else [dilation]*num_parallel - - self.convs = [Conv2D(filters, - kernel_size=k, - strides=strides, - dilation=d, - padding=padding, - activation=activation, - add_dropout=add_dropout, - dropout_rate=dropout_rate, - use_bias=use_bias, - batch_normalization=batch_normalization, - num_repetitions=2) for k, d in zip(kernel_list, dilation_list)] - - self.add = tf.keras.layers.Add() - - def call(self, inputs, training=False): - outputs = [conv_layer(inputs, training=training) for conv_layer in self.convs] - - return self.add(outputs + [inputs]) - - -class Conv3D(tf.keras.layers.Layer): - """ Multiple repetitions of 3d convolution, batch normalization and dropout layers. """ - - def __init__(self, filters, kernel_size=3, strides=1, padding='VALID', add_dropout=True, dropout_rate=0.2, - batch_normalization=False, use_bias=True, num_repetitions=1, convolve_time=True): - super().__init__() - - repetitions = [] - - t_size = kernel_size if convolve_time else 1 - kernel_shape = (t_size, kernel_size, kernel_size) - - for _ in range(num_repetitions): - layer = [ - tf.keras.layers.Conv3D( - filters=filters, - kernel_size=kernel_shape, - strides=strides, - padding=padding, - use_bias=use_bias, - activation='relu', - ) - ] - - if batch_normalization: - layer.append(tf.keras.layers.BatchNormalization()) - - if add_dropout: - layer.append(tf.keras.layers.Dropout(rate=dropout_rate)) - - layer = tf.keras.Sequential(layer) - - repetitions.append(layer) - - self.combined_layer = tf.keras.Sequential(repetitions) - - def call(self, inputs, training=False): - return self.combined_layer(inputs, training=training) - - -class Deconv2D(tf.keras.layers.Layer): - """ 2d transpose convolution with optional batch normalization. """ - - def __init__(self, filters, kernel_size=2, batch_normalization=False): - super().__init__() - - layer = [tf.keras.layers.Conv2DTranspose( - filters=filters, - kernel_size=kernel_size, - strides=kernel_size, - padding='SAME', - activation='relu' - )] - - if batch_normalization: - layer.append(tf.keras.layers.BatchNormalization()) - - self.layer = tf.keras.Sequential(layer) - - def call(self, inputs, training=None): - return self.layer(inputs, training=training) - - -class CropAndConcat(tf.keras.layers.Layer): - """ Layer that crops the first tensor and concatenates it with the second. Used for skip connections. """ - @staticmethod - def call(x1, x2): - # Crop x1 to shape of x2 - x2_shape = tf.shape(x2) - x1_crop = tf.image.resize_with_crop_or_pad(x1, x2_shape[1], x2_shape[2]) - - # Concatenate along last dimension and return - return tf.concat([x1_crop, x2], axis=-1) - - -class MaxPool3D(tf.keras.layers.Layer): - def __init__(self, kernel_size=2, strides=2, pool_time=False): - super().__init__() - - tsize = kernel_size if pool_time else 1 - tstride = strides if pool_time else 1 - - kernel_shape = (tsize, kernel_size, kernel_size) - strides = (tstride, strides, strides) - - self.layer = tf.keras.layers.MaxPool3D( - pool_size=kernel_shape, - strides=strides, - padding='SAME' - ) - - def call(self, inputs, training=None): - return self.layer(inputs, training=training) - - -class Reduce3DTo2D(tf.keras.layers.Layer): - """ Reduces 3d representations into 2d using 3d convolution over the whole time dimension. """ - - def __init__(self, filters, kernel_size=3, stride=1, add_dropout=False, dropout_rate=0.2): - super().__init__() - - self.filters = filters - self.kernel_size = kernel_size - self.stride = stride - self.add_dropout = add_dropout - self.dropout_rate = dropout_rate - self.layer = None - - def build(self, input_size): - t_size = input_size[1] - layer = [tf.keras.layers.Conv3D( - self.filters, - kernel_size=(t_size, self.kernel_size, self.kernel_size), - strides=(1, self.stride, self.stride), - padding='VALID', - activation='relu' - )] - - if self.add_dropout: - layer.append(tf.keras.layers.Dropout(rate=self.dropout_rate)) - - self.layer = tf.keras.Sequential(layer) - - def call(self, inputs, training=None): - r = self.layer(inputs, training=training) - - # Squeeze along temporal dimension - return tf.squeeze(r, axis=[1]) - - -class PyramidPoolingModule(tf.keras.layers.Layer): - """ - Implementation of the Pyramid Pooling Module - - Implementation taken from the following paper - - Zhao et al. - Pyramid Scene Parsing Network - https://arxiv.org/pdf/1612.01105.pdf - - PyTorch implementation https://github.com/hszhao/semseg/blob/master/model/pspnet.py - """ - def __init__(self, filters, bins=(1, 2, 4, 8), interpolation='bilinear', batch_normalization=False): - super().__init__() - - self.filters = filters - self.bins = bins - self.batch_normalization = batch_normalization - self.interpolation = interpolation - self.layers = None - - def build(self, input_size): - _, height, width, n_features = input_size - - layers = [] - - for bin_size in self.bins: - - size_factors = height // bin_size, width // bin_size - - layer = tf.keras.Sequential() - layer.add(AveragePooling2D(pool_size=size_factors, - padding='same')) - layer.add(tf.keras.layers.Conv2D(filters=self.filters//len(self.bins), - kernel_size=1, - padding='same', - use_bias=False)) - if self.batch_normalization: - layer.add(BatchNormalization()) - layer.add(Activation('relu')) - - layer.add(UpSampling2D(size=size_factors, interpolation=self.interpolation)) - - layers.append(layer) - - self.layers = layers - - def call(self, inputs, training=None): - """ Concatenate the output of the pooling layers, resampled to original size """ - _, height, width, _ = inputs.shape - - outputs = [inputs] - - outputs += [layer(inputs, training=training) for layer in self.layers] - - return tf.concat(outputs, axis=-1) diff --git a/eo-flow/eoflow/models/losses.py b/eo-flow/eoflow/models/losses.py deleted file mode 100644 index 63aa8f7..0000000 --- a/eo-flow/eoflow/models/losses.py +++ /dev/null @@ -1,234 +0,0 @@ -import tensorflow as tf -from tensorflow.keras.losses import Loss, Reduction - - -def cropped_loss(loss_fn): - """ Wraps loss function. Crops the labels to match the logits size. """ - - def _loss_fn(labels, logits): - logits_shape = tf.shape(logits) - labels_crop = tf.image.resize_with_crop_or_pad(labels, logits_shape[1], logits_shape[2]) - - return loss_fn(labels_crop, logits) - - return _loss_fn - - -class CategoricalCrossEntropy(Loss): - """ Wrapper class for cross-entropy with class weights """ - def __init__(self, from_logits=True, class_weights=None, reduction=Reduction.AUTO, name='FocalLoss'): - """Categorical cross-entropy. - - :param from_logits: Whether predictions are logits or softmax, defaults to True - :type from_logits: bool - :param class_weights: Array of class weights to be applied to loss. Needs to be of `n_classes` length - :type class_weights: np.array - :param reduction: reduction to be used, defaults to Reduction.AUTO - :type reduction: tf.keras.losses.Reduction, optional - :param name: name of the loss, defaults to 'FocalLoss' - :type name: str - """ - super().__init__(reduction=reduction, name=name) - - self.from_logits = from_logits - self.class_weights = class_weights - - def call(self, y_true, y_pred): - # Perform softmax - if self.from_logits: - y_pred = tf.nn.softmax(y_pred) - - # Clip the prediction value to prevent NaN's and Inf's - epsilon = tf.keras.backend.epsilon() - y_pred = tf.clip_by_value(y_pred, epsilon, 1.) - - # Calculate Cross Entropy - loss = -y_true * tf.math.log(y_pred) - - # Multiply cross-entropy with class-wise weights - if self.class_weights is not None: - loss = tf.multiply(loss, self.class_weights) - - # Sum over classes - loss = tf.reduce_sum(loss, axis=-1) - - return loss - - -class CategoricalFocalLoss(Loss): - """ Categorical version of focal loss. - - References: - Official paper: https://arxiv.org/pdf/1708.02002.pdf - Keras implementation: https://github.com/umbertogriffo/focal-loss-keras - """ - - def __init__(self, gamma=2., alpha=.25, from_logits=True, class_weights=None, - reduction=Reduction.AUTO, - name='FocalLoss'): - """Categorical version of focal loss. - - :param gamma: gamma value, defaults to 2. - :type gamma: float - :param alpha: alpha value, defaults to .25 - :type alpha: float - :param from_logits: Whether predictions are logits or softmax, defaults to True - :type from_logits: bool - :param class_weights: Array of class weights to be applied to loss. Needs to be of `n_classes` length - :type class_weights: np.array - :param reduction: reduction to be used, defaults to Reduction.AUTO - :type reduction: tf.keras.losses.Reduction, optional - :param name: name of the loss, defaults to 'FocalLoss' - :type name: str - """ - super().__init__(reduction=reduction, name=name) - - self.gamma = gamma - self.alpha = alpha - self.from_logits = from_logits - self.class_weights = class_weights - - def call(self, y_true, y_pred): - - # Perform softmax - if self.from_logits: - y_pred = tf.nn.softmax(y_pred) - - # Clip the prediction value to prevent NaN's and Inf's - epsilon = tf.keras.backend.epsilon() - y_pred = tf.clip_by_value(y_pred, epsilon, 1.) - - # Calculate Cross Entropy - cross_entropy = -y_true * tf.math.log(y_pred) - - # Calculate Focal Loss - loss = self.alpha * tf.math.pow(1 - y_pred, self.gamma) * cross_entropy - - # Multiply focal loss with class-wise weights - if self.class_weights is not None: - loss = tf.multiply(cross_entropy, self.class_weights) - - # Sum over classes - loss = tf.reduce_sum(loss, axis=-1) - - return loss - - -class JaccardDistanceLoss(Loss): - """ Implementation of the Jaccard distance, or Intersection over Union IoU loss. - - Jaccard = (|X & Y|)/ (|X|+ |Y| - |X & Y|) - = sum(|A*B|)/(sum(|A|)+sum(|B|)-sum(|A*B|)) - - Implementation taken from https://github.com/keras-team/keras-contrib/blob/master/keras_contrib/losses/jaccard.py - """ - def __init__(self, smooth=1, from_logits=True, class_weights=None, reduction=Reduction.AUTO, name='JaccardLoss'): - """ Jaccard distance loss. - - :param smooth: Smoothing factor. Default is 1. - :type smooth: int - :param from_logits: Whether predictions are logits or softmax, defaults to True - :type from_logits: bool - :param class_weights: Array of class weights to be applied to loss. Needs to be of `n_classes` length - :type class_weights: np.array - :param reduction: reduction to be used, defaults to Reduction.AUTO - :type reduction: tf.keras.losses.Reduction, optional - :param name: name of the loss, defaults to 'JaccardLoss' - :type name: str - """ - super().__init__(reduction=reduction, name=name) - - self.smooth = smooth - self.from_logits = from_logits - - self.class_weights = class_weights - - def call(self, y_true, y_pred): - - # Perform softmax - if self.from_logits: - y_pred = tf.nn.softmax(y_pred) - - intersection = tf.reduce_sum(y_true * y_pred, axis=(1, 2)) - - sum_ = tf.reduce_sum(y_true + y_pred, axis=(1, 2)) - - jac = (intersection + self.smooth) / (sum_ - intersection + self.smooth) - - loss = (1 - jac) * self.smooth - - if self.class_weights is not None: - loss = tf.multiply(loss, self.class_weights) - - loss = tf.reduce_sum(loss, axis=-1) - - return loss - - -class TanimotoDistanceLoss(Loss): - """ Implementation of the Tanimoto distance, which is modified version of the Jaccard distance. - - Tanimoto = (|X & Y|)/ (|X|^2+ |Y|^2 - |X & Y|) - = sum(|A*B|)/(sum(|A|^2)+sum(|B|^2)-sum(|A*B|)) - - Implementation taken from - https://github.com/feevos/resuneta/blob/145be5519ee4bec9a8cce9e887808b8df011f520/nn/loss/loss.py#L7 - """ - def __init__(self, smooth=1.0e-5, from_logits=True, class_weights=None, - reduction=Reduction.AUTO, normalise=False, name='TanimotoLoss'): - """ Tanimoto distance loss. - - :param smooth: Smoothing factor. Default is 1.0e-5. - :type smooth: float - :param from_logits: Whether predictions are logits or softmax, defaults to True - :type from_logits: bool - :param class_weights: Array of class weights to be applied to loss. Needs to be of `n_classes` length - :type class_weights: np.array - :param reduction: Reduction to be used, defaults to Reduction.AUTO - :type reduction: tf.keras.losses.Reduction, optional - :param normalise: Whether to normalise loss by number of positive samples in class, defaults to `False` - :type normalise: bool - :param name: Name of the loss, defaults to 'TanimotoLoss' - :type name: str - """ - super().__init__(reduction=reduction, name=name) - - self.smooth = smooth - self.from_logits = from_logits - self.normalise = normalise - - self.class_weights = class_weights - - def call(self, y_true, y_pred): - - # Perform softmax - if self.from_logits: - y_pred = tf.nn.softmax(y_pred) - - n_classes = y_true.shape[-1] - - volume = tf.reduce_mean(tf.reduce_sum(y_true, axis=(1, 2)), axis=0) \ - if self.normalise else tf.ones(n_classes, dtype=tf.float32) - - weights = tf.math.reciprocal(tf.math.square(volume)) - new_weights = tf.where(tf.math.is_inf(weights), tf.zeros_like(weights), weights) - weights = tf.where(tf.math.is_inf(weights), tf.ones_like(weights) * tf.reduce_max(new_weights), weights) - - intersection = tf.reduce_sum(y_true * y_pred, axis=(1, 2)) - - sum_ = tf.reduce_sum(y_true * y_true + y_pred * y_pred, axis=(1, 2)) - - num_ = tf.multiply(intersection, weights) + self.smooth - - den_ = tf.multiply(sum_ - intersection, weights) + self.smooth - - tanimoto = num_ / den_ - - loss = (1 - tanimoto) - - if self.class_weights is not None: - loss = tf.multiply(loss, self.class_weights) - - loss = tf.reduce_sum(loss, axis=-1) - - return loss diff --git a/eo-flow/eoflow/models/metrics.py b/eo-flow/eoflow/models/metrics.py deleted file mode 100644 index a2af3a9..0000000 --- a/eo-flow/eoflow/models/metrics.py +++ /dev/null @@ -1,335 +0,0 @@ -import warnings - -from typing import Any, Callable, List - -from skimage import measure -from scipy import ndimage - -import tensorflow as tf -import tensorflow_addons as tfa -import numpy as np - - -class InitializableMetric(tf.keras.metrics.Metric): - """ Metric that has to be initialized from model configuration. """ - - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.initialized = False - - def init_from_config(self, model_config=None): - """ Initializes the metric from configuration. """ - - self.initialized = True - - def assert_initialized(self): - """ Checks if the metric is initialized. """ - - if not self.initialized: - raise ValueError("InitializableMetric was not initialized before use.") - - -class MeanIoU(InitializableMetric): - """ Computes mean intersection over union metric for semantic segmentation. - Wraps keras MeanIoU to work on logits. """ - - def __init__(self, default_max_classes=32, name='mean_iou'): - """ Creates MeanIoU metric - - :param default_max_classes: Default value for max number of classes. Required by Keras MeanIoU. - Must be greater or equal to the actual number of classes. - Will not be used if n_classes is in model configuration. Defaults to 32. - :type default_max_classes: int - :param name: Name of the metric - :type name: str - """ - - super().__init__(name=name, dtype=tf.float32) - self.default_max_classes = default_max_classes - self.metric = None - - def init_from_config(self, model_config=None): - super().init_from_config(model_config) - - if model_config is not None and 'n_classes' in model_config: - self.metric = tf.keras.metrics.MeanIoU(num_classes=model_config['n_classes']) - else: - print("n_classes not found in model config or model config not provided. Using default max value.") - self.metric = tf.keras.metrics.MeanIoU(num_classes=self.default_max_classes) - - def update_state(self, y_true, y_pred, sample_weight=None): - self.assert_initialized() - - y_pred_c = tf.argmax(y_pred, axis=-1) - y_true_c = tf.argmax(y_true, axis=-1) - - return self.metric.update_state(y_true_c, y_pred_c, sample_weight) - - def result(self): - self.assert_initialized() - - return self.metric.result() - - def reset_states(self): - self.assert_initialized() - - return self.metric.reset_states() - - def get_config(self): - self.assert_initialized() - - return self.metric.get_config() - - -class CroppedMetric(tf.keras.metrics.Metric): - """ Wraps a metric. Crops the labels to match the logits size. """ - - def __init__(self, metric): - super().__init__(name=metric.name, dtype=metric.dtype) - self.metric = metric - - def update_state(self, y_true, y_pred, sample_weight=None): - logits_shape = tf.shape(y_pred) - labels_crop = tf.image.resize_with_crop_or_pad(y_true, logits_shape[1], logits_shape[2]) - - return self.metric.update_state(labels_crop, y_pred, sample_weight) - - def result(self): - return self.metric.result() - - def reset_states(self): - return self.metric.reset_states() - - def get_config(self): - return self.metric.get_config() - - -class RSquared(InitializableMetric): - def __init__(self,name = 'r_square'): - super().__init__(name=name, dtype=tf.float32) - self.metric = None - - def init_from_config(self, model_config=None): - super().init_from_config(model_config) - self.metric = tfa.metrics.RSquare(dtype=tf.float32, y_shape=(1,)) - - def update_state(self, y_true, y_pred): - self.assert_initialized() - - return self.metric.update_state(y_true, y_pred) - - def result(self): - self.assert_initialized() - - return self.metric.result() - - def reset_states(self): - self.assert_initialized() - - return self.metric.reset_states() - - def get_config(self): - self.assert_initialized() - - return self.metric.get_config() - - -class MCCMetric(InitializableMetric): - """ Computes Mathew Correlation Coefficient metric. Wraps metrics.MatthewsCorrelationCoefficient from - tensorflow-addons, and reshapes the input (logits) into (m, n_classes) tensors. The logits are thresholded to get - "one-hot encoded" values for (multi)class metrics """ - - def __init__(self, default_n_classes=2, default_threshold=0.5, name='mcc'): - """ Creates MCCMetric metric - - :param default_n_classes: Default number of classes - :type default_n_classes: int - :param default_threshold: Default value for threshold - :type default_threshold: float - :param name: Name of the metric - :type name: str - """ - - super().__init__(name=name, dtype=tf.float32) - self.metric = None - self.default_n_classes = default_n_classes - self.threshold = default_threshold - - def init_from_config(self, model_config=None): - super().init_from_config(model_config) - - if model_config is not None and 'n_classes' in model_config: - self.metric = tfa.metrics.MatthewsCorrelationCoefficient(num_classes=model_config['n_classes']) - else: - print("n_classes not found in model config or model config not provided. Using default max value.") - self.metric = tfa.metrics.MatthewsCorrelationCoefficient(num_classes=self.default_n_classes) - - if model_config is not None and 'mcc_threshold' in model_config: - self.threshold = model_config['mcc_threshold'] - else: - print(f"Using default value for threshold: {self.threshold}.") - - self.metric = tfa.metrics.MatthewsCorrelationCoefficient(num_classes=model_config['n_classes']) - - def update_state(self, y_true, y_pred, sample_weight=None): - self.assert_initialized() - - n = tf.math.reduce_prod(tf.shape(y_pred)[:-1]) - y_pred_c = tf.reshape(y_pred > self.threshold, (n, self.metric.num_classes)) - y_true_c = tf.reshape(y_true, (n, self.metric.num_classes)) - - return self.metric.update_state(y_true_c, y_pred_c, sample_weight=sample_weight) - - def result(self): - self.assert_initialized() - - return self.metric.result() - - def reset_states(self): - self.assert_initialized() - - return self.metric.reset_states() - - def get_config(self): - self.assert_initialized() - - return self.metric.get_config() - - -class GeometricMetrics(InitializableMetric): - """" - Implementation of Geometric error metrics. Oversegmentation, Undersegmentation, Border, Fragmentation errors. - - The error metrics are based on a paper by C. Persello, A Novel Protocol for Accuracy Assessment in Classification of - Very High Resolution Images (https://ieeexplore.ieee.org/document/5282610) - """ - - @staticmethod - def _detect_edges(im: np.ndarray, thr: float = 0) -> np.ndarray: - """ Edge detection function using the sobel operator. """ - sx = ndimage.sobel(im, axis=0, mode='constant') - sy = ndimage.sobel(im, axis=1, mode='constant') - sob = np.hypot(sx, sy) - return sob > thr - - @staticmethod - def _segmentation_error(intersection_area: float, object_area: float) -> float: - return 1. - intersection_area / object_area - - @staticmethod - def _intersection(mask1: np.ndarray, mask2: np.ndarray) -> float: - return np.sum(np.logical_and(mask1, mask2)) - - def _border_err(self, border_ref_edge: np.ndarray, border_meas_edge: np.ndarray) -> float: - ref_edge_size = np.sum(border_ref_edge) - intersection = self._intersection(border_ref_edge, border_meas_edge) - err = intersection / ref_edge_size if ref_edge_size != 0 else 0 - return 1. - err - - def _fragmentation_err(self, r: int, reference_mask: np.ndarray) -> float: - if r <= 1: - return 0 - den = np.sum(reference_mask) - self.pixel_size - return (r - 1.) / den if den > 0 else 0 - - @staticmethod - def _validate_input(reference, measurement): - if np.ndim(reference) != np.ndim(measurement): - raise ValueError("Reference and measurement input shapes must match.") - - def __init__(self, pixel_size: int = 1, edge_func: Callable = None, **edge_func_params: Any): - - super().__init__(name='geometric_metrics', dtype=tf.float64) - - self.oversegmentation_error = [] - self.undersegmentation_error = [] - self.border_error = [] - self.fragmentation_error = [] - - self.edge_func = self._detect_edges if edge_func is None else edge_func - self.edge_func_params = edge_func_params - self.pixel_size = pixel_size - - def update_state(self, reference: np.ndarray, measurement: np.ndarray, encode_reference: bool = True, - background_value: int = 0) -> None: - """ Calculate the error metrics for a measurement and reference arrays. For each . - - If encode_reference is set to True, connected components will be used to label objects in the reference and - measurements. - """ - - if not tf.executing_eagerly(): - warnings.warn("Geometric metrics must be run with eager execution. If running as a compiled Keras model, " - "enable eager execution with model.run_eagerly = True") - - reference = reference.numpy() if isinstance(reference, tf.Tensor) else reference - measurement = measurement.numpy() if isinstance(reference, tf.Tensor) else measurement - - self._validate_input(reference, measurement) - - for ref, meas in zip(reference, measurement): - ref = ref - meas = meas - - if encode_reference: - cc_reference = measure.label(ref, background=background_value) - else: - cc_reference = ref - - cc_measurement = measure.label(meas, background=background_value) - components_reference = set(np.unique(cc_reference)).difference([background_value]) - - ref_edges = self.edge_func(cc_reference) - meas_edges = self.edge_func(cc_measurement) - for component in components_reference: - reference_mask = cc_reference == component - - uniq, count = np.unique(cc_measurement[reference_mask & (cc_measurement != background_value)], - return_counts=True) - ref_area = np.sum(reference_mask) - - max_interecting_measurement = uniq[count.argmax()] if len(count) > 0 else background_value - meas_mask = cc_measurement == max_interecting_measurement - meas_area = np.count_nonzero(cc_measurement == max_interecting_measurement) - intersection_area = count.max() if len(count) > 0 else 0 - - self.oversegmentation_error.append(self._segmentation_error(intersection_area, ref_area)) - self.undersegmentation_error.append(self._segmentation_error(intersection_area, meas_area)) - border_ref_edge = ref_edges.squeeze() & reference_mask.squeeze() - border_meas_edge = meas_edges.squeeze() & meas_mask.squeeze() - - self.border_error.append(self._border_err(border_ref_edge, border_meas_edge)) - self.fragmentation_error.append(self._fragmentation_err(len(uniq), reference_mask)) - - def get_oversegmentation_error(self) -> float: - """ Return oversegmentation error. """ - return np.array(self.oversegmentation_error).mean() - - def get_undersegmentation_error(self) -> float: - """ Return undersegmentation error. """ - - return np.array(self.undersegmentation_error).mean() - - def get_border_error(self) -> float: - """ Return border error. """ - - return np.array(self.border_error).mean() - - def get_fragmentation_error(self) -> float: - """ Return fragmentation error. """ - - return np.array(self.fragmentation_error).mean() - - def result(self) -> List[float]: - """ Return a list of values representing oversegmentation, undersegmentation, border, fragmentation errors. """ - - return [self.get_oversegmentation_error(), - self.get_undersegmentation_error(), - self.get_border_error(), self.get_fragmentation_error()] - - def reset_states(self) -> None: - """ Empty all the error arrays. """ - self.oversegmentation_error = [] - self.undersegmentation_error = [] - self.border_error = [] - self.fragmentation_error = [] diff --git a/eo-flow/eoflow/models/pse_tae_layers.py b/eo-flow/eoflow/models/pse_tae_layers.py deleted file mode 100644 index 794d8cc..0000000 --- a/eo-flow/eoflow/models/pse_tae_layers.py +++ /dev/null @@ -1,176 +0,0 @@ -import numpy as np -import tensorflow as tf -import tensorflow.keras.layers as L - -from .transformer_encoder_layers import scaled_dot_product_attention, positional_encoding - -pooling_methods = { - 'mean': tf.math.reduce_mean, - 'std': tf.math.reduce_std, - 'max': tf.math.reduce_max, - 'min': tf.math.reduce_min -} - -class PixelSetEncoder(tf.keras.layers.Layer): - def __init__(self, mlp1=[10, 32, 64], mlp2=[64, 128], pooling='mean_std'): - super().__init__() - - self.mlp1 = tf.keras.Sequential([LinearLayer(out_dim) for out_dim in mlp1]) - - pooling_methods = [SetPooling(method) for method in pooling.split('_')] - self.pooling = SummaryConcatenate(pooling_methods, axis=-1) - - mlp2_layers = [LinearLayer(out_dim) for out_dim in mlp2[:-1]] - mlp2_layers.append(LinearLayer(mlp2[-1], activation=False)) - self.mlp2 = tf.keras.Sequential(mlp2_layers) - - self.encoder = tf.keras.Sequential([ - self.mlp1, - self.pooling, - self.mlp2 - ]) - - def call(self, x, training=None, mask=None): - return self.encoder(x, training=training, mask=mask) - - -class MultiHeadAttention(tf.keras.layers.Layer): - def __init__(self, n_head, d_k, name='multi_head_attention'): - super().__init__(name=name) - - self.n_head = n_head - self.d_k = d_k - - self.fc1_q = L.Dense(d_k * n_head, - kernel_initializer=tf.random_normal_initializer(mean=0, stddev=np.sqrt(2.0 / d_k))) - - self.fc1_k = L.Dense(d_k * n_head, - kernel_initializer=tf.random_normal_initializer(mean=0, stddev=np.sqrt(2.0 / d_k))) - - self.fc2 = tf.keras.Sequential([ - L.BatchNormalization(), - L.Dense(d_k) - ]) - - def split_heads(self, x, batch_size): - """Split the last dimension into (n_head, d_k). - Transpose the result such that the shape is (batch_size, n_head, seq_len, d_k) - """ - - x = tf.reshape(x, (batch_size, -1, self.n_head, self.d_k)) - return tf.transpose(x, perm=[0, 2, 1, 3]) - - def call(self, q, k, v, training=None, mask=None): - batch_size = tf.shape(q)[0] - - q = self.fc1_q(q) - q = self.split_heads(q, batch_size) - q = tf.reduce_mean(q, axis=2, keepdims=True) # MEAN query - - k = self.fc1_k(k) - k = self.split_heads(k, batch_size) - - # Repeat n_head times - v = tf.expand_dims(v, axis=1) - v = tf.tile(v, (1, self.n_head, 1, 1)) - - output, attn = scaled_dot_product_attention(q, k, v, mask) - - output = tf.squeeze(output, axis=2) - - # Concat heads - output = tf.reshape(output, (batch_size, -1)) - - return output - -class TemporalAttentionEncoder(tf.keras.layers.Layer): - def __init__(self, n_head=4, d_k=32, d_model=None, n_neurons=[512, 128, 128], dropout=0.2, - T=1000, len_max_seq=24, positions=None): - super().__init__() - - - self.positions = positions - if self.positions is None: - self.positions = len_max_seq + 1 - - self.d_model = d_model - self.T = T - - self.in_layer_norm = tf.keras.layers.LayerNormalization(name='in_layer_norm') - - self.inconv = None - if d_model is not None: - self.inconv = tf.keras.Sequential([ - L.Conv1D(d_model, 1, name='inconv'), - L.LayerNormalization(name='conv_layer_norm') - ]) - - self.out_layer_norm = tf.keras.layers.LayerNormalization(name='out_layer_norm') - - self.attention_heads = MultiHeadAttention(n_head, d_k, name='attention_heads') - - mlp_layers = [LinearLayer(out_dim) for out_dim in n_neurons] - self.mlp = tf.keras.Sequential(mlp_layers, name='mlp') - - self.dropout = L.Dropout(dropout) - - def build(self, input_shape): - d_in = input_shape[-1] if self.d_model is None else self.d_model - self.position_enc = positional_encoding(self.positions, d_in, T=self.T) - - def call(self, x, training=None, mask=None): - seq_len = tf.shape(x)[1] - - x = self.in_layer_norm(x, training=training) - - if self.inconv is not None: - x = self.inconv(x, training=training) - - pos_encoding = self.position_enc[:, :seq_len, :] - if self.positions is None: - pos_encoding = self.position_enc[:, 1:seq_len+1, :] - - enc_output = x + pos_encoding - - enc_output = self.attention_heads(enc_output, enc_output, enc_output, training=training, mask=mask) - - enc_output = self.mlp(enc_output, training=training) - enc_output = self.dropout(enc_output, training=training) - enc_output = self.out_layer_norm(enc_output, training=training) - - return enc_output - -def LinearLayer(out_dim, batch_norm=True, activation=True): - """ Linear layer. """ - - layers = [L.Dense(out_dim)] - - if batch_norm: - layers.append(L.BatchNormalization()) - - if activation: - layers.append(L.ReLU()) - - return tf.keras.Sequential(layers) - -class SetPooling(tf.keras.layers.Layer): - """ Pooling over the Set dimension using a specified pooling method. """ - def __init__(self, pooling_method): - super().__init__() - - self.pooling_method = pooling_methods[pooling_method] - - def call(self, x, training=None, mask=None): - return self.pooling_method(x, axis=1) - -class SummaryConcatenate(tf.keras.layers.Layer): - """ Runs multiple summary layers on a single input and concatenates them. """ - def __init__(self, layers, axis=-1): - super().__init__() - - self.layers = layers - self.axis = axis - - def call(self, x, training=None, mask=None): - layer_outputs = [layer(x, training=training, mask=mask) for layer in self.layers] - return L.concatenate(layer_outputs, axis=self.axis) diff --git a/eo-flow/eoflow/models/segmentation_task/__init__.py b/eo-flow/eoflow/models/segmentation_task/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/eo-flow/eoflow/models/segmentation_task/segmentation_base.py b/eo-flow/eoflow/models/segmentation_task/segmentation_base.py deleted file mode 100644 index 8e4a825..0000000 --- a/eo-flow/eoflow/models/segmentation_task/segmentation_base.py +++ /dev/null @@ -1,164 +0,0 @@ -import os -import logging - -import numpy as np -import tensorflow as tf -from marshmallow import Schema, fields -from marshmallow.validate import OneOf, ContainsOnly - -from eoflow.base import BaseModelTraining - -from eoflow.models.losses import CategoricalCrossEntropy, CategoricalFocalLoss, JaccardDistanceLoss, TanimotoDistanceLoss -from eoflow.models.losses import cropped_loss -from eoflow.models.metrics import MeanIoU, InitializableMetric, CroppedMetric, MCCMetric -from eoflow.models.callbacks import VisualizationCallback - -logging.basicConfig(level=logging.INFO, - format='%(asctime)s %(levelname)s %(message)s') - - -# Available losses. Add keys with new losses here. -segmentation_losses = { - 'cross_entropy': CategoricalCrossEntropy, - 'focal_loss': CategoricalFocalLoss, - 'jaccard_loss': JaccardDistanceLoss, - 'tanimoto_loss': TanimotoDistanceLoss -} - - -# Available metrics. Add keys with new metrics here. -segmentation_metrics = { - 'accuracy': lambda: tf.keras.metrics.CategoricalAccuracy(name='accuracy'), - 'iou': lambda: MeanIoU(default_max_classes=32), - 'precision': tf.keras.metrics.Precision, - 'recall': tf.keras.metrics.Recall, - 'mcc': MCCMetric -} - - -class BaseSegmentationModel(BaseModelTraining): - """ Base for segmentation models. """ - - class _Schema(Schema): - n_classes = fields.Int(required=True, description='Number of classes', example=2) - learning_rate = fields.Float(missing=None, description='Learning rate used in training.', example=0.01) - loss = fields.String(missing='cross_entropy', description='Loss function used for training.', - validate=OneOf(segmentation_losses.keys())) - metrics = fields.List(fields.String, missing=['accuracy', 'iou'], - description='List of metrics used for evaluation.', - validate=ContainsOnly(segmentation_metrics.keys())) - - class_weights = fields.Dict(missing=None, description='Dictionary mapping class id with weight. ' - 'If key for some labels is not specified, 1 is used.') - - prediction_visualization = fields.Bool(missing=False, description='Record prediction visualization summaries.') - prediction_visualization_num = fields.Int(missing=5, - description='Number of images used for prediction visualization.') - - def _prepare_class_weights(self): - """ Utility function to parse class weights """ - if self.config.class_weights is None: - return np.ones(self.config.n_classes) - return np.array([self.config.class_weights[iclass] if iclass in self.config.class_weights else 1.0 - for iclass in range(self.config.n_classes)]) - - def prepare(self, optimizer=None, loss=None, metrics=None, **kwargs): - """ Prepares the model. Optimizer, loss and metrics are read using the following protocol: - * If an argument is None, the default value is used from the configuration of the model. - * If an argument is a key contained in segmentation specific losses/metrics, those are used. - * Otherwise the argument is passed to `compile` as is. - - """ - # Read defaults if None - if optimizer is None: - optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate) - - if loss is None: - loss = self.config.loss - - if metrics is None: - metrics = self.config.metric - - class_weights = self._prepare_class_weights() - - # Wrap loss function - # TODO: pass kwargs to loss from config - if loss in segmentation_losses: - loss = segmentation_losses[loss](from_logits=False, class_weights=class_weights) - wrapped_loss = cropped_loss(loss) - - # Wrap metrics - wrapped_metrics = [] - for metric in metrics: - - if metric in segmentation_metrics: - if metric in ['precision', 'recall']: - wrapped_metrics += [CroppedMetric(segmentation_metrics[metric](top_k=1, - class_id=class_id, - name=f'{metric}_{class_id}')) - for class_id in range(self.config.n_classes)] - continue - else: - metric = segmentation_metrics[metric]() - - # Initialize initializable metrics - if isinstance(metric, InitializableMetric): - metric.init_from_config(self.config) - - wrapped_metric = CroppedMetric(metric) - wrapped_metrics.append(wrapped_metric) - - self.compile(optimizer=optimizer, loss=wrapped_loss, metrics=wrapped_metrics, **kwargs) - - def _get_visualization_callback(self, dataset, log_dir): - ds = dataset.unbatch().batch(self.config.prediction_visualization_num).take(1) - data = next(iter(ds)) - - visualization_callback = VisualizationCallback(data, log_dir) - return visualization_callback - - # Override default method to add prediction visualization - def train(self, dataset, - num_epochs, - model_directory, - iterations_per_epoch=None, - class_weights=None, - callbacks=[], - save_steps='epoch', - summary_steps=1, **kwargs): - - custom_callbacks = [] - - if self.config.prediction_visualization: - log_dir = os.path.join(model_directory, 'logs', 'predictions') - visualization_callback = self._get_visualization_callback(dataset, log_dir) - custom_callbacks.append(visualization_callback) - - super().train(dataset, num_epochs, model_directory, iterations_per_epoch, - callbacks=callbacks + custom_callbacks, save_steps=save_steps, - summary_steps=summary_steps, **kwargs) - - # Override default method to add prediction visualization - def train_and_evaluate(self, - train_dataset, - val_dataset, - num_epochs, - iterations_per_epoch, - model_directory, - class_weights=None, - save_steps=100, - summary_steps=10, - callbacks=[], **kwargs): - - custom_callbacks = [] - - if self.config.prediction_visualization: - log_dir = os.path.join(model_directory, 'logs', 'predictions') - visualization_callback = self._get_visualization_callback(val_dataset, log_dir) - custom_callbacks.append(visualization_callback) - - super().train_and_evaluate(train_dataset, val_dataset, - num_epochs, iterations_per_epoch, - model_directory, - save_steps=save_steps, summary_steps=summary_steps, - callbacks=callbacks + custom_callbacks, **kwargs) diff --git a/eo-flow/eoflow/models/segmentation_task/segmentation_unets.py b/eo-flow/eoflow/models/segmentation_task/segmentation_unets.py deleted file mode 100644 index e653e35..0000000 --- a/eo-flow/eoflow/models/segmentation_task/segmentation_unets.py +++ /dev/null @@ -1,651 +0,0 @@ -import logging -import tensorflow as tf -from marshmallow import fields - -from eoflow.models.layers import Conv2D, Deconv2D, CropAndConcat, Conv3D, MaxPool3D, Reduce3DTo2D, ResConv2D, PyramidPoolingModule -from .segmentation_base import BaseSegmentationModel - -logging.basicConfig(level=logging.INFO, - format='%(asctime)s %(levelname)s %(message)s') - - -class FCNModel(BaseSegmentationModel): - """ Implementation of a vanilla Fully-Convolutional-Network (aka U-net) """ - - class FCNModelSchema(BaseSegmentationModel._Schema): - n_layers = fields.Int(required=True, description='Number of layers of the FCN model', example=10) - keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) - features_root = fields.Int(required=True, description='Number of features at the root level.', example=32) - - conv_size = fields.Int(missing=3, description='Size of the convolution kernels.') - deconv_size = fields.Int(missing=2, description='Size of the deconvolution kernels.') - conv_stride = fields.Int(missing=1, description='Stride used in convolutions.') - dilation_rate = fields.List(fields.Int, missing=1, description='Dilation rate used in convolutions.') - add_dropout = fields.Bool(missing=False, description='Add dropout to layers.') - add_batch_norm = fields.Bool(missing=True, description='Add batch normalization to layers.') - bias_init = fields.Float(missing=0.0, description='Bias initialization value.') - use_bias = fields.Bool(missing=True, description='Add bias parameters to convolutional layer.') - padding = fields.String(missing='VALID', description='Padding type used in convolutions.') - - pool_size = fields.Int(missing=2, description='Kernel size used in max pooling.') - pool_stride = fields.Int(missing=2, description='Stride used in max pooling.') - - class_weights = fields.List(fields.Float, missing=None, description='Class weights used in training.') - - def build(self, inputs_shape): - """Builds the net for input x.""" - - x = tf.keras.layers.Input(inputs_shape[1:]) - dropout_rate = 1 - self.config.keep_prob - - # Encoding path - # the number of features of the convolutional kernels is proportional to the square of the level - # for instance, starting with 32 features at the first level (layer=0), there will be 64 features at layer=1 and - # 128 features at layer=2 - net = x - connection_outputs = [] - for layer in range(self.config.n_layers): - # compute number of features as a function of network depth level - features = 2 ** layer * self.config.features_root - - # bank of two convolutional filters - conv = Conv2D( - filters=features, - kernel_size=self.config.conv_size, - strides=self.config.conv_stride, - dilation=self.config.dilation_rate, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - use_bias=self.config.use_bias, - num_repetitions=2)(net) - - connection_outputs.append(conv) - - # max pooling operation - net = tf.keras.layers.MaxPool2D( - pool_size=self.config.pool_size, - strides=self.config.pool_stride, - padding='SAME')(conv) - - # bank of 2 convolutional filters at bottom of U-net. - bottom = Conv2D( - filters=2 ** self.config.n_layers * self.config.features_root, - kernel_size=self.config.conv_size, - strides=self.config.conv_stride, - dilation=self.config.dilation_rate, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - use_bias=self.config.use_bias, - num_repetitions=2, - padding=self.config.padding)(net) - - net = bottom - # Decoding path - # the decoding path mirrors the encoding path in terms of number of features per convolutional filter - for layer in range(self.config.n_layers): - # find corresponding level in decoding branch - conterpart_layer = self.config.n_layers - 1 - layer - # get same number of features as counterpart layer - features = 2 ** conterpart_layer * self.config.features_root - - deconv = Deconv2D( - filters=features, - kernel_size=self.config.deconv_size, - batch_normalization=self.config.add_batch_norm)(net) - - # # skip connections to concatenate features from encoding path - cc = CropAndConcat()(connection_outputs[conterpart_layer], - deconv) - - # bank of 2 convolutional filters - net = Conv2D( - filters=features, - kernel_size=self.config.conv_size, - strides=self.config.conv_stride, - dilation=self.config.dilation_rate, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - use_bias=self.config.use_bias, - num_repetitions=2, - padding=self.config.padding)(cc) - - # final 1x1 convolution corresponding to pixel-wise linear combination of feature channels - logits = tf.keras.layers.Conv2D( - filters=self.config.n_classes, - kernel_size=1)(net) - - logits = tf.keras.layers.Softmax()(logits) - - self.net = tf.keras.Model(inputs=x, outputs=logits) - - def call(self, inputs, training=None): - return self.net(inputs, training) - - -class TFCNModel(BaseSegmentationModel): - """ Implementation of a Temporal Fully-Convolutional-Network """ - - class TFCNModelSchema(BaseSegmentationModel._Schema): - n_layers = fields.Int(required=True, description='Number of layers of the FCN model', example=10) - keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) - features_root = fields.Int(required=True, description='Number of features at the root level.', example=32) - - conv_size = fields.Int(missing=3, description='Size of the convolution kernels.') - deconv_size = fields.Int(missing=2, description='Size of the deconvolution kernels.') - conv_size_reduce = fields.Int(missing=3, description='Size of the kernel for time reduction.') - conv_stride = fields.Int(missing=1, description='Stride used in convolutions.') - add_dropout = fields.Bool(missing=False, description='Add dropout to layers.') - add_batch_norm = fields.Bool(missing=True, description='Add batch normalization to layers.') - bias_init = fields.Float(missing=0.0, description='Bias initialization value.') - use_bias = fields.Bool(missing=True, description='Add bias parameters to convolutional layer.') - padding = fields.String(missing='VALID', description='Padding type used in convolutions.') - single_encoding_conv = fields.Bool(missing=False, description="Whether to apply 1 or 2 banks of conv filters.") - - pool_size = fields.Int(missing=2, description='Kernel size used in max pooling.') - pool_stride = fields.Int(missing=2, description='Stride used in max pooling.') - pool_time = fields.Bool(missing=False, description='Operate pooling over time dimension.') - - class_weights = fields.List(fields.Float, missing=None, description='Class weights used in training.') - - def build(self, inputs_shape): - - x = tf.keras.layers.Input(inputs_shape[1:]) - dropout_rate = 1 - self.config.keep_prob - - num_repetitions = 1 if self.config.single_encoding_conv else 2 - - # encoding path - net = x - connection_outputs = [] - for layer in range(self.config.n_layers): - # compute number of features as a function of network depth level - features = 2 ** layer * self.config.features_root - # bank of one 3d convolutional filter; convolution is done along the temporal as well as spatial directions - conv = Conv3D( - features, - kernel_size=self.config.conv_size, - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - num_repetitions=num_repetitions, - use_bias=self.config.use_bias, - padding=self.config.padding)(net) - - connection_outputs.append(conv) - # max pooling operation - net = MaxPool3D( - kernel_size=self.config.pool_size, - strides=self.config.pool_stride, - pool_time=self.config.pool_time)(conv) - - # Bank of 1 3d convolutional filter at bottom of FCN - bottom = Conv3D( - 2 ** self.config.n_layers * self.config.features_root, - kernel_size=self.config.conv_size, - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - num_repetitions=num_repetitions, - padding=self.config.padding, - use_bias=self.config.use_bias, - convolve_time=(not self.config.pool_time))(net) - - # Reduce temporal dimension - bottom = Reduce3DTo2D( - 2 ** self.config.n_layers * self.config.features_root, - kernel_size=self.config.conv_size_reduce, - stride=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate)(bottom) - - net = bottom - # decoding path - for layer in range(self.config.n_layers): - # find corresponding level in decoding branch - conterpart_layer = self.config.n_layers - 1 - layer - # get same number of features as counterpart layer - features = 2 ** conterpart_layer * self.config.features_root - - # transposed convolution to upsample tensors - deconv = Deconv2D( - filters=features, - kernel_size=self.config.deconv_size, - batch_normalization=self.config.add_batch_norm)(net) - - # skip connection with linear combination along time - reduced = Reduce3DTo2D( - features, - kernel_size=self.config.conv_size_reduce, - stride=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate)(connection_outputs[conterpart_layer]) - - # crop and concatenate - cc = CropAndConcat()(reduced, deconv) - - # bank of 2 convolutional layers as in standard FCN - net = Conv2D( - features, - kernel_size=self.config.conv_size, - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - use_bias=self.config.use_bias, - num_repetitions=2)(cc) - - # final 1x1 convolution corresponding to pixel-wise linear combination of feature channels - logits = tf.keras.layers.Conv2D( - filters=self.config.n_classes, - kernel_size=1)(net) - - logits = tf.keras.layers.Softmax()(logits) - - self.net = tf.keras.Model(inputs=x, outputs=logits) - - def call(self, inputs, training=None): - return self.net(inputs, training) - - -class ResUnetA(FCNModel): - """ - ResUnetA - - https://github.com/feevos/resuneta/tree/145be5519ee4bec9a8cce9e887808b8df011f520/models - - NOTE: The input to this network is a dictionary specifying input features and three output target images. This - might require some modification to the functions used to automate training and evaluation. Get in touch through - issues if this happens. - - TODO: build architecture from parameters as for FCn and TFCN - - """ - - def build(self, inputs_shape): - """Builds the net for input x.""" - x = tf.keras.layers.Input(shape=inputs_shape['features'][1:], name='features') - dropout_rate = 1 - self.config.keep_prob - - # block 1 - initial_conv = Conv2D( - filters=self.config.features_root, - kernel_size=1, # 1x1 kernel - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - use_bias=self.config.use_bias, - batch_normalization=True, - padding=self.config.padding, - num_repetitions=1)(x) - - # block 2 - resconv_1 = ResConv2D( - filters=self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1, 3, 15, 31], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - use_bias=self.config.use_bias, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=4)(initial_conv) - - # block 3 - pool_1 = Conv2D( - filters=2 * self.config.features_root, - kernel_size=self.config.pool_size, - strides=self.config.pool_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding='SAME', - num_repetitions=1)(resconv_1) - - # block 4 - resconv_2 = ResConv2D( - filters=2 * self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1, 3, 15, 31], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=4)(pool_1) - - # block 5 - pool_2 = Conv2D( - filters=4 * self.config.features_root, - kernel_size=self.config.pool_size, - strides=self.config.pool_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding='SAME', - num_repetitions=1)(resconv_2) - - # block 6 - resconv_3 = ResConv2D( - filters=4 * self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1, 3, 15], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=3)(pool_2) - - # block 7 - pool_3 = Conv2D( - filters=8 * self.config.features_root, - kernel_size=self.config.pool_size, - strides=self.config.pool_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding='SAME', - num_repetitions=1)(resconv_3) - - # block 8 - resconv_4 = ResConv2D( - filters=8 * self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1, 3, 15], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=3)(pool_3) - - # block 9 - pool_4 = Conv2D( - filters=16 * self.config.features_root, - kernel_size=self.config.pool_size, - strides=self.config.pool_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding='SAME', - num_repetitions=1)(resconv_4) - - # block 10 - resconv_5 = ResConv2D( - filters=16 * self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=1)(pool_4) - - # block 11 - pool_5 = Conv2D( - filters=32 * self.config.features_root, - kernel_size=self.config.pool_size, - strides=self.config.pool_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding='SAME', - num_repetitions=1)(resconv_5) - - # block 12 - resconv_6 = ResConv2D( - filters=32 * self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=1)(pool_5) - - # block 13 - ppm1 = PyramidPoolingModule(filters=32 * self.config.features_root, - batch_normalization=True)(resconv_6) - - # block 14 - deconv_1 = Deconv2D( - filters=32 * self.config.features_root, - kernel_size=self.config.deconv_size, - batch_normalization=self.config.add_batch_norm)(ppm1) - - # block 15 - concat_1 = CropAndConcat()(resconv_5, deconv_1) - concat_1 = Conv2D( - filters=16 * self.config.features_root, - kernel_size=1, # 1x1 kernel - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=True, # maybe - padding=self.config.padding, - num_repetitions=1)(concat_1) - - # block 16 - resconv_7 = ResConv2D( - filters=16 * self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=1)(concat_1) - - # block 17 - deconv_2 = Deconv2D( - filters=16 * self.config.features_root, - kernel_size=self.config.deconv_size, - batch_normalization=self.config.add_batch_norm)(resconv_7) - - # block 18 - concat_2 = CropAndConcat()(resconv_4, deconv_2) - concat_2 = Conv2D( - filters=8 * self.config.features_root, - kernel_size=1, # 1x1 kernel - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=True, # maybe - padding=self.config.padding, - num_repetitions=1)(concat_2) - - # block 19 - resconv_8 = ResConv2D( - filters=8 * self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1, 3, 15], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=3)(concat_2) - - # block 20 - deconv_3 = Deconv2D( - filters=8 * self.config.features_root, - kernel_size=self.config.deconv_size, - batch_normalization=self.config.add_batch_norm)(resconv_8) - - # block 21 - concat_3 = CropAndConcat()(resconv_3, deconv_3) - concat_3 = Conv2D( - filters=4 * self.config.features_root, - kernel_size=1, # 1x1 kernel - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=True, - padding=self.config.padding, - num_repetitions=1)(concat_3) - - # block 22 - resconv_9 = ResConv2D( - filters=4 * self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1, 3, 15], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=3)(concat_3) - - # block 23 - deconv_4 = Deconv2D( - filters=4 * self.config.features_root, - kernel_size=self.config.deconv_size, - batch_normalization=self.config.add_batch_norm)(resconv_9) - - # block 24 - concat_4 = CropAndConcat()(resconv_2, deconv_4) - concat_4 = Conv2D( - filters=2 * self.config.features_root, - kernel_size=1, # 1x1 kernel - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=True, - padding=self.config.padding, - num_repetitions=1)(concat_4) - - # block 25 - resconv_10 = ResConv2D( - filters=2 * self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1, 3, 15, 31], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=4)(concat_4) - - # block 26 - deconv_5 = Deconv2D( - filters=2 * self.config.features_root, - kernel_size=self.config.deconv_size, - batch_normalization=self.config.add_batch_norm)(resconv_10) - - # block 27 - concat_5 = CropAndConcat()(resconv_1, deconv_5) - concat_5 = Conv2D( - filters=self.config.features_root, - kernel_size=1, # 1x1 kernel - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=True, - padding=self.config.padding, - num_repetitions=1)(concat_5) - - # block 28 - resconv_11 = ResConv2D( - filters=self.config.features_root, - kernel_size=self.config.conv_size, - dilation=[1, 3, 15, 31], - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - padding=self.config.padding, - num_parallel=4)(concat_5) - - # block 29 - concat_6 = CropAndConcat()(initial_conv, resconv_11) - concat_6 = Conv2D( - filters=self.config.features_root, - kernel_size=1, # 1x1 kernel - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - use_bias=self.config.use_bias, - dropout_rate=dropout_rate, - batch_normalization=True, - padding=self.config.padding, - num_repetitions=1)(concat_6) - - # block 30 - ppm2 = PyramidPoolingModule(filters=self.config.features_root, - batch_normalization=True)(concat_6) - - # comditioned multi-tasking - # first get distance - distance_conv = Conv2D( - filters=self.config.features_root, - kernel_size=self.config.conv_size, - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - num_repetitions=2, - padding=self.config.padding)(concat_6) # in last layer we take the combined features - logits_distance = tf.keras.layers.Conv2D(filters=self.config.n_classes, kernel_size=1)(distance_conv) - logits_distance = tf.keras.layers.Softmax(name='distance')(logits_distance) - - # concatenate distance logits to features - dcc = CropAndConcat()(ppm2, logits_distance) - boundary_conv = Conv2D( - filters=self.config.features_root, - kernel_size=self.config.conv_size, - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - num_repetitions=1, - padding=self.config.padding)(dcc) - logits_boundary = tf.keras.layers.Conv2D(filters=self.config.n_classes, kernel_size=1)(boundary_conv) - logits_boundary = tf.keras.layers.Softmax(name='boundary')(logits_boundary) - - bdcc = CropAndConcat()(dcc, logits_boundary) - extent_conv = Conv2D( - filters=self.config.features_root, - kernel_size=self.config.conv_size, - strides=self.config.conv_stride, - add_dropout=self.config.add_dropout, - dropout_rate=dropout_rate, - batch_normalization=self.config.add_batch_norm, - num_repetitions=2, - padding=self.config.padding)(bdcc) - logits_extent = tf.keras.layers.Conv2D(filters=self.config.n_classes, kernel_size=1)(extent_conv) - logits_extent = tf.keras.layers.Softmax(name='extent')(logits_extent) - - self.net = tf.keras.Model(inputs=x, outputs=[logits_extent, logits_boundary, logits_distance]) - - def call(self, inputs, training=True): - return self.net(inputs, training) diff --git a/eo-flow/eoflow/models/tempnets_task/__init__.py b/eo-flow/eoflow/models/tempnets_task/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/eo-flow/eoflow/models/tempnets_task/cnn_tempnets.py b/eo-flow/eoflow/models/tempnets_task/cnn_tempnets.py deleted file mode 100644 index 163a55f..0000000 --- a/eo-flow/eoflow/models/tempnets_task/cnn_tempnets.py +++ /dev/null @@ -1,349 +0,0 @@ -import logging -import tensorflow as tf -from marshmallow import fields -from marshmallow.validate import OneOf - -from keras.layers import TimeDistributed -from tensorflow.keras.layers import SimpleRNN, LSTM, GRU, Dense -from tensorflow.python.keras.utils.layer_utils import print_summary - -from eoflow.models.layers import ResidualBlock -from eoflow.models.tempnets_task.tempnets_base import BaseTempnetsModel - -from eoflow.models import transformer_encoder_layers -from eoflow.models import pse_tae_layers - - -logging.basicConfig(level=logging.INFO, - format='%(asctime)s %(levelname)s %(message)s') - - -class TCNModel(BaseTempnetsModel): - """ Implementation of the TCN network taken form the keras-TCN implementation - - https://github.com/philipperemy/keras-tcn - """ - - class TCNModelSchema(BaseTempnetsModel._Schema): - keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) - - kernel_size = fields.Int(missing=2, description='Size of the convolution kernels.') - nb_filters = fields.Int(missing=64, description='Number of convolutional filters.') - nb_conv_stacks = fields.Int(missing=1) - dilations = fields.List(fields.Int, missing=[1, 2, 4, 8, 16, 32], description='Size of dilations used in the ' - 'covolutional layers') - padding = fields.String(missing='CAUSAL', validate=OneOf(['CAUSAL', 'SAME']), - description='Padding type used in convolutions.') - use_skip_connections = fields.Bool(missing=True, description='Flag to whether to use skip connections.') - return_sequences = fields.Bool(missing=False, description='Flag to whether return sequences or not.') - activation = fields.Str(missing='linear', description='Activation function used in final filters.') - kernel_initializer = fields.Str(missing='he_normal', description='method to initialise kernel parameters.') - kernel_regularizer = fields.Float(missing=0, description='L2 regularization parameter.') - - batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') - layer_norm = fields.Bool(missing=False, description='Whether to use layer normalisation.') - - def _cnn_layer(self, net): - - dropout_rate = 1 - self.config.keep_prob - - layer = tf.keras.layers.Conv1D(filters= self.config.nb_filters, - kernel_size=self.config.kernel_size, - padding=self.config.padding, - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - if self.config.batch_norm: - layer = tf.keras.layers.BatchNormalization(axis=-1)(layer) - - layer = tf.keras.layers.Dropout(dropout_rate)(layer) - layer = tf.keras.layers.Activation(self.config.activation)(layer) - return layer - - def build(self, inputs_shape): - """ Build TCN architecture - - The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of - time-frames, and `D` the number of channels - """ - x = tf.keras.layers.Input(inputs_shape[1:]) - - dropout_rate = 1 - self.config.keep_prob - - net = x - - net = self._cnn_layer(net) - - # list to hold all the member ResidualBlocks - residual_blocks = [] - skip_connections = [] - - total_num_blocks = self.config.nb_conv_stacks * len(self.config.dilations) - if not self.config.use_skip_connections: - total_num_blocks += 1 # cheap way to do a false case for below - - for _ in range(self.config.nb_conv_stacks): - for d in self.config.dilations: - net, skip_out = ResidualBlock(dilation_rate=d, - nb_filters=self.config.nb_filters, - kernel_size=self.config.kernel_size, - padding=self.config.padding, - activation=self.config.activation, - dropout_rate=dropout_rate, - use_batch_norm=self.config.batch_norm, - use_layer_norm=self.config.layer_norm, - kernel_initializer=self.config.kernel_initializer, - last_block=len(residual_blocks) + 1 == total_num_blocks, - name=f'residual_block_{len(residual_blocks)}')(net) - residual_blocks.append(net) - skip_connections.append(skip_out) - - - # Author: @karolbadowski. - output_slice_index = int(net.shape.as_list()[1] / 2) \ - if self.config.padding.lower() == 'same' else -1 - lambda_layer = tf.keras.layers.Lambda(lambda tt: tt[:, output_slice_index, :]) - - if self.config.use_skip_connections: - net = tf.keras.layers.add(skip_connections) - - if not self.config.return_sequences: - net = lambda_layer(net) - - net = tf.keras.layers.Dense(1, activation='linear')(net) - - self.net = tf.keras.Model(inputs=x, outputs=net) - - #print_summary(self.net) - - def call(self, inputs, training=None): - return self.net(inputs, training) - - - -class TempCNNModel(BaseTempnetsModel): - """ Implementation of the TempCNN network taken from the temporalCNN implementation - - https://github.com/charlotte-pel/temporalCNN - """ - - class TempCNNModelSchema(BaseTempnetsModel._Schema): - keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) - kernel_size = fields.Int(missing=5, description='Size of the convolution kernels.') - nb_conv_filters = fields.Int(missing=16, description='Number of convolutional filters.') - nb_conv_stacks = fields.Int(missing=3, description='Number of convolutional blocks.') - nb_conv_strides = fields.Int(missing=1, description='Value of convolutional strides.') - nb_fc_neurons = fields.Int(missing=256, description='Number of Fully Connect neurons.') - nb_fc_stacks = fields.Int(missing=1, description='Number of fully connected layers.') - final_layer = fields.String(missing='Flatten', validate=OneOf(['Flatten','GlobalAveragePooling1D', 'GlobalMaxPooling1D']), - description='Final layer after the convolutions.') - padding = fields.String(missing='SAME', validate=OneOf(['SAME','VALID', 'CAUSAL']), - description='Padding type used in convolutions.') - activation = fields.Str(missing='relu', description='Activation function used in final filters.') - fc_activation = fields.Str(missing=None, description='Activation function used in final FC layers.') - kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') - kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') - enumerate = fields.Bool(missing=False, description='Increase number of filters across convolution') - batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') - - def _cnn_layer(self, net, i = 0): - - dropout_rate = 1 - self.config.keep_prob - filters = self.config.nb_conv_filters - kernel_size = self.config.kernel_size - - if self.config.enumerate: - filters = filters * (2**i) - kernel_size = kernel_size * (i+1) - - layer = tf.keras.layers.Conv1D(filters=filters, - kernel_size=kernel_size, - strides=self.config.nb_conv_strides, - padding=self.config.padding, - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - if self.config.batch_norm: - layer = tf.keras.layers.BatchNormalization(axis=-1)(layer) - - layer = tf.keras.layers.Dropout(dropout_rate)(layer) - layer = tf.keras.layers.Activation(self.config.activation)(layer) - - - return layer - - def _embeddings(self,net): - - name = "embedding" - if self.config.final_layer == 'Flatten': - net = tf.keras.layers.Flatten(name=name)(net) - elif self.config.final_layer == 'GlobalAveragePooling1D': - net = tf.keras.layers.GlobalAveragePooling1D(name=name)(net) - elif self.config.final_layer == 'GlobalMaxPooling1D': - net = tf.keras.layers.GlobalMaxPooling1D(name=name)(net) - - return net - - def _fcn_layer(self, net): - dropout_rate = 1 - self.config.keep_prob - layer_fcn = Dense(units=self.config.nb_fc_neurons, - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - if self.config.batch_norm: - layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) - - layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) - if self.config.fc_activation: - layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) - - return layer_fcn - - - def build(self, inputs_shape): - """ Build TCN architecture - - The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of - time-frames, and `D` the number of channels - """ - x = tf.keras.layers.Input(inputs_shape[1:]) - - net = x - for i, _ in enumerate(range(self.config.nb_conv_stacks)): - net = self._cnn_layer(net, i) - - net = self._embeddings(net) - self.backbone = tf.keras.Model(inputs=x, outputs=net) - - for _ in range(self.config.nb_fc_stacks): - net = self._fcn_layer(net) - - net = Dense(units = 1, - activation = 'linear', - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - - self.net = tf.keras.Model(inputs=x, outputs=net) - - print_summary(self.net) - - def call(self, inputs, training=None): - return self.net(inputs, training) - - def get_feature_map(self, inputs, training=None): - return self.backbone(inputs, training) - - - -class HistogramCNNModel(BaseTempnetsModel): - """ Implementation of the CNN2D with histogram time series - - https://cs.stanford.edu/~ermon/papers/cropyield_AAAI17.pdf - """ - - class HistogramCNNModel(BaseTempnetsModel._Schema): - keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) - kernel_size = fields.List(fields.Int, missing=2, description='Size of the convolution kernels.') - nb_conv_filters = fields.Int(missing=16, description='Number of convolutional filters.') - nb_conv_stacks = fields.Int(missing=3, description='Number of convolutional blocks.') - nb_conv_strides = fields.List(fields.Int, missing=2, description='Value of convolutional strides.') - nb_fc_neurons = fields.Int(missing=256, description='Number of Fully Connect neurons.') - nb_fc_stacks = fields.Int(missing=1, description='Number of fully connected layers.') - final_layer = fields.String(missing='Flatten', validate=OneOf(['Flatten','GlobalAveragePooling2D', 'GlobalMaxPooling2D']), - description='Final layer after the convolutions.') - padding = fields.String(missing='SAME', validate=OneOf(['SAME','VALID', 'CAUSAL']), - description='Padding type used in convolutions.') - activation = fields.Str(missing='relu', description='Activation function used in final filters.') - kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') - kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') - enumerate = fields.Bool(missing=False, description='Increase number of filters across convolution') - batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') - - def _cnn_layer(self, net, i = 1, last = False): - - dropout_rate = 1 - self.config.keep_prob - filters = self.config.nb_conv_filters - s_i, s_j = self.config.nb_conv_strides.copy() - - if self.config.enumerate: - filters = filters * (2**i) - if last: - strides = self.config.nb_conv_strides.copy() - else: - strides = (s_i * (i + 1), s_i * (i + 1)) - - print(strides) - - layer = tf.keras.layers.Conv2D(filters=filters, - kernel_size=self.config.kernel_size, - strides=strides, - padding=self.config.padding, - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - if self.config.batch_norm: - layer = tf.keras.layers.BatchNormalization(axis=-1)(layer) - - #if self.config.enumerate: layer = tf.keras.layers.MaxPool1D()(layer) - - layer = tf.keras.layers.Dropout(dropout_rate)(layer) - layer = tf.keras.layers.Activation(self.config.activation)(layer) - return layer - - def _embeddings(self,net): - - name = "embedding" - if self.config.final_layer == 'Flatten': - net = tf.keras.layers.Flatten(name=name)(net) - elif self.config.final_layer == 'GlobalAveragePooling2D': - net = tf.keras.layers.GlobalAveragePooling2D(name=name)(net) - elif self.config.final_layer == 'GlobalMaxPooling2D': - net = tf.keras.layers.GlobalMaxPooling2D(name=name)(net) - - return net - - def _fcn_layer(self, net): - dropout_rate = 1 - self.config.keep_prob - layer_fcn = Dense(units=self.config.nb_fc_neurons, - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - if self.config.batch_norm: - layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) - - layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) - layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) - - return layer_fcn - - - def build(self, inputs_shape): - """ Build TCN architecture - - The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of - time-frames, and `D` the number of channels - """ - x = tf.keras.layers.Input(inputs_shape[1:]) - - net = x - for i, _ in enumerate(range(self.config.nb_conv_stacks)): - net = self._cnn_layer(net, i) - print(net.shape) - net = self._cnn_layer(net, i, True) - print(net.shape) - - net = self._embeddings(net) - self.backbone = tf.keras.Model(inputs=x, outputs=net) - - for _ in range(self.config.nb_fc_stacks): - net = self._fcn_layer(net) - - net = Dense(units = 1, - activation = 'linear', - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - - self.net = tf.keras.Model(inputs=x, outputs=net) - - #print_summary(self.net) - - def call(self, inputs, training=None): - return self.net(inputs, training) - - def get_feature_map(self, inputs, training=None): - return self.backbone(inputs, training) diff --git a/eo-flow/eoflow/models/tempnets_task/mlp_tempnets.py b/eo-flow/eoflow/models/tempnets_task/mlp_tempnets.py deleted file mode 100644 index 82bd350..0000000 --- a/eo-flow/eoflow/models/tempnets_task/mlp_tempnets.py +++ /dev/null @@ -1,182 +0,0 @@ -import logging -import tensorflow as tf -from marshmallow import fields -from marshmallow.validate import OneOf - -from keras.layers import TimeDistributed -from tensorflow.keras.layers import SimpleRNN, LSTM, GRU, Dense -from tensorflow.python.keras.utils.layer_utils import print_summary - -from eoflow.models.layers import ResidualBlock -from eoflow.models.tempnets_task.tempnets_base import BaseTempnetsModel - -from eoflow.models import transformer_encoder_layers -from eoflow.models import pse_tae_layers - -logging.basicConfig(level=logging.INFO, - format='%(asctime)s %(levelname)s %(message)s') - - -class MLP(BaseTempnetsModel): - """ - Implementation of the mlp network - """ - - class MLPSchema(BaseTempnetsModel._Schema): - keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) - nb_fc_neurons = fields.Int(missing=256, description='Number of Fully Connect neurons.') - nb_fc_stacks = fields.Int(missing=1, description='Number of fully connected layers.') - activation = fields.Str(missing='relu', description='Activation function used in final filters.') - kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') - kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') - batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') - - def _fcn_layer(self, net): - dropout_rate = 1 - self.config.keep_prob - layer_fcn = Dense(units=self.config.nb_fc_neurons, - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - if self.config.batch_norm: - layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) - layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) - layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) - - return layer_fcn - - def build(self, inputs_shape): - """ Build TCN architecture - - The `inputs_shape` argument is a `(N, T*D)` tuple where `N` denotes the number of samples, `T` the number of - time-frames, and `D` the number of channels - """ - x = tf.keras.layers.Input(inputs_shape[1:]) - net = x - - for _ in range(self.config.nb_fc_stacks): - net = self._fcn_layer(net) - - net = tf.keras.layers.Dense(units = 1, - activation = 'linear', - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - - self.net = tf.keras.Model(inputs=x, outputs=net) - - print_summary(self.net) - - def call(self, inputs, training=None): - return self.net(inputs, training) - - - - -class TransformerEncoder(BaseTempnetsModel): - """ Implementation of a self-attention classifier - Code is based on the Pytorch implementation of Marc Russwurm https://github.com/MarcCoru/crop-type-mapping - """ - - class TransformerEncoderSchema(BaseTempnetsModel._Schema): - keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) - - num_heads = fields.Int(missing=8, description='Number of Attention heads.') - num_layers = fields.Int(missing=4, description='Number of encoder layers.') - num_dff = fields.Int(missing=512, description='Number of feed-forward neurons in point-wise MLP.') - d_model = fields.Int(missing=128, description='Depth of model.') - max_pos_enc = fields.Int(missing=24, description='Maximum length of positional encoding.') - layer_norm = fields.Bool(missing=True, description='Whether to apply layer normalization in the encoder.') - - activation = fields.Str(missing='linear', description='Activation function used in final dense filters.') - - def init_model(self): - - self.encoder = transformer_encoder_layers.Encoder( - num_layers=self.config.num_layers, - d_model=self.config.d_model, - num_heads=self.config.num_heads, - dff=self.config.num_dff, - maximum_position_encoding=self.config.max_pos_enc, - layer_norm=self.config.layer_norm) - - self.dense = tf.keras.layers.Dense(units=self.config.n_classes, - activation=self.config.activation) - - def build(self, inputs_shape): - """ Build Transformer encoder architecture - The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of - time-frames, and `D` the number of channels - """ - seq_len = inputs_shape[1] - - self.net = tf.keras.Sequential([ - self.encoder, - self.dense, - tf.keras.layers.MaxPool1D(pool_size=seq_len), - tf.keras.layers.Lambda(lambda x: tf.keras.backend.squeeze(x, axis=-2), name='squeeze'), - tf.keras.layers.Softmax() - ]) - # Build the model, so we can print the summary - self.net.build(inputs_shape) - - print_summary(self.net) - - def call(self, inputs, training=None, mask=None): - return self.net(inputs, training, mask) - - - - - -######################################################################################################################################################## - -class PseTae(BaseTempnetsModel): - """ Implementation of the Pixel-Set encoder + Temporal Attention Encoder sequence classifier - - Code is based on the Pytorch implementation of V. Sainte Fare Garnot et al. https://github.com/VSainteuf/pytorch-psetae - """ - - class PseTaeSchema(BaseTempnetsModel._Schema): - mlp1 = fields.List(fields.Int, missing=[10, 32, 64], description='Number of units for each layer in mlp1.') - pooling = fields.Str(missing='mean_std', description='Methods used for pooling. Seperated by underscore. (mean, std, max, min)') - mlp2 = fields.List(fields.Int, missing=[132, 128], description='Number of units for each layer in mlp2.') - - num_heads = fields.Int(missing=4, description='Number of Attention heads.') - num_dff = fields.Int(missing=32, description='Number of feed-forward neurons in point-wise MLP.') - d_model = fields.Int(missing=None, description='Depth of model.') - mlp3 = fields.List(fields.Int, missing=[512, 128, 128], description='Number of units for each layer in mlp3.') - dropout = fields.Float(missing=0.2, description='Dropout rate for attention encoder.') - T = fields.Float(missing=1000, description='Number of features for attention.') - len_max_seq = fields.Int(missing=24, description='Number of features for attention.') - mlp4 = fields.List(fields.Int, missing=[128, 64, 32], description='Number of units for each layer in mlp4. ') - - def init_model(self): - # TODO: missing features from original PseTae: - # * spatial encoder extra features (hand-made) - # * spatial encoder masking - - self.spatial_encoder = pse_tae_layers.PixelSetEncoder( - mlp1=self.config.mlp1, - mlp2=self.config.mlp2, - pooling=self.config.pooling) - - self.temporal_encoder = pse_tae_layers.TemporalAttentionEncoder( - n_head=self.config.num_heads, - d_k=self.config.num_dff, - d_model=self.config.d_model, - n_neurons=self.config.mlp3, - dropout=self.config.dropout, - T=self.config.T, - len_max_seq=self.config.len_max_seq) - - mlp4_layers = [pse_tae_layers.LinearLayer(out_dim) for out_dim in self.config.mlp4] - # Final layer (logits) - mlp4_layers.append(pse_tae_layers.LinearLayer(1, batch_norm=False, activation='linear')) - - self.mlp4 = tf.keras.Sequential(mlp4_layers) - - def call(self, inputs, training=None, mask=None): - - out = self.spatial_encoder(inputs, training=training, mask=mask) - out = self.temporal_encoder(out, training=training, mask=mask) - out = self.mlp4(out, training=training, mask=mask) - - return out diff --git a/eo-flow/eoflow/models/tempnets_task/rnn_tempnets.py b/eo-flow/eoflow/models/tempnets_task/rnn_tempnets.py deleted file mode 100644 index aadcfe9..0000000 --- a/eo-flow/eoflow/models/tempnets_task/rnn_tempnets.py +++ /dev/null @@ -1,232 +0,0 @@ -import logging -import tensorflow as tf -from marshmallow import fields -from marshmallow.validate import OneOf - -from keras.layers import TimeDistributed -from tensorflow.keras.layers import SimpleRNN, LSTM, GRU, Dense -from tensorflow.python.keras.utils.layer_utils import print_summary - -from eoflow.models.layers import ResidualBlock -from eoflow.models.tempnets_task.tempnets_base import BaseTempnetsModel - -from eoflow.models import transformer_encoder_layers -from eoflow.models import pse_tae_layers - -logging.basicConfig(level=logging.INFO, - format='%(asctime)s %(levelname)s %(message)s') - -rnn_layers = dict(rnn=SimpleRNN, gru=GRU, lstm=LSTM) - - -class BiRNN(BaseTempnetsModel): - """ Implementation of a Bidirectional Recurrent Neural Network - - This implementation allows users to define which RNN layer to use, e.g. SimpleRNN, GRU or LSTM - """ - - class BiRNNModelSchema(BaseTempnetsModel._Schema): - rnn_layer = fields.String(required=True, validate=OneOf(['rnn', 'lstm', 'gru']), - description='Type of RNN layer to use') - - keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) - - rnn_units = fields.Int(missing=64, description='Size of the convolution kernels.') - rnn_blocks = fields.Int(missing=1, description='Number of LSTM blocks') - bidirectional = fields.Bool(missing=True, description='Whether to use a bidirectional layer') - - activation = fields.Str(missing='relu', description='Activation function for fully connected layers') - kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') - kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') - nb_fc_stacks = fields.Int(missing=0, description='Number of fully connected layers.') - nb_fc_neurons = fields.Int(missing=0, description='Number of fully connected neurons.') - - layer_norm = fields.Bool(missing=True, description='Whether to apply layer normalization in the encoder.') - batch_norm = fields.Bool(missing=False, description='Whether to use batch normalisation.') - - def _rnn_layer(self, net, last=False): - """ Returns a RNN layer for current configuration. Use `last=True` for the last RNN layer. """ - RNNLayer = rnn_layers[self.config.rnn_layer] - dropout_rate = 1 - self.config.keep_prob - - layer = RNNLayer( - units=self.config.rnn_units, - dropout=dropout_rate, - return_sequences=not last, - ) - - # Use bidirectional if specified - if self.config.bidirectional: - layer = tf.keras.layers.Bidirectional(layer) - - return layer(net) - - - def _fcn_layer(self, net): - dropout_rate = 1 - self.config.keep_prob - layer_fcn = Dense(units=self.config.nb_fc_neurons, - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - if self.config.batch_norm: - layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) - layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) - layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) - - return layer_fcn - - def build(self, inputs_shape): - """ Creates the RNN model architecture. """ - - x = tf.keras.layers.Input(inputs_shape[1:]) - net = x - - if self.config.layer_norm: - net = tf.keras.layers.LayerNormalization(axis=-1)(net) - - for _ in range(self.config.rnn_blocks -1): - net = self._rnn_layer(net) - net = self._rnn_layer(net, last=True) - - if self.config.layer_norm: - net = tf.keras.layers.LayerNormalization(axis=-1)(net) - - for _ in range(self.config.nb_fc_stacks): - net = self._fcn_layer(net) - - net = tf.keras.layers.Dense(units=1, - activation='linear', - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - - self.net = tf.keras.Model(inputs=x, outputs=net) - - print_summary(self.net) - - def call(self, inputs, training=None): - return self.net(inputs, training) - - - -#https://www.sciencedirect.com/science/article/pii/S0034425721003205 - - -class ConvLSTM(BaseTempnetsModel): - """ Implementation of a Bidirectional Recurrent Neural Network - - This implementation allows users to define which RNN layer to use, e.g. SimpleRNN, GRU or LSTM - """ - - - class ConvLSTMShema(BaseTempnetsModel._Schema): - keep_prob = fields.Float(required=True, description='Keep probability used in dropout layers.', example=0.5) - kernel_size = fields.Int(missing=5, description='Size of the convolution kernels.') - nb_conv_filters = fields.Int(missing=16, description='Number of convolutional filters.') - nb_conv_stacks = fields.Int(missing=3, description='Number of convolutional blocks.') - nb_conv_strides = fields.Int(missing=1, description='Value of convolutional strides.') - nb_fc_neurons = fields.Int(missing=256, description='Number of Fully Connect neurons.') - nb_fc_stacks = fields.Int(missing=1, description='Number of fully connected layers.') - - padding = fields.String(missing='SAME', validate=OneOf(['SAME','VALID', 'CAUSAL']), - description='Padding type used in convolutions.') - activation = fields.Str(missing='relu', description='Activation function used in final filters.') - kernel_initializer = fields.Str(missing='he_normal', description='Method to initialise kernel parameters.') - kernel_regularizer = fields.Float(missing=1e-6, description='L2 regularization parameter.') - enumerate = fields.Bool(missing=False, description='Increase number of filters across convolution') - batch_norm = fields.Bool(missing=True, description='Whether to use batch normalisation.') - - rnn_layer = fields.String(required=True, validate=OneOf(['rnn', 'lstm', 'gru']), - description='Type of RNN layer to use') - rnn_units = fields.Int(missing=64, description='Size of the convolution kernels.') - rnn_blocks = fields.Int(missing=1, description='Number of LSTM blocks') - bidirectional = fields.Bool(missing=False, description='Whether to use a bidirectional layer') - layer_norm = fields.Bool(missing=True, description='Whether to apply layer normalization in the encoder.') - - def _cnn_layer(self, net, i = 0): - - dropout_rate = 1 - self.config.keep_prob - filters = self.config.nb_conv_filters - kernel_size = self.config.kernel_size - - if self.config.enumerate: - filters = filters * (2**i) - kernel_size = kernel_size * (i+1) - - layer = tf.keras.layers.Conv1D(filters=filters, - kernel_size=kernel_size, - strides=self.config.nb_conv_strides, - padding=self.config.padding, - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - if self.config.batch_norm: - layer = tf.keras.layers.BatchNormalization(axis=-1)(layer) - - layer = tf.keras.layers.Dropout(dropout_rate)(layer) - layer = tf.keras.layers.Activation(self.config.activation)(layer) - - return layer - - def _rnn_layer(self, net, last=False): - """ Returns a RNN layer for current configuration. Use `last=True` for the last RNN layer. """ - RNNLayer = rnn_layers[self.config.rnn_layer] - dropout_rate = 1 - self.config.keep_prob - - layer = RNNLayer( - units=self.config.rnn_units, - dropout=dropout_rate, - return_sequences=not last, - ) - - # Use bidirectional if specified - if self.config.bidirectional: - layer = tf.keras.layers.Bidirectional(layer) - - return layer(net) - - def _fcn_layer(self, net): - dropout_rate = 1 - self.config.keep_prob - layer_fcn = Dense(units=self.config.nb_fc_neurons, - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - if self.config.batch_norm: - layer_fcn = tf.keras.layers.BatchNormalization(axis=-1)(layer_fcn) - - layer_fcn = tf.keras.layers.Dropout(dropout_rate)(layer_fcn) - layer_fcn = tf.keras.layers.Activation(self.config.activation)(layer_fcn) - - - return layer_fcn - - def build(self, inputs_shape): - """ Build TCN architecture - - The `inputs_shape` argument is a `(N, T, D)` tuple where `N` denotes the number of samples, `T` the number of - time-frames, and `D` the number of channels - """ - x = tf.keras.layers.Input(shape = inputs_shape[1:]) - print(x.shape) - net = x - for i, _ in enumerate(range(self.config.nb_conv_stacks)): - net = self._cnn_layer(net, i) - - for i, _ in range(self.config.rnn_blocks-1): - net = self._rnn_layer(net) - net = self._rnn_layer(net, last=True) - - for _ in range(self.config.nb_fc_stacks): - net = self._fcn_layer(net) - - net = Dense(units = 1, - activation = 'linear', - kernel_initializer=self.config.kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(self.config.kernel_regularizer))(net) - - self.net = tf.keras.Model(inputs=x, outputs=net) - - print_summary(self.net) - - def call(self, inputs, training=None): - return self.net(inputs, training) - - def get_feature_map(self, inputs, training=None): - return self.backbone(inputs, training) - diff --git a/eo-flow/eoflow/models/tempnets_task/tempnets_base.py b/eo-flow/eoflow/models/tempnets_task/tempnets_base.py deleted file mode 100644 index fbfa446..0000000 --- a/eo-flow/eoflow/models/tempnets_task/tempnets_base.py +++ /dev/null @@ -1,173 +0,0 @@ -import logging - -import tensorflow as tf - -from marshmallow import Schema, fields -from marshmallow.validate import OneOf, ContainsOnly - -from eoflow.base import BaseModelTraining, BaseModelCustomTraining -import tensorflow as tensorflow - -from eoflow.models.losses import CategoricalCrossEntropy, CategoricalFocalLoss -from eoflow.models.metrics import InitializableMetric, RSquared - - -logging.basicConfig(level=logging.INFO, - format='%(asctime)s %(levelname)s %(message)s') - - -# Available losses. Add keys with new losses here. -dictionary_losses = { - 'mse': tensorflow.keras.losses.MeanSquaredError, - 'huber': tensorflow.keras.losses.Huber, - 'mae': tensorflow.keras.losses.MeanAbsoluteError, - 'cross_entropy': CategoricalCrossEntropy, - 'focal_loss': CategoricalFocalLoss -} - -# Available metrics. Add keys with new metrics here. -dictionary_metrics = { - 'mse': tf.keras.metrics.MeanSquaredError, - 'mape': tf.keras.metrics.MeanAbsolutePercentageError, - 'mae': tf.keras.metrics.MeanAbsoluteError, - 'accuracy': tf.keras.metrics.CategoricalAccuracy(name='accuracy'), - 'precision': tf.keras.metrics.Precision, - 'recall': tf.keras.metrics.Recall, - 'r_square' : RSquared -} - - - -class BaseTempnetsModel(BaseModelTraining): - """ Base for pixel-wise classification models. """ - - class _Schema(Schema): - #n_outputs = fields.Int(required=True, description='Number of output layers', example=1) - learning_rate = fields.Float(missing=None, description='Learning rate used in training.', example=0.001) - loss = fields.String(missing='mse', description='Loss function used for training.', - validate=OneOf(dictionary_losses.keys())) - metrics = fields.List(fields.String, missing=['mse'], - description='List of metrics used for evaluation.', - validate=ContainsOnly(dictionary_metrics.keys())) - - def prepare(self, optimizer=None, loss=None, metrics=None, **kwargs): - """ Prepares the model. Optimizer, loss and metrics are read using the following protocol: - * If an argument is None, the default value is used from the configuration of the model. - * If an argument is a key contained in segmentation specific losses/metrics, those are used. - * Otherwise the argument is passed to `compile` as is. - - """ - # Read defaults if None - if optimizer is None: - optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate) - - if loss is None: - loss = self.config.loss - - if metrics is None: - metrics = self.config.metric - - loss = dictionary_losses[loss](**kwargs) - - reported_metrics = [] - for metric in metrics: - - if metric in dictionary_metrics: - metric = dictionary_metrics[metric](**kwargs) - - # Initialize initializable metrics - if isinstance(metric, InitializableMetric): - metric.init_from_config(self.config) - - reported_metrics.append(metric) - - self.compile(optimizer=optimizer, loss=loss, metrics=reported_metrics, **kwargs) - - # Override default method to add prediction visualization - def train(self, - dataset, - num_epochs, - model_directory, - iterations_per_epoch=None, - callbacks=[], - save_steps='epoch', - summary_steps=1, **kwargs): - - super().train(dataset, num_epochs, model_directory, iterations_per_epoch, - callbacks=callbacks, save_steps=save_steps, - summary_steps=summary_steps, **kwargs) - - # Override default method to add prediction visualization - def train_and_evaluate(self, - train_dataset, - val_dataset, - num_epochs, - iterations_per_epoch, - model_directory, - save_steps=100, - summary_steps=10, - callbacks=[], **kwargs): - - super().train_and_evaluate(train_dataset, val_dataset, - num_epochs, iterations_per_epoch, - model_directory, - save_steps=save_steps, summary_steps=summary_steps, - callbacks=callbacks, **kwargs) - - - -''' -class BaseTempnetsModel(BaseModelCustomTraining): - """ Base for pixel-wise classification models. """ - - class _Schema(Schema): - #n_outputs = fields.Int(required=True, description='Number of output layers', example=1) - learning_rate = fields.Float(missing=None, description='Learning rate used in training.', example=0.001) - loss = fields.String(missing='mse', description='Loss function used for training.', - validate=OneOf(dictionary_losses.keys())) - metrics = fields.String(missing='mse', - description='List of metrics used for evaluation.', - validate=OneOf(dictionary_metrics.keys())) - - def prepare(self, optimizer=None, loss=None, metrics=None, - loss_metric = tf.keras.metrics.Mean(), - **kwargs): - """ Prepares the model. Optimizer, loss and metrics are read using the following protocol: - * If an argument is None, the default value is used from the configuration of the model. - * If an argument is a key contained in segmentation specific losses/metrics, those are used. - * Otherwise the argument is passed to `compile` as is. - - """ - # Read defaults if None - if optimizer is None: - optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate) - - if loss is None: - loss = self.config.loss - loss = dictionary_losses[loss](**kwargs) - self.loss_metric = loss_metric - - if metrics is None: - metrics = self.config.metrics - self.metric = dictionary_metrics[metrics](**kwargs) - - if isinstance(self.metric, InitializableMetric): - self.metric.init_from_config(self.config) - - self.compile(optimizer=optimizer, loss=loss, metrics=self.metric, **kwargs) - - # Override default method to add prediction visualization - def train_and_evaluate(self, - train_dataset, - val_dataset, - num_epochs, - iterations_per_epoch, - model_directory, - **kwargs): - - super().train_and_evaluate(train_dataset, val_dataset, - num_epochs, iterations_per_epoch, - model_directory, - **kwargs) - -''' \ No newline at end of file diff --git a/eo-flow/eoflow/models/transformer_encoder_layers.py b/eo-flow/eoflow/models/transformer_encoder_layers.py deleted file mode 100644 index 08b86d6..0000000 --- a/eo-flow/eoflow/models/transformer_encoder_layers.py +++ /dev/null @@ -1,193 +0,0 @@ -import tensorflow as tf -import numpy as np - -from tensorflow.keras.layers import Conv1D, LayerNormalization - -# This code is taken from the TF tutorial on transformers -# https://www.tensorflow.org/tutorials/text/transformer -def scaled_dot_product_attention(q, k, v, mask=None): - """ Calculate the attention weights. - q, k, v must have matching leading dimensions. - k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v. - The mask has different shapes depending on its type(padding or look ahead) - but it must be broadcastable for addition. - - Args: - q: query shape == (..., seq_len_q, depth) - k: key shape == (..., seq_len_k, depth) - v: value shape == (..., seq_len_v, depth_v) - mask: Float tensor with shape broadcastable - to (..., seq_len_q, seq_len_k). Defaults to None. - - Returns: - output, attention_weights - """ - - matmul_qk = tf.matmul(q, k, transpose_b=True) # (..., seq_len_q, seq_len_k) - - # scale matmul_qk - dk = tf.cast(tf.shape(k)[-1], tf.float32) - scaled_attention_logits = matmul_qk / tf.math.sqrt(dk) - - # add the mask to the scaled tensor. - if mask is not None: - scaled_attention_logits += (mask * -1e9) - - # softmax is normalized on the last axis (seq_len_k) so that the scores - # add up to 1. - attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1) # (..., seq_len_q, seq_len_k) - - output = tf.matmul(attention_weights, v) # (..., seq_len_q, depth_v) - - return output, attention_weights - - -class MultiHeadAttention(tf.keras.layers.Layer): - def __init__(self, d_model, num_heads): - super(MultiHeadAttention, self).__init__() - self.num_heads = num_heads - self.d_model = d_model - - assert d_model % self.num_heads == 0 - - self.depth = d_model // self.num_heads - - self.wq = tf.keras.layers.Dense(d_model) - self.wk = tf.keras.layers.Dense(d_model) - self.wv = tf.keras.layers.Dense(d_model) - - self.dense = tf.keras.layers.Dense(d_model) - - def split_heads(self, x, batch_size): - """Split the last dimension into (num_heads, depth). - Transpose the result such that the shape is (batch_size, num_heads, seq_len, depth) - """ - x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth)) - return tf.transpose(x, perm=[0, 2, 1, 3]) - - def call(self, v, k, q, mask=None): - batch_size = tf.shape(q)[0] - - q = self.wq(q) # (batch_size, seq_len, d_model) - k = self.wk(k) # (batch_size, seq_len, d_model) - v = self.wv(v) # (batch_size, seq_len, d_model) - - q = self.split_heads(q, batch_size) # (batch_size, num_heads, seq_len_q, depth) - k = self.split_heads(k, batch_size) # (batch_size, num_heads, seq_len_k, depth) - v = self.split_heads(v, batch_size) # (batch_size, num_heads, seq_len_v, depth) - - # scaled_attention.shape == (batch_size, num_heads, seq_len_q, depth) - # attention_weights.shape == (batch_size, num_heads, seq_len_q, seq_len_k) - scaled_attention, attention_weights = scaled_dot_product_attention(q, k, v, mask) - - # (batch_size, seq_len_q, num_heads, depth) - scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3]) - - # (batch_size, seq_len_q, d_model) - concat_attention = tf.reshape(scaled_attention, (batch_size, -1, self.d_model)) - - # (batch_size, seq_len_q, d_model) - output = self.dense(concat_attention) - - return output, attention_weights - - -def point_wise_feed_forward_network(d_model, dff): - return tf.keras.Sequential([ - tf.keras.layers.Dense(dff, activation='relu'), # (batch_size, seq_len, dff) - tf.keras.layers.Dense(d_model) # (batch_size, seq_len, d_model) - ]) - - -def positional_encoding(positions, d_model, T=10000): - - if isinstance(positions, int): - positions = np.arange(positions) - else: - positions = np.array(positions) - - def _get_angles(pos, i, d_model): - angle_rates = 1 / np.power(T, (2 * (i//2)) / np.float32(d_model)) - return pos * angle_rates - - depths = np.arange(d_model) - - angle_rads = _get_angles(positions[:, np.newaxis], - depths[np.newaxis, :], - d_model) - - # apply sin to even indices in the array; 2i - angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2]) - - # apply cos to odd indices in the array; 2i+1 - angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2]) - - pos_encoding = angle_rads[np.newaxis, ...] - - return tf.cast(pos_encoding, dtype=tf.float32) - - -class EncoderLayer(tf.keras.layers.Layer): - def __init__(self, d_model, num_heads, dff, rate=0.1): - super(EncoderLayer, self).__init__() - - self.mha = MultiHeadAttention(d_model, num_heads) - self.ffn = point_wise_feed_forward_network(d_model, dff) - - self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6) - self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6) - - self.dropout1 = tf.keras.layers.Dropout(rate) - self.dropout2 = tf.keras.layers.Dropout(rate) - - def call(self, x, training=None, mask=None): - attn_output, _ = self.mha(x, x, x, mask) # (batch_size, input_seq_len, d_model) - attn_output = self.dropout1(attn_output, training=training) - out1 = self.layernorm1(x + attn_output) # (batch_size, input_seq_len, d_model) - - ffn_output = self.ffn(out1) # (batch_size, input_seq_len, d_model) - ffn_output = self.dropout2(ffn_output, training=training) - return self.layernorm2(out1 + ffn_output) - - -class Encoder(tf.keras.layers.Layer): - def __init__(self, num_layers, d_model, num_heads, dff, maximum_position_encoding, rate=0.1, layer_norm=False, T=10000): - super(Encoder, self).__init__() - - self.d_model = d_model - self.num_layers = num_layers - - self.lnorm_in = tf.keras.layers.LayerNormalization() if layer_norm else None - self.lnorm_conv = tf.keras.layers.LayerNormalization() if layer_norm else None - - # replace embedding with 1d convolution - self.conv_in = Conv1D(d_model, 1) - # self.embedding = tf.keras.layers.Embedding(input_vocab_size, d_model) - self.pos_encoding = positional_encoding(maximum_position_encoding, self.d_model, T=T) - - encoder_layers = [EncoderLayer(d_model, num_heads, dff, rate) - for _ in range(num_layers)] - self.encoder = tf.keras.Sequential(encoder_layers) - - self.dropout = tf.keras.layers.Dropout(rate) - - - def call(self, x, training=None, mask=None): - seq_len = tf.shape(x)[1] - - if self.lnorm_in: - x = self.lnorm_in(x) - - # adding embedding and position encoding. - x = self.conv_in(x, training=training) # (batch_size, input_seq_len, d_model) - if self.lnorm_conv: - x = self.lnorm_conv(x) - - x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32)) - x += self.pos_encoding[:, :seq_len, :] - - x = self.dropout(x, training=training) - - x = self.encoder(x, training=training, mask=mask) - - return x # (batch_size, input_seq_len, d_model) diff --git a/eo-flow/eoflow/tasks/__init__.py b/eo-flow/eoflow/tasks/__init__.py deleted file mode 100644 index 6f0263f..0000000 --- a/eo-flow/eoflow/tasks/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .train import TrainTask, TrainAndEvaluateTask -from .predict import PredictTask -from .evaluate import EvaluateTask diff --git a/eo-flow/eoflow/tasks/evaluate.py b/eo-flow/eoflow/tasks/evaluate.py deleted file mode 100644 index 51197d5..0000000 --- a/eo-flow/eoflow/tasks/evaluate.py +++ /dev/null @@ -1,28 +0,0 @@ -from marshmallow import Schema, fields - -from ..base import BaseTask -from ..base.configuration import ObjectConfiguration - - -class EvaluateTask(BaseTask): - class EvaluateTaskConfig(Schema): - model_directory = fields.String(required=True, description='Directory of the model', example='/tmp/model/') - - input_config = fields.Nested(nested=ObjectConfiguration, required=True, - description="Input type and configuration.") - - def run(self): - dataset = self.parse_input(self.config.input_config) - - self.model.prepare() - self.model.load_latest(self.config.model_directory) - - values = self.model.evaluate(dataset) - names = self.model.metrics_names - - metrics = {name:value for name,value in zip(names, values)} - - # Display metrics - print("Evaluation results:") - for metric_name in metrics: - print("{}: {}".format(metric_name, metrics[metric_name])) diff --git a/eo-flow/eoflow/tasks/predict.py b/eo-flow/eoflow/tasks/predict.py deleted file mode 100644 index 456049b..0000000 --- a/eo-flow/eoflow/tasks/predict.py +++ /dev/null @@ -1,21 +0,0 @@ -from marshmallow import Schema, fields - -from ..base import BaseTask -from ..base.configuration import ObjectConfiguration - - -class PredictTask(BaseTask): - class PredictTaskConfig(Schema): - model_directory = fields.String(required=True, description='Directory of the model', example='/tmp/model/') - - input_config = fields.Nested(nested=ObjectConfiguration, required=True, - description="Input type and configuration.") - - def run(self): - dataset_fn = self.parse_input(self.config.input_config) - - self.model.prepare() # TODO: find a way to initialize without compiling the model - self.model.load_latest(self.config.model_directory) - - predictions_list = self.model.predict(dataset_fn) - # TODO: something with predictions diff --git a/eo-flow/eoflow/tasks/train.py b/eo-flow/eoflow/tasks/train.py deleted file mode 100644 index 2cd59d7..0000000 --- a/eo-flow/eoflow/tasks/train.py +++ /dev/null @@ -1,61 +0,0 @@ -from marshmallow import Schema, fields - -from ..base import BaseTask -from ..base.configuration import ObjectConfiguration -#https://github.com/sghoshjr/Domain-Adversarial-Neural-Network/blob/master/DANN.py - -class TrainTask(BaseTask): - class TrainTaskConfig(Schema): - num_epochs = fields.Int(required=True, description='Number of epochs used in training', example=50) - iterations_per_epoch = fields.Int(required=True, description='Number of training steps per epoch', example=100) - model_directory = fields.String(required=True, description='Directory of the model output', example='/tmp/model/') - - input_config = fields.Nested(nested=ObjectConfiguration, required=True, description="Input type and configuration.") - - save_steps = fields.Int(missing=100, description="Number of training steps between model checkpoints.") - summary_steps = fields.Int(missing='epoch', description="Number of training steps between recording summaries.") - - def run(self): - dataset = self.parse_input(self.config.input_config) - - self.model.prepare() - - self.model.train( - dataset, - num_epochs=self.config.num_epochs, - iterations_per_epoch=self.config.iterations_per_epoch, - model_directory=self.config.model_directory, - save_steps=self.config.save_steps, - summary_steps=self.config.summary_steps - ) - - -class TrainAndEvaluateTask(BaseTask): - class TrainAndEvaluateTask(Schema): - num_epochs = fields.Int(required=True, description='Number of epochs used in training', example=50) - iterations_per_epoch = fields.Int(required=True, description='Number of training steps per epoch', example=100) - model_directory = fields.String(required=True, description='Directory of the model output', - example='/tmp/model/') - - train_input_config = fields.Nested(nested=ObjectConfiguration, required=True, - description="Input type and configuration for training.") - val_input_config = fields.Nested(nested=ObjectConfiguration, required=True, - description="Input type and configuration for validation.") - - save_steps = fields.Int(missing=100, description="Number of training steps between model checkpoints.") - summary_steps = fields.Int(missing='epoch', description="Number of training steps between recording summaries.") - - def run(self): - train_dataset = self.parse_input(self.config.train_input_config) - val_dataset = self.parse_input(self.config.val_input_config) - - self.model.prepare() - - self.model.train_and_evaluate( - train_dataset, val_dataset, - num_epochs=self.config.num_epochs, - iterations_per_epoch=self.config.iterations_per_epoch, - model_directory=self.config.model_directory, - save_steps=self.config.save_steps, - summary_steps=self.config.summary_steps - ) diff --git a/eo-flow/eoflow/utils/__init__.py b/eo-flow/eoflow/utils/__init__.py deleted file mode 100644 index d663b85..0000000 --- a/eo-flow/eoflow/utils/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .utils import create_dirs, parse_classname, get_common_shape - diff --git a/eo-flow/eoflow/utils/tf_utils.py b/eo-flow/eoflow/utils/tf_utils.py deleted file mode 100644 index b9f3c14..0000000 --- a/eo-flow/eoflow/utils/tf_utils.py +++ /dev/null @@ -1,21 +0,0 @@ -import tensorflow as tf -import io -import matplotlib.pyplot as plt - - -def plot_to_image(figure): - """ Converts the matplotlib plot specified by 'figure' to a PNG image and - returns it. The supplied figure is closed and inaccessible after this call. """ - - # Save the plot to a PNG in memory. - buf = io.BytesIO() - plt.savefig(buf, format='png') - # Closing the figure prevents it from being displayed directly inside - # the notebook. - plt.close(figure) - buf.seek(0) - # Convert PNG buffer to TF image - image = tf.image.decode_png(buf.getvalue(), channels=4) - # Add the batch dimension - image = tf.expand_dims(image, 0) - return image diff --git a/eo-flow/eoflow/utils/utils.py b/eo-flow/eoflow/utils/utils.py deleted file mode 100644 index 749c31a..0000000 --- a/eo-flow/eoflow/utils/utils.py +++ /dev/null @@ -1,34 +0,0 @@ -import os -from pydoc import locate - - -def parse_classname(classname): - return locate(classname) - - -def create_dirs(dirs): - """ - dirs - a list of directories to create if these directories are not found - :param dirs: - :return exit_code: 0:success -1:failed - """ - try: - for dir_ in dirs: - if not os.path.exists(dir_): - os.makedirs(dir_) - return 0 - except Exception as err: - print("Creating directories error: {0}".format(err)) - exit(-1) - - -def get_common_shape(shape1, shape2): - """ Get a common shape that fits both shapes. Dimensions that differ in size are set to None. - Example: [None, 20, 100, 50], [None, 20, 200, 50] -> [None, 20, None, 50] - """ - if len(shape1) != len(shape2): - raise ValueError("Can't compute common shape. Ndims is different.") - - common_shape = [dim1 if dim1==dim2 else None for dim1, dim2 in zip(shape1, shape2)] - - return common_shape diff --git a/eo-flow/examples/exporting_data.ipynb b/eo-flow/examples/exporting_data.ipynb deleted file mode 100644 index 018ecdb..0000000 --- a/eo-flow/examples/exporting_data.ipynb +++ /dev/null @@ -1,196 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exporting data with numpy and h5py\n", - "\n", - "This notebook shows different ways to export the data for eoflow using numpy or h5py." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import numpy as np\n", - "import h5py" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Create temp dir\n", - "os.makedirs('temp')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Method 1: saving arrays using numpy" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's create some numpy arrays to represent our features and labels." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "features = np.random.random(size=(1024, 32, 32, 13))\n", - "labels = np.random.randint(10, size=(1024,))\n", - "\n", - "features.shape, labels.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For numpy use the `np.savez` function to save multiple arrays into a single `.npz` file." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "np.savez('temp/data.npz', features=features, labels=labels)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Numpy reads and writes the whole file at the same time. Therefore the file size should be small to reduce the overhead.\n", - "\n", - "If the dataset size is large (can't fit into memory) it is better to split the dataset into multiple .npz files, or use the hdf5 format." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Method 2: saving arrays using h5py" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's save the same data using the h5py library." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "with h5py.File('temp/data.hdf5', 'w') as file:\n", - " file.create_dataset('features', data=features)\n", - " file.create_dataset('labels', data=labels)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The h5py allows us to create seperate datasets (and groups of datasets) and save the data to it. The format also allows for sequential reading. This means that only part of the data that is needed can be loaded. Therefore the spliting of the dataset into smaller pieces is not needed anymore.\n", - "\n", - "However, if the dataset we want to export is too big to fit into memory we cannot use this method to export the data. That's where the **Method 3** comes in." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Method 3: saving arrays iteratively using h5py" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The h5py allows us to write the data in parts (e.g. row by row). The datasets we create can be indexed and written to similarly to numpy arrays. Let's export a dataset produced from a generator." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def _generate_data(num_examples):\n", - " \"\"\" Generates specified number of examples (example by example).\"\"\"\n", - " \n", - " for i in range(num_examples):\n", - " features = np.random.random(size=(32, 32, 13))\n", - " labels = np.random.randint(10, size=())\n", - " \n", - " yield features, labels" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "with h5py.File('temp/data_gen.hdf5', 'w') as file:\n", - " num_examples = 1024\n", - " \n", - " # Define datasets (total shape)\n", - " features_ds = file.create_dataset('features', (num_examples, 32, 32, 13), dtype=np.float32)\n", - " labels_ds = file.create_dataset('labels', (num_examples,), dtype=np.int32)\n", - " \n", - " # Store the generated data into the datasets\n", - " for i, (features, labels) in enumerate(_generate_data(num_examples)):\n", - " features_ds[i] = features\n", - " labels_ds[i] = labels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**NOTE**: the `data_gen.hdf5` size is smaller, because we specified the dtype of the features to be float32, while the original dtype of the array is float64." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "tf2", - "language": "python", - "name": "tf2" - }, - "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.6.9" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/eo-flow/examples/input.py b/eo-flow/examples/input.py deleted file mode 100644 index 6b4f429..0000000 --- a/eo-flow/examples/input.py +++ /dev/null @@ -1,122 +0,0 @@ -import json - -import numpy as np -import tensorflow as tf -from marshmallow import fields, Schema - -from eolearn.core import FeatureType -from eoflow.base import BaseInput -from eoflow.input.eopatch import eopatch_dataset, EOPatchSegmentationInput -from eoflow.input.operations import extract_subpatches, augment_data, cache_dataset - -_valid_types = [t.value for t in FeatureType] - - -class ExampleInput(BaseInput): - """ A simple example of an Input class. Produces random data. """ - - class _Schema(Schema): - input_shape = fields.List(fields.Int, description="Shape of a single input example.", required=True, example=[784]) - num_classes = fields.Int(description="Number of classes.", required=True, example=10) - - batch_size = fields.Int(description="Number of examples in a batch.", required=True, example=20) - batches_per_epoch = fields.Int(required=True, description='Number of batches in epoch', example=20) - - def _generate_batch(self): - """ Generator that returns random features and labels. """ - - for i in range(self.config.batches_per_epoch): - input_shape = [self.config.batch_size] + self.config.input_shape - input_data = np.random.rand(*input_shape) - - onehot = np.eye(self.config.num_classes) - output_shape = [self.config.batch_size] - classes = np.random.randint(self.config.num_classes, size=output_shape) - labels = onehot[classes] - - yield input_data, labels - - def get_dataset(self): - input_shape = [self.config.batch_size] + self.config.input_shape - output_shape = [self.config.batch_size, self.config.num_classes] - - # Create a tf dataset from a np.array generator - dataset = tf.data.Dataset.from_generator( - self._generate_batch, - (tf.float32, tf.float32), - (tf.TensorShape(input_shape), tf.TensorShape(output_shape)) - ) - - return dataset - - -class EOPatchInputExample(BaseInput): - """ An example input method for EOPatches. Shows feature reading, subpatch extraction, data augmentation, - caching, batching, etc. """ - - # Configuration schema (extended from EOPatchSegmentationInput) - class _Schema(EOPatchSegmentationInput._Schema): - # New fields - patch_size = fields.List(fields.Int, description="Width and height of extracted patches.", required=True, example=[1,2]) - num_subpatches = fields.Int(required=True, description="Number of subpatches extracted by random sampling.", example=5) - - interleave_size = fields.Int(description="Number of eopatches to interleave the subpatches from.", required=True, example=5) - data_augmentation = fields.Bool(missing=False, description="Use data augmentation on images.") - - cache_file = fields.String( - missing=None, description="A path to the file where the dataset will be cached. No caching if not provided.", example='/tmp/data') - - @staticmethod - def _parse_shape(shape): - shape = [None if s < 0 else s for s in shape] - return shape - - def get_dataset(self): - cfg = self.config - print(json.dumps(cfg, indent=4)) - - # Create a tf.data.Dataset from EOPatches - features_data = [ - (cfg.input_feature_type, cfg.input_feature_name, 'features', np.float32, self._parse_shape(cfg.input_feature_shape)), - (cfg.labels_feature_type, cfg.labels_feature_name, 'labels', np.int64, self._parse_shape(cfg.labels_feature_shape)) - ] - dataset = eopatch_dataset(self.config.data_dir, features_data, fill_na=-2) - - # Extract random subpatches - extract_fn = extract_subpatches( - self.config.patch_size, - [('features', self.config.input_feature_axis), - ('labels', self.config.labels_feature_axis)], - random_sampling=True, - num_random_samples=self.config.num_subpatches - ) - # Interleave patches extracted from multiple EOPatches - dataset = dataset.interleave(extract_fn, self.config.interleave_size) - - # Cache the dataset so the patch extraction is done only once - if self.config.cache_file is not None: - dataset = cache_dataset(dataset, self.config.cache_file) - - # Data augmentation - if cfg.data_augmentation: - feature_augmentation = [ - ('features', ['flip_left_right', 'rotate', 'brightness']), - ('labels', ['flip_left_right', 'rotate']) - ] - dataset = dataset.map(augment_data(feature_augmentation)) - - # One-hot encode labels and return tuple - def _prepare_data(data): - features = data['features'] - labels = data['labels'][..., 0] - - labels_oh = tf.one_hot(labels, depth=self.config.num_classes) - - return features, labels_oh - - dataset = dataset.map(_prepare_data) - - # Create batches - dataset = dataset.batch(self.config.batch_size) - - return dataset diff --git a/eo-flow/examples/models.py b/eo-flow/examples/models.py deleted file mode 100644 index 2d4d347..0000000 --- a/eo-flow/examples/models.py +++ /dev/null @@ -1,39 +0,0 @@ -from eoflow.base import BaseModelTraining -import tensorflow as tf - -from marshmallow import Schema, fields - - -class ExampleModel(BaseModelTraining): - """ Example implementation of a model. Builds a fully connected net with a single hidden layer. """ - - class _Schema(Schema): - output_size = fields.Int(required=True, description='Output size of the model', example=10) - hidden_units = fields.Int(missing=512, description='Number of hidden units', example=512) - learning_rate = fields.Float(missing=0.01, description='Learning rate for Adam optimizer', example=0.01) - - def init_model(self): - l1 = tf.keras.layers.Dense(self.config.hidden_units, activation='relu') - l2 = tf.keras.layers.Dense(self.config.output_size, activation='softmax') - - self.net = tf.keras.Sequential([l1, l2]) - - def call(self, inputs, training=False): - x = self.net(inputs) - - return x - - def prepare(self, optimizer=None, loss=None, metrics=None, **kwargs): - """ Prepares the model. Optimizer, loss and metrics are read using the following protocol: - * If an argument is None, the default value is used from the configuration of the model. - * If an argument is a key contained in segmentation specific losses/metrics, those are used. - * Otherwise the argument is passed to `compile` as is. - - """ - optimizer = tf.keras.optimizers.Adam(learning_rate=self.config.learning_rate) - - loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True) - - metrics = tf.keras.metric.CategoricalAccuracy(name='accuracy') - - self.compile(optimizer=optimizer, loss=loss, metrics=[metrics], **kwargs) diff --git a/eo-flow/examples/notebook_classification.ipynb b/eo-flow/examples/notebook_classification.ipynb deleted file mode 100644 index 8f3c83c..0000000 --- a/eo-flow/examples/notebook_classification.ipynb +++ /dev/null @@ -1,662 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Training and evaluation in `eo-flow`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Set up paths to data and check few EOPatches, and get some stats on label distribution" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - } - ], - "source": [ - "import os\n", - "\n", - "from eolearn.core import EOPatch, FeatureType\n", - "import numpy as np\n", - "%pylab inline" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Path to your `EOPatch` folders, split into `train` and `test` sub-folders" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "root_dir = 'path-to-eopatches'" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's check an EOPatch" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "eop = EOPatch.load(os.path.join(root_dir, 'train', 'eopatch-17x11'))" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "EOPatch(\n", - " data: {\n", - " FEATURES: numpy.ndarray(shape=(23, 1010, 999, 9), dtype=float32)\n", - " }\n", - " mask: {}\n", - " scalar: {}\n", - " label: {}\n", - " vector: {}\n", - " data_timeless: {}\n", - " mask_timeless: {\n", - " LULC_RABA: numpy.ndarray(shape=(1010, 999, 1), dtype=uint8)\n", - " }\n", - " scalar_timeless: {}\n", - " label_timeless: {}\n", - " vector_timeless: {}\n", - " meta_info: {}\n", - " bbox: BBox(((540141.9938823571, 5135790.459732607), (550136.7861024287, 5145887.882684642)), crs=EPSG:32633)\n", - " timestamp: [datetime.datetime(2017, 1, 1, 0, 0), ..., datetime.datetime(2017, 12, 19, 0, 0)], length=23\n", - ")" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "eop" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Patches are too big for training. We will have to split them into smaller subpatches." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "

" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10,10))\n", - "plt.imshow(eop.data['FEATURES'][12][...,[0,1,2]] * 2.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10,10))\n", - "plt.imshow(eop.mask_timeless['LULC_RABA'].squeeze(), vmin=0, vmax=8)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.00723397, 0. , 0. , 0. , 0. ,\n", - " 0. , 0. , 0. , 0. , 0. ,\n", - " 0. , 0. , 0. , 0. , 0. ,\n", - " 0. , 0. , 0. , 0. , 0. ,\n", - " 0. , 0. , 0. ])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Check for NaN values in each timeslice\n", - "np.mean(np.isnan(eop.data['FEATURES']), axis=(1,2,3))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "8" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "eop.mask_timeless['LULC_RABA'].max()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "train_data_path = os.path.join(root_dir, 'train')\n", - "val_data_path = os.path.join(root_dir, 'test')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Import `eo-flow` modules" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "import json\n", - "\n", - "from eoflow.models import TFCNModel\n", - "from eoflow.input.eopatch import eopatch_dataset\n", - "from eoflow.input.operations import augment_data, cache_dataset, extract_subpatches\n", - "from eoflow.utils import create_dirs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prepare the input data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create the input pipeline" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "n_classes = 10\n", - "model_directory = \"./tfcn_experiment/\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def build_dataset(dataset_dir, is_train, batch_size=1):\n", - " \"\"\" Creates a tensorflow dataset from EOPatches in a given directory. \"\"\"\n", - " \n", - " # Read features and labels into a tf dataset object using the `eopatch_dataset` method\n", - " features_data = [\n", - " # (feature_type, feature_name, out_feature_name, dtype, feature_shape)\n", - " (FeatureType.DATA, 'FEATURES', 'features', np.float32, [23, None, None, 9]),\n", - " (FeatureType.MASK_TIMELESS, 'LULC_RABA', 'labels', np.int64, [None, None, 1])\n", - " ]\n", - " dataset = eopatch_dataset(dataset_dir, features_data, fill_na=-2)\n", - " \n", - " # Extract random subpatches\n", - " patch_size = (128, 128)\n", - " features_to_extract = [\n", - " # (feature_name, height_and_width_axis)\n", - " ('features', [1,2]),\n", - " ('labels', [0,1])\n", - " ]\n", - " extract_fn = extract_subpatches(\n", - " patch_size,\n", - " features_to_extract,\n", - " random_sampling=True,\n", - " num_random_samples=10\n", - " )\n", - " # Interleave patches extracted from multiple EOPatches\n", - " dataset = dataset.interleave(extract_fn, 5)\n", - " \n", - " # Dataset caching. The sampling is performed only in the first iteration, and the samples cached\n", - " cache_file = os.path.join(model_directory, \"data_train\" if is_train else \"data_val\")\n", - " dataset = dataset.cache()\n", - " \n", - " # Shuffle and data augmentation (if training)\n", - " # For augmentation use flipping (vertical and horizontal) and brightness for the input image\n", - " if is_train:\n", - " # Shuffle samples\n", - " dataset = dataset.shuffle(buffer_size=50)\n", - " \n", - " # Randomly augment the data\n", - " feature_augmentation_cfg = [\n", - " # (feature_name, augmentations_list)\n", - " # Possible augmentations: flip_left_right, flip_up_down, rotate, brightness, contrast\n", - " ('features', ['flip_left_right', 'flip_up_down', 'brightness']),\n", - " ('labels', ['flip_left_right', 'flip_up_down'])\n", - " ]\n", - " dataset = dataset.map(augment_data(feature_augmentation_cfg))\n", - " \n", - " # Prepare the data and return features and labels seperately\n", - " def _prepare_data(data):\n", - " features = data['features']\n", - " labels = data['labels'][...,0]\n", - "\n", - " # One-hot encode the labels\n", - " labels_oh = tf.one_hot(labels, depth=n_classes)\n", - "\n", - " return features, labels_oh\n", - "\n", - " dataset = dataset.map(_prepare_data)\n", - "\n", - " # Create batches\n", - " dataset = dataset.batch(batch_size)\n", - " \n", - " return dataset\n", - " \n", - "# Training dataset\n", - "train_input = build_dataset(train_data_path, True, batch_size=5)\n", - "\n", - "# Validation dataset_fn\n", - "val_input = build_dataset(val_data_path, False, batch_size=5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Initialize the model with configuration" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# Model configuration\n", - "model_cfg = {\n", - " \"learning_rate\": 0.0001,\n", - " \"n_layers\": 3,\n", - " \"n_classes\": n_classes,\n", - " \"keep_prob\": 0.8,\n", - " \"features_root\": 16,\n", - " \"conv_size\": 3,\n", - " \"conv_stride\": 1,\n", - " \"deconv_size\": 2,\n", - " \"add_dropout\": True,\n", - " \"add_batch_norm\": False,\n", - " \"bias_init\": 0.0,\n", - " \"padding\": \"VALID\",\n", - " \"pool_size\": 2,\n", - " \"pool_stride\": 2,\n", - " \"pool_time\": False,\n", - " \"single_encoding_conv\": True,\n", - " \"conv_size_reduce\": 3,\n", - " \"loss\": \"focal_loss\",\n", - " \"metrics\": [\"accuracy\", \"iou\"],\n", - " \"prediction_visualization\": True\n", - "}\n", - " \n", - "# Initialize model with configuration\n", - "model = TFCNModel(model_cfg)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "# Prepare the model (must be run before training)\n", - "model.prepare()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Train the model. We can interrupt the training early using the interrupt command (stop button)." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train for 100 steps\n", - "Epoch 1/10\n", - "100/100 [==============================] - 1141s 11s/step - loss: 1.9883 - accuracy: 0.3747 - mean_iou: 0.0742 - val_loss: 1.4648 - val_accuracy: 0.7144 - val_mean_iou: 0.1793\n", - "Epoch 2/10\n", - "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1063s 11s/step - loss: 1.3959 - accuracy: 0.5477 - mean_iou: 0.1661 - val_loss: 1.0487 - val_accuracy: 0.7133 - val_mean_iou: 0.1790\n", - "Epoch 3/10\n", - "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1065s 11s/step - loss: 1.3004 - accuracy: 0.5893 - mean_iou: 0.2026 - val_loss: 0.9034 - val_accuracy: 0.7193 - val_mean_iou: 0.1884\n", - "Epoch 4/10\n", - "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1062s 11s/step - loss: 1.0737 - accuracy: 0.6093 - mean_iou: 0.2241 - val_loss: 0.8370 - val_accuracy: 0.7399 - val_mean_iou: 0.2314\n", - "Epoch 5/10\n", - "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1069s 11s/step - loss: 1.1915 - accuracy: 0.6359 - mean_iou: 0.2417 - val_loss: 0.7493 - val_accuracy: 0.7463 - val_mean_iou: 0.2429\n", - "Epoch 6/10\n", - "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1067s 11s/step - loss: 0.8633 - accuracy: 0.6667 - mean_iou: 0.2610 - val_loss: 0.6817 - val_accuracy: 0.7784 - val_mean_iou: 0.2881\n", - "Epoch 7/10\n", - "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1067s 11s/step - loss: 0.8731 - accuracy: 0.6838 - mean_iou: 0.2729 - val_loss: 0.7144 - val_accuracy: 0.7676 - val_mean_iou: 0.2992\n", - "Epoch 8/10\n", - "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1069s 11s/step - loss: 0.8290 - accuracy: 0.7005 - mean_iou: 0.2832 - val_loss: 0.6799 - val_accuracy: 0.7781 - val_mean_iou: 0.3094\n", - "Epoch 9/10\n", - "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1069s 11s/step - loss: 0.9021 - accuracy: 0.7144 - mean_iou: 0.2916 - val_loss: 0.6597 - val_accuracy: 0.7797 - val_mean_iou: 0.3091\n", - "Epoch 10/10\n", - "100/4 [==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 1068s 11s/step - loss: 0.8910 - accuracy: 0.7182 - mean_iou: 0.2938 - val_loss: 0.6293 - val_accuracy: 0.7955 - val_mean_iou: 0.3188\n" - ] - } - ], - "source": [ - "# Train the model\n", - "model.train_and_evaluate(\n", - " train_dataset=train_input,\n", - " val_dataset=val_input,\n", - " num_epochs=10,\n", - " iterations_per_epoch=100,\n", - " model_directory=model_directory,\n", - " save_steps=50, \n", - " summary_steps='epoch'\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Predict with model\n", - "\n", - "Use the `predict` function to run the prediction on a dataset." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "predictions = model.predict(val_input)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(20, 60, 60, 10)" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "predictions.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(20, 60, 60)" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "predicted_classes = np.argmax(predictions, axis=3)\n", - "predicted_classes.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "_, (ax1, ax2) = plt.subplots(1,2,figsize=(15,15))\n", - "ax1.imshow(predictions[0][...,2])\n", - "ax2.imshow(predicted_classes[0], vmin=0, vmax=7)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluate the model\n", - "\n", - "For the evaluation use the `evaluate` function. The metrics used for evaluation are defined in the model." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4/4 [==============================] - 3s 638ms/step - loss: 0.6293 - accuracy: 0.7955 - mean_iou: 0.3188\n" - ] - } - ], - "source": [ - "metrics = model.evaluate(val_input)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'loss': 0.6293014883995056, 'accuracy': 0.7954583, 'mean_iou': 0.31882656}" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "{metric_name:metric for metric, metric_name in zip(metrics, model.metrics_names)}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Other methods\n", - "\n", - "EOFlow model inherits from `tf.keras.Model`. All the methods from the Keras models can be called on the model. Above we used the `predict` and `evaluate` methods. Behind the scenes the `train_and_evaluate` methods calls the keras `fit` method. Custom callbacks can be provided to this method." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Other data loaders\n", - "\n", - "This notebook showed how data can be read directly from eopatches. In the `examples` directory, code to create datasets from numpy arrays can be found. Numpy arrays can be used directly for training and testing as per the `Keras` API." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/eo-flow/examples/pretraining.py b/eo-flow/examples/pretraining.py deleted file mode 100644 index e69de29..0000000 diff --git a/eo-flow/examples/remove_file.py b/eo-flow/examples/remove_file.py deleted file mode 100644 index 90184be..0000000 --- a/eo-flow/examples/remove_file.py +++ /dev/null @@ -1,11 +0,0 @@ -import os -import numpy as np -import shutil -path = '/media/DATA/johann/in_season_yield/data/Sentinel2/EOPatch_V2/training/2020/fold_2' -import shutil -files = [os.path.join(path, k) for k in os.listdir(path) if np.any([x in k for x in ['checkpoint']])] -for f in files: - try: - os.remove(f) - except: - pass \ No newline at end of file diff --git a/eo-flow/examples/test_cnns.py b/eo-flow/examples/test_cnns.py deleted file mode 100644 index e23813b..0000000 --- a/eo-flow/examples/test_cnns.py +++ /dev/null @@ -1,105 +0,0 @@ -import eoflow.models.tempnets_task.cnn_tempnets as cnn_tempnets -import tensorflow as tf - -# Model configuration CNNLSTM -import numpy as np -import os -import tensorflow_addons as tfa -######################################################################################################################## -######################################################################################################################## - - -path = '/home/johann/Documents/Syngenta/2020/fold_5/' -x_train = np.load(os.path.join(path, 'training_x_bands.npy')) -y_train = np.load(os.path.join(path, 'training_y.npy')) -x_train = x_train.reshape(756, 27, 10) -x_val = np.load(os.path.join(path, 'val_x_bands.npy')) -x_val = x_val.reshape(190, 27, 10) -y_val = np.load(os.path.join(path, 'val_y.npy')) - - - -# Model configuration CNN -model_cfg_cnn = { - "learning_rate": 10e-5, - "keep_prob" : 0.5, - "nb_conv_filters": 16, - "nb_conv_stacks": 3, # Nb Conv layers - "nb_fc_neurons" : 2048, - "nb_fc_stacks": 1, #Nb FCN layers - "kernel_size" : 1, - "nb_conv_strides" :1, - "kernel_initializer" : 'he_normal', - "batch_norm": True, - "padding": "VALID",#"VALID", CAUSAL works great?! - "kernel_regularizer" : 1e-6, - "final_layer" : 'Flatten', - "loss": "huber", - "enumerate" : True, - "metrics": "r_square" -} - - -model_cnn = cnn_tempnets.TempCNNModel(model_cfg_cnn) -# Prepare the model (must be run before training) -model_cnn.prepare() - -# Train the model -model_cnn.train_and_evaluate( - train_dataset=(x_train, y_train), - val_dataset=(x_val, y_val), - num_epochs=500, - iterations_per_epoch=5, - batch_size = 8, - model_directory='/home/johann/Documents/model' -) - -model_cnn.load_weights('./') -t = model_cnn.predict(x_val) -import matplotlib.pyplot as plt -plt.scatter(t, y_val) -plt.show() -######################################################################################################################## -######################################################################################################################## - -# Model configuration CNN -model_cfg_cnn2d = { - "learning_rate": 10e-5, - "keep_prob" : 0.5, - "nb_conv_filters": 128, - "nb_conv_stacks": 3, # Nb Conv layers - "nb_fc_neurons" : 2048, - "nb_fc_stacks": 1, #Nb FCN layers - "kernel_size" : [1,1], - "nb_conv_strides" : [1,1], - "kernel_initializer" : 'he_normal', - "batch_norm": True, - "padding": "VALID",#"VALID", CAUSAL works great?! - "kernel_regularizer" : 1e-6, - "final_layer" : 'Flatten', - "loss": "huber", - "enumerate" : True, - "metrics": ["mse", "mae"] -} - - - -model_cnn = cnn_tempnets.HistogramCNNModel(model_cfg_cnn2d) -# Prepare the model (must be run before training) -model_cnn.prepare() -model_cnn.build((None, 30, 32, 9)) -model_cnn.summary() -output_file_name_cnnlstm, checkpoint = utils.define_callbacks(path_DL, model_cfg_cnnlstm, prefix = 'cnnlstm_') - - -# Train the model -model_cnn.train_and_evaluate( - train_dataset=train_ds, - val_dataset=val_ds, - num_epochs=500, - iterations_per_epoch=iterations_per_epoch, - model_directory=os.path.join(path_DL, os.path.join(output_file_name_cnnlstm, "model")), - save_steps=10, - summary_steps='epoch', - callbacks=[checkpoint] -) diff --git a/eo-flow/figures/fcn-architecture.png b/eo-flow/figures/fcn-architecture.png deleted file mode 100644 index 843d4cfcc17fcc2a8e3bc3c6958c5bedd072243e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 148643 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
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#RGB\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(np.clip(patch.data['BANDS-S2-L2A'][25][..., [2, 1, 0]]*2.5, 0, 1), vmin=0, vmax=1);\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "id": "d2fac3a6-797f-4288-8833-0aeb33871898", + "metadata": {}, + "outputs": [], + "source": [ + "masking = preprocessing.MaskPixels([\"NDVI\"])\n", + "patch = masking.execute(patch, erosion = 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "id": "ed4fb29a-cfcf-431f-8d53-5b93e566646e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#NDVI\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(patch.data['NDVI'][15].squeeze());\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 224, + "id": "9f9105ab-0a88-4ea8-a1c7-381729118bb7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#LAI Time Series from masked field\n", + "variable = 'NDVI'\n", + "stats_df = preprocessing.get_time_series_profile(patch = patch, \n", + " variable = variable, \n", + " mask_name = 'MASK', \n", + " function = np.nanmean)\n", + "\n", + "plt.plot(patch.timestamp, stats_df[variable])\n", + "plt.xticks(rotation=90)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "id": "f3d7144a-8a97-41f2-bf21-ea44681e9123", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "datetime.datetime(2020, 5, 31, 0, 0)" + ] + }, + "execution_count": 183, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Peak of the season is at 31/05 \n", + "time_argmax = np.nanargmax(stats_df[variable])\n", + "patch.timestamp[time_argmax]" + ] + }, + { + "cell_type": "markdown", + "id": "08b85a00-3c63-4c31-b8b8-400d15777eca", + "metadata": {}, + "source": [ + "## Extract Sentinel-1 data " + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "id": "54ba256b-c0f7-4575-88b4-f0baee1bdf6e", + "metadata": {}, + "outputs": [], + "source": [ + "s1_eopatch = sentinel1.workflow_instructions_S1IW(**kwargs,\n", + " speckle_lee_window = 3,\n", + " orbit_direction = 'ASC',\n", + " backCoeff = 'SIGMA0_ELLIPSOID' ) # you can add period_length in the dictionary to resample" + ] + }, + { + "cell_type": "code", + "execution_count": 215, + "id": "06fc7e92-9993-4035-aa14-f7c31c05701e", + "metadata": {}, + "outputs": [], + "source": [ + "VV = s1_eopatch.data['BANDS-S1-IW'][...,0]\n", + "VH = s1_eopatch.data['BANDS-S1-IW'][...,1]\n", + "RVI = (4*VH)/(VH+VV)\n", + "s1_eopatch.add_feature(FeatureType.DATA, \"RVI\", RVI[..., np.newaxis])\n", + "masking = preprocessing.MaskPixels([ \"RVI\"])\n", + "s1_eopatch = masking.execute(s1_eopatch)" + ] + }, + { + "cell_type": "code", + "execution_count": 216, + "id": "21b2ed83-6fb9-4225-a514-a30ed60217a1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Display RVI from SIGMA0 without any speckle filtering\n", + "s1_eopatch = masking.execute(s1_eopatch)\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(s1_eopatch.data['RVI'][25,].squeeze());\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f83ebeec-9ae7-44f0-b83e-b968dcf63105", + "metadata": {}, + "source": [ + "You can easily download and install OTB https://www.orfeo-toolbox.org/CookBook/Installation.html#linux, which allows you to apply Quegan multitemporal speckle filtering" + ] + }, + { + "cell_type": "code", + "execution_count": 217, + "id": "946a81fc-678e-4560-b8f9-26341e93b38d", + "metadata": {}, + "outputs": [], + "source": [ + "#Can take around 30 seconds\n", + "mutlitemp = cmd_otb.MultitempSpeckleFiltering(otb_path = '/home/s999379/git-repo/OTB-7.4.0-Linux64/bin',\n", + " window = 3)\n", + "s1_eopatch = mutlitemp.execute(s1_eopatch)" + ] + }, + { + "cell_type": "code", + "execution_count": 220, + "id": "ea3b4d6b-adc8-49aa-82e7-cd3f66c74298", + "metadata": {}, + "outputs": [], + "source": [ + "VH = s1_eopatch.data['VH_filtered']\n", + "VV = s1_eopatch.data['VV_filtered']\n", + "RVI_smoothed = (4*VH)/(VH+VV)\n", + "s1_eopatch.add_feature(FeatureType.DATA, \"RVI_smoothed\", RVI_smoothed)\n", + "masking = preprocessing.MaskPixels([\"RVI_smoothed\"])\n", + "s1_eopatch = masking.execute(s1_eopatch)" + ] + }, + { + "cell_type": "code", + "execution_count": 222, + "id": "a4c9c8b1-be3f-4dde-b6c6-f6bd558226ae", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(s1_eopatch.data['RVI_smoothed'][25,].squeeze().squeeze());\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 223, + "id": "eb425046-28fc-44a2-835c-141f70380f4f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#LAI Time Series from masked field\n", + "variable = 'RVI_smoothed'\n", + "stats_df = preprocessing.get_time_series_profile(patch = s1_eopatch, \n", + " variable = variable, \n", + " mask_name = 'MASK', \n", + " function = np.nanmean)\n", + "smoothed_rvi = savgol_filter(stats_df[variable], 5 , 2)\n", + "plt.plot(s1_eopatch.timestamp, smoothed_rvi)\n", + "plt.xticks(rotation=90)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "eo-crops", + "language": "python", + "name": "eo-crops" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb new file mode 100644 index 0000000..92e040e --- /dev/null +++ b/eo-crops/examples/VHRS data.ipynb @@ -0,0 +1,1019 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "decc16fd-a7a9-4c5d-aea6-3558028049ba", + "metadata": {}, + "source": [ + "# Third party commercial data" + ] + }, + { + "cell_type": "markdown", + "id": "7e8ef3e1-fac8-4e7d-b619-1d529d2da6d2", + "metadata": {}, + "source": [ + "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and predfin. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n", + "\n", + "The workflow for agriculture purposes is as follows :\n", + "\n", + "1) Read shapefile that represent you field (boundaries or microplots)\n", + "\n", + "2) Extract Sentinel-2 data and compute averaged NDVI time series to get a summary of the season vegetation dynamic.\n", + "\n", + "3) Get the index of time when NDVI is maximum (season's peak) and add +/- one month to this date to get the time period for VHRS data extraction.\n", + "\n", + "4) Extract VHRS data. If provider is Airbus, you can apply pansharpening algorithms to get the spatial resolution from the panchromatic band.\n", + "\n", + "5) Preprocess and save the data.\n", + "\n", + "6) Optional : intersects pixels with trial microplots polygons to get a value of NDVI for each microplot." + ] + }, + { + "cell_type": "markdown", + "id": "18f4338d-47d3-4680-8949-48dce4d1ec42", + "metadata": {}, + "source": [ + "## Set your working environment" + ] + }, + { + "cell_type": "markdown", + "id": "5ff84548-45ed-4c18-8c26-66c38b4c2f89", + "metadata": {}, + "source": [ + "### Import the packages" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "9f951ed2-adb4-422a-b4c1-e0a0151cc0f9", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import glob\n", + "\n", + "\n", + "import geopandas as gpd\n", + "\n", + "import os\n", + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from importlib import reload\n", + "\n", + "from eocrops.input import utils_sh as utils_sh\n", + "from eocrops.input import sentinel2 as sentinel2\n", + "from eocrops.input import vhrs as vhrs\n", + "from eocrops.tasks import preprocessing as preprocessing" + ] + }, + { + "cell_type": "markdown", + "id": "7325554a-5b71-4c54-89ce-9b087ba054c0", + "metadata": {}, + "source": [ + "### Read your vector file" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "c525df92-c794-4867-b2f1-1021dee5c076", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/s999379/git-repo/eo-crops\n" + ] + } + ], + "source": [ + "dir_path = os.path.dirname(os.getcwd())\n", + "print(dir_path)\n", + "#read microplot data\n", + "shapefile_input = gpd.read_file(os.path.join(dir_path, './examples/layers/POLYGON.shp'))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "39c2e87d-f9ef-4147-8d9f-c415519143ce", + "metadata": {}, + "outputs": [], + "source": [ + "api =''\n", + "client_id =''\n", + "client_secret =''\n", + "config = utils_sh.config_sentinelhub_cred(api, client_id, client_secret)\n", + "#Provide here your planet API key \n", + "config.planet_key = ''" + ] + }, + { + "cell_type": "markdown", + "id": "4f173e0b-e236-4882-bff9-c16f25e76407", + "metadata": {}, + "source": [ + "### Extract S2 data" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "c0dc4fd0-86b7-474a-831d-422062663e0f", + "metadata": {}, + "outputs": [], + "source": [ + "time_period = ('2020-02-01', '2020-10-30')" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "1c34d76b-ab4b-4ed8-989c-7ba450df5337", + "metadata": {}, + "outputs": [], + "source": [ + "patch = sentinel2.workflow_instructions_S2L2A(**kwargs,\n", + " coverage_predicate=0.5,\n", + " interpolation={'interpolate' : True,\n", + " 'period_length' : 8}) # you can add period_length in the dictionary to resample\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "7ac5fbd7-bd82-489c-847f-08012095c0aa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#RGB\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(np.clip(patch.data['BANDS-S2-L2A'][15][..., [2, 1, 0]]*2.5, 0, 1), vmin=0, vmax=1);\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "id": "d2fac3a6-797f-4288-8833-0aeb33871898", + "metadata": {}, + "outputs": [], + "source": [ + "preprocessing = reload(preprocessing)\n", + "#Mask out pixels that are oustide the polygon for visualisation and apply a binary erosion with radius = 1 to keep only pure pixels\n", + "masking = preprocessing.MaskPixels([\"NDVI\"])\n", + "patch = masking.execute(patch, erosion = 1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d31f67f3-7a66-417b-aad8-0f61c39bb441", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 203, + "id": "ed4fb29a-cfcf-431f-8d53-5b93e566646e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#NDVI\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(patch.data['NDVI'][15].squeeze());\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "9f9105ab-0a88-4ea8-a1c7-381729118bb7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#LAI Time Series from masked field\n", + "variable = 'NDVI'\n", + "stats_df = preprocessing.get_time_series_profile(patch = patch, \n", + " variable = variable, \n", + " mask_name = 'MASK', \n", + " function = np.nanmean)\n", + "\n", + "plt.plot(patch.timestamp, stats_df[variable])\n", + "plt.xticks(rotation=90)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "id": "52bd3b0c-e232-4ccf-8155-9a97ab2e9d46", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "datetime.datetime(2020, 3, 28, 0, 0)" + ] + }, + "execution_count": 206, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Peak of the season is at 15/05 \n", + "time_max_index = np.nanargmax(stats_df[variable])\n", + "patch.timestamp[np.nanargmax(stats_df[variable])]" + ] + }, + { + "cell_type": "markdown", + "id": "7876d697-aa75-4db2-947b-d1e6a4d13fae", + "metadata": {}, + "source": [ + "## VHRS data" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "d851a64e-d689-486e-8965-37a7ca9b6926", + "metadata": {}, + "outputs": [], + "source": [ + "#Define the time period\n", + "time_period_vhrs = ('2020-04-15', '2020-06-15')\n", + "#Define the workflow\n", + "download_workflow = vhrs.DownloadVHRSSentinelHub(shapefile=shapefile_input,\n", + " time_stamp = time_period_vhrs,\n", + " config = config,\n", + " maxCloudCoverage=10)" + ] + }, + { + "cell_type": "markdown", + "id": "08b85a00-3c63-4c31-b8b8-400d15777eca", + "metadata": {}, + "source": [ + "### Extract Planetscope data" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "id": "e5a6cfb6-dee3-4f11-aa83-3079f113d67c", + "metadata": {}, + "outputs": [], + "source": [ + "#Define the provider as follows for Planetscope\n", + "provider_planet = ('PLANET', 'PSScene4Band')\n", + "#You can retrieve order id and collection ID on your SH account (https://apps.sentinel-hub.com/dashboard/#/tpdi) instead of doing a request again\n", + "order_id, collection_id = '\t2f900fad-1f5e-4a46-b6da-327012d400e1', '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "dd38636c-58b4-4752-a25a-843c644b259b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"3bd9ec08-a159-4e7d-9e5f-a9ef2f5bb0b8\",\"exp\":1643712934,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"e79e4f71-3649-4c29-af01-83fe1122789d\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n", + "7802e29a-cf4e-49bb-8c31-1977db377682\n", + "1.4870982763449545\n", + "CREATED\n" + ] + } + ], + "source": [ + "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", + "order_id, results = download_workflow.execute_query(provider_planet, name_query='Example Planet')" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "1ebb6d8a-c7aa-4f61-8819-53bbb16eeeef", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "24" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#You can access to all the meta data in results.\n", + "len(results['features'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4fbe6346-4277-4be4-a25a-85f13b060d73", + "metadata": {}, + "outputs": [], + "source": [ + "#Check the status of the order. Image will not be available \n", + "collection_id = download_workflow.confirm_order(order_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "id": "92e56cf3-07cd-417a-ad00-7161f1e0fa6f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"ccfeacfe-22bd-4850-993c-36d404ceb598\",\"exp\":1643717245,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"4127fd5e-26d0-43bf-8280-cceff506c6d4\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n" + ] + }, + { + "data": { + "text/plain": [ + "'DONE'" + ] + }, + "execution_count": 163, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", + "download_workflow.check_status(order_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "id": "8abef4fe-dcf7-46f1-b0ed-2da4ea4db777", + "metadata": {}, + "outputs": [], + "source": [ + "eopatch_planet = download_workflow.get_data(order_id = order_id,\n", + " collection_id = collection_id,\n", + " provider = provider,\n", + " resolution = 3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb721590-2df1-4d97-8603-e2cd4b3ed8eb", + "metadata": {}, + "outputs": [], + "source": [ + "#Reset the download_workflow if you would like to launch new orders. It is a way to prevent to download multiple times the same image and consume credits.\n", + "download_workflow.reset_workflow()" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "id": "bfef88ed-ab7d-4c68-ac12-0e02921ad578", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(np.clip(eopatch_planet['data']['BANDS'][..., [2, 1, 0]][7,], 0, 1));\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "35ec81f8-30b8-4389-880f-9f1dda0e04fe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#LAI Time Series from masked field\n", + "variable = 'NDVI'\n", + "stats_df = preprocessing.get_time_series_profile(patch = eopatch_planet, \n", + " variable = variable, \n", + " mask_name = 'MASK', \n", + " function = np.nanmean)\n", + "\n", + "plt.plot(eopatch_planet.timestamp, stats_df[variable])\n", + "plt.xticks(rotation=90)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "id": "b37209c2-c43f-4ae0-b73c-b26ae34d7f36", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "time_peak = np.nanargmax(stats_df[variable])\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(eopatch_planet.data['NDVI'][time_peak,].astype(float))\n", + "plt.colorbar()\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4ab4a072-ba7b-44bf-ae99-61b5430ac322", + "metadata": {}, + "source": [ + "If you would like to save the EOPatch, you can \n", + "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n", + "- save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask" + ] + }, + { + "cell_type": "markdown", + "id": "de10acec-05ac-456f-bc58-dc7470807db4", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Extract AIRBUS SPOT data" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "id": "0af89767-d810-4f42-bad0-f9c9ec97de3a", + "metadata": {}, + "outputs": [], + "source": [ + "#Define the provider as follows for Planetscope\n", + "provider_spot = ('AIRBUS', 'SPOT')\n", + "#can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", + "order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "46d557aa-1f4f-4e7b-8ac2-f131402728a2", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"6bb838ab-4015-4091-8522-193491e5823f\",\"exp\":1643712725,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"40ae4dbc-b655-454e-bdf3-13202b360bf6\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n", + "cbd4ae1e-e9a4-4838-add5-7ac99a1f2bd6\n", + "2.5\n", + "CREATED\n" + ] + } + ], + "source": [ + "#Define the workflow to get your order_id and meta data. \n", + "order_id_spot, results_spot = download_workflow.execute_query(provider_spot, name_query='example spot')" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "bd0f45f3-c648-4786-a207-719cd6e62f87", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RUNNING\n" + ] + } + ], + "source": [ + "collection_id_spot = download_workflow.confirm_order(order_id_spot)" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "id": "1887644a-1dc8-4dca-95e8-8da5608ba4c7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"41f1d0ad-5272-4409-a1d7-945c4760846f\",\"exp\":1643717125,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"2209ace6-eaa2-497d-aa6c-1f2a72db3a5d\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n" + ] + }, + { + "data": { + "text/plain": [ + "'RUNNING'" + ] + }, + "execution_count": 161, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", + "download_workflow.check_status(order_id_spot)" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "f4d356f1-4e7a-48c3-8d27-f74616602719", + "metadata": {}, + "outputs": [], + "source": [ + "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + "eopatch_spot = download_workflow.get_data(order_id = order_id_spot,\n", + " collection_id = collection_id_spot,\n", + " provider = provider_spot,\n", + " resolution = 1.5,\n", + " pansharpen = True,\n", + " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82966531-5930-410f-958e-f7ae4bdf1ad6", + "metadata": {}, + "outputs": [], + "source": [ + "#Reset the download_workflow method if you would like to execute new queries. \n", + "# t is a way to prevent to download multiple times the same image and consume credits for nothing.\n", + "download_workflow.reset_workflow()" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "ca6d8434-36f3-425a-ba22-f4f664affd52", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[datetime.datetime(2020, 4, 15, 10, 55, 52, 100000),\n", + " datetime.datetime(2020, 5, 18, 10, 52, 42, 100000),\n", + " datetime.datetime(2020, 6, 6, 10, 54, 50, 200000)]" + ] + }, + "execution_count": 168, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eopatch_spot.timestamp " + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "id": "a00fd087-3d60-4206-9edc-456a92da30b8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(np.clip(eopatch_spot['data']['BANDS'][..., [2, 1, 0]][1,], 0, 1));\n", + "plt.axis(False);\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "id": "d589e21b-71a7-4076-a70c-dfe5835e02e1", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASYAAAEiCAYAAABUVX/MAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACM30lEQVR4nO39ebRsaXrWB/7e79tTxBnvkFNlDZmlqpJKI5JlYYFZgIRwmdW27O62u6Q23eqlRZu2JWMhY4SR1UIg0FCVaQFCdokGybDksuxuuwu7jIRBBmGX7ZKEGUqiGk3UPGTmvWeKiD1839t/fMPeEffcrMysvJnn3tzPWnfdc+LEsGPYT7zD8z6vqCozZsyYcZVgXu0DmDFjxoxdzMQ0Y8aMK4eZmGbMmHHlMBPTjBkzrhxmYpoxY8aVw0xMM2bMuHKYiWnGjBkvCCLyDhH5sIj8qoh81yV/f6OI/JyI/D0R+Qci8vvi5aWI/KSI/EMR+RUR+WOf67FmYpoxY8bnhIhY4EeBfxH4YuCbROSLd6723cBPq+pXAu8E/kK8/F8DalX9MuCfAf5NEXni+R5vJqYZM2a8EHwN8Kuq+uuq2gHvBb5x5zoKHMafj4BPTC7fE5ECWAAdcPp8DzYT04wZM14IHgc+Ovn9Y/GyKb4X+DdE5GPA+4Fvj5f/l8AF8EngI8C7VPW553uw4mU44BkzZlwR/Au/e0+ffc696Nv94j9oPwRsJhe9R1Xf8yLv5puAn1DVd4vI1wJ/RUS+lBBtOeB1wDXg50Xkv1fVX7/bHc3ENGPGA4RnnnP8Lz/z+hd9u/KxX9uo6lc/z1U+Drxh8vvr42VTfCvwDgBV/YCINMBN4JuBv66qPfAZEfkfga8G7kpMcyo3Y8YDBcWpf9H/XgA+CLxVRJ4UkYpQ3H7fznU+Anw9gIi8HWiAz8bLvy5evgf8c8A/fr4Hm4lpxowHCAp49EX/+5z3qzoA3wb8DPArhO7bh0Tk+0TkX45X+07gD4jI3wf+M+BbNNiX/CiwLyIfIhDcX1bVf/B8jyez7cmMGQ8Ovuorav35v/7oi77d/us+8oufI5V7RTHXmGbMeICgKO4BCDZmYpox4wHDC0nNrjpmYpox4wGCAm4mphkzZlw1PAgR09yVmzFjxpXDHDHNmPEAQWEufs+YMePq4QXJJa84ZmKaMeMBgqJz8XvGjBlXDAru/uelmZhmzHiQEEZS7n/MxDRjxgMFwSGv9kF83piJacaMBwgK+DmVmzFjxlXDHDHNmDHjSiGMpMzENGPGjCsGrzMxzZgx4wphjphmzJhx5aAI7gEYgZ2JacaMBwxzKjdjxowrhTmVmzFjxhWE4HRO5WbMmHGFEEZS7n9iuv+fwYwZMx44zBHTjBkPGOYa04wZM64UVOca04wZM64g/BwxzZgx4yohyAXmiGnGjBlXCnMqN2PGjCuGB0UuMBPTjBkPGNw8kjJjxoyrhHmId8aMGVcSfq4xzZgx4yph7srNmDHjykGRucY0Y8aMq4e5KzdjxowrBVVmHdOMGTOuGmQeSZkxY8bVgvJgREz3/zOYMWPGFhzmRf97IRCRd4jIh0XkV0Xkuy75+xtF5OdE5O+JyD8Qkd83+duXi8gHRORDIvIPRaR5vseaI6YZM2Z8ToiIBX4U+AbgY8AHReR9qvrLk6t9N/DTqvpjIvLFwPuBJ0SkAP4q8PtV9e+LyA2gf77Hm4lpxowHCIrcqy0pXwP8qqr+OoCIvBf4RmBKTAocxp+PgE/En38v8A9U9e8DqOqzn+vBZmKaMeMBwz0SWD4OfHTy+8eA37pzne8FflZEvh3YA35PvPxtgIrIzwAPAe9V1R96vgebiWnGjAcIykseSbkpIr8w+f09qvqeF3kf3wT8hKq+W0S+FvgrIvKlBJ7554F/FlgBf1NEflFV/+bd7mgmphkzHijIS/X8fkZVv/p5/v5x4A2T318fL5viW4F3AKjqB2KB+yYhuvo7qvoMgIi8H/gq4K7ENHflZsx4gJAiphf77wXgg8BbReRJEamAdwLv27nOR4CvBxCRtwMN8FngZ4AvE5FlLIT/TrZrU3dgjphmzHjAcC+2pKjqICLfRiAZC/wlVf2QiHwf8Auq+j7gO4EfF5HvIHDkt6iqArdE5CkCuSnwflX9b5/v8WZimjHjAYKq3DPbE1V9P0ECML3seyY//zLw2+9y279KkAy8IMzENGPGA4YHQfk9E9OMGQ8Qguf3PCs3Y8Yd8J96qwL8YtvxH3/md/Pz//TNmH94wD/+E99x/58xVx7zlpQZMy7FP/vH/x80tz3VyUB51vHmixY5uwV/4tU+sgcfoSt3//P/TEwzXlZ82R9+WksLQyOYwaKmoqgspi55x9v/mMr5CkTQZYMua37ml/7E/X8WXTHM1rozZkzwxf/B0yoVuEYQB2AoSsFXBltbitpiyvCR00WJawp+1zt+UF1lGBbC5pqhOxI+9INzyvdScQ9n5V5RzMQ042XB2//406olyAAyKOVKAej2DewZqguP6Ry26/FHS/qDCrcwDI3B1UK/ELojYdiDL/jhp9RXilaKLgf+6f/1u+7/M+0VxGytO2MG8JYfeko5APFgEWwHza2B7tCyPjD4ChDD4lMKJ2fo8ZJhaen3DEMjuAb6PaE7VFwDvlKwihaeonZ89X/3H2hTDAAYUf7O7/nhmajugmCte/+/PDMxzfi88MSff5eaUsALogDKsBT6fUu3bxj2wBcwNOCagrIs0cLgK8FVgq/Al4JaME7QXoFwORUUpeOgbgFY9SWqwm/72T+qe2XHQbWhMJ6jcs2Pf/V/ev+fjS8T5lRuxmsWT/y5dytHPUiBOEElRDq+hPXDMDSW/gC6Yw9W6fcNw6Jm/8brQYR+KQyLUI9ydSAvlRB1GQfq4re/E567WFJYTztYSuuwxgMweBtOwhKe+pVv0Ov2HCuKU+Fb3vaB+//sfA1jJqYZLw3XuvyjCqhVfB1IqF0I7UMgy4GiHhABd91w+pjl/ImSxacM4sCXhNStVMQDGgjK14qWoUY1tAUXKlR1SOWquuNas+Z6fcFxuaY2Aw9XpzxanHBsV5QyvBqvxpVBKH7PNaYZr1Foa8EJxgmYSCSlx9QOY5WidJTlsKVB9guhXfRs3BLbCr4At/BopfFOAYGYE4JVTKEsFh3XlmtqO/DI8pTXN7d5uDrl2K44MBsa02FRShkoxWHx/A+/+VY98w0bX1HKQCWO3/fmf/SaiKLuxRDvK42ZmGa8aDz5I+9WKQ0yBFmAWtBSMbWjqBxVNbCoeowozodvbxGlsg7XCJ/+7ALxgq8UbTxSO5BwHVVBncBgQMAWjsePTnhkcYZBuV5dcLM859HihOv2HICNljjA4CmDTgGAEgeRtAyev/EbX6QWxSGc+QWdWt75ll+4/8/iCWaB5YzXJJ78s+9WlJGUBHztkeVAs+yoy4GqcFTW4TVoagZnsDG7KI1HS8V5RSsPhSJWEQFjwx0OWNQrGKWue57Yf47r5QXnrgZCRGDEY8Vz4WtuuyWVOKz1WPWkgKGK0ZNF8/G7OLIRoquB//rXvkI3WnLmFvyBL/z5+/+MnlO5Ga81ZFJS8AIY0Eox+z2Hh2uOl2sK4zEoHqF3ls5ZBm/oneC8oCpQetRoIKXCg4ZCtykVUIwK3ocUcVn1PFKdsrQta1dyOjSU4rhuL9gzLWd+wZlfcGxX+Ti9Gox4ShloJqTUYXFq8+8lDiuKJxDVn/vHX6d7pqUUxyf6Y57pD/jhr/gv7juymod4Z7xm8OSPvDuc4RpSNwrFG0UWjsPDNW84vs1D9Tm9GjauZONKrHi8BkLadCWrvsJ7wS7G2pOq4AcBDaRlracoXEjNrGdR9pTi8Gro1bJ2Jeem5sw3HPsKgAOz5the0EifUzkb07om/u5VQEPa5zH0WtCYngqHweNMvEx6GtNzYDacm4bv/N/+dfUq9GppfcFZ3/Der33PlT3zZx3TjNcU1GrI2wpFG4ddDBjjOdjb8AXXnuXtB5/iZnHOc8Men+4Oea5bUhlDYwfqouLMelZdiXOGwob6UzdYhsEiElIPaz11OVAWkVyM56BquTUsKcVhRDku11wrV5TicAh7pg1kIj2lDDltMzKmcKEw7jGiGPH0ajHeZyJrYupz5huM+Hh7pfeWC1dzPlR0vmDwhsHb3ZfmymFO5Wa8JvDEX3iXmj58C7tSKZc9D107w3lDYTxFPpnD/2tXct7XVGZgv2w5rNZcq0tO2gWnXagTtX2cmfOSm3HWepqqZ7/qKI2jMJ7KDDzT7bNnOwrj2LctS9Nh8fQa7sPg87E68Vg8qMGKo1cD4inFUzGwF+UEtyOJlRJqUg7B4Fn5mg2BvCBEH8EXWzCiFMbxr/zdf0s7X9A7S+uKK6VEn2flZjzweNuffFr7Iw8S0iA1gFWaRcdDiwvO+pqLruJ2t+BTbdhzeDIsOOkaLvoKXwj7ZcvC9ng1uevWO8PgDT527IwoxnqqYmBZ9uwVHU3RU4hnUMNJ10AFe3SUhcOIZ6Mlm6HkwGywVjnzC/ZMy7FZ0Zgei7LR9PEeKPGUolgJGzhSircURyNg2PBx03Pb7cWivaE2A/s2qM5LX+BUGLyli8LOIRLWP/83/n09rDc0tmfwlvf9jj//qjLDXGOa8cDirX/6KcUAnlBPKkMaJ41jWfVcq0OxuR0KnDd0vmDjyxxZqArOG1ZDxeAtG1ewGUraPkQazplQ4JbQkbPWU9oQfRXGUZmBUjyDC2lU7y2m8NQx0gk1nxKLcmDXXPgQiZUykAKojZY5vfPi8EBJcNIvY3S3Z4SlWGDg2Kx4btjnzDc5DSyMp9YBrwanNqaD4V8hnrJ0LIuO1y1OMeK5GGr+9Q/8m7oZSrqY9l2vV/zUP/fjrwhbzHKBGQ8s3vJDT6lMPttaKtigN6qXPYuyZ2F7qFd4hMoMOZ2rzUBlHKV1eISNK+l8wXooWfUl3RBISVVQJZOStR5rPB6h8wWVd2DATGpGpThKE1Kx1pesXEVt+kyIG19ymz3OWAShpfhQ2JY7d61ZlE4NG/XUolgJ9apeC271eyxth5+kRT5GS9PL6mJgv2h5uDnjjfVzbHzJLbNk4XraomBQQ+sK9oqWb/3gt+hJ30SiNvzs7/qP7hl7zDWmGQ8c3vpnQqSUNEoh73GUzcBi0XG02HBQtRiUh+szHq7PaH2Ru2DWeA7KDad9wxBTtSAXsKNcIEIEjFGM0TDj5g3tUGT9U2N7KhMikv2iozZD7M4ZVq5i5StK51iaMB7T+4Iz3wDQSM/14pzrtqeZFMVTNcoh9Bg+5UrO/EAT1eYbLXi238s1ptSNa30xSeFC5LQsOm7W57yxfo6bxSnPDIfUkTgXtsOr0NoSI55BbUz1DFDw+/7Ov6OFeIx4VkP18hGVzjWmGQ8YvuCHngplpI0gHlylqFFs7TjYX/PQ3gXXYwrnER6rbvPW+lM8O+zzzHDIylcYlH3bclyt6bylEJ+jjFVfIqKICBBFlcYjovhYe0owMqZSe0WHU+H2sOR0WNBrSB2dSvzfsDQhwknR01Gx5tHyhGOzoRFHGYnJxUp7Hwnuo/0NGtNxYDZsfEnrS9auxMbHb10gpY0rWA0VrSswotR2YGF7DosNpThO3B7PDXtZBGojBRYm1LKMKgvbY0VZu5LOWbwaBn15u3zzMoIZDxyGY4c9N6Bhyt+XIY1rmp5H9s/vUGA3EvQ+FLDREMG0WuS2/tqV4aQeQo1IVZA4emKMYm04hRIJGQlEtCh66mKgEJcFmhu3T+u2P66pnnVU7XOjvsjRSimOXi0ukk8YQwlRmUVBQ4pYiueh4jRomcSzoaQ2PYdFi0e2ZAKdLyJ5WhZFz37Zshejok92R9welhQSuoalcfGxLUUkqFIchVpKCXW0tZRsXMF5X+fn/3JhjphmPDB401/+QQWDXyh+ESIlao+tHftNy2G1YS92qM76hgsXxI0bLfFqOHMN566mV0ttBvaKlgtX8Vy75LRtWPcF3huM8RgTCKiw4aQNSxqhsI66GCitC+pxNTl9WvUV674Egr5JJgX2dV8yeMu1esVRuWa/aDmy6zgT19BLSOdKPDYJMEVBPY/ai9jBs5yJZ2m6cOxDHSKaqF0yhFm/wmw4LDc83JxRm4GVrzjrG251C57ce5bHqpP4uhS0vsyvb6+W3lucMdS+x4in84E8K9u/bO/jXPye8UDgib/wLtXaEyZmFRqHrRxV3bPXdCEiqTfhW95VXLiaZ9s91kOZC8ILG2o8rS8YIjFZPL0POp92KBhcqMtYUYzxVEUYB1HAeYOoUJoggvQqdGpjt8/SO8uqK+mGIkRboljjcT6VxuFiqGiKnr14LEFIWdCpxYinYWC8dih+W1EOjABC5xSnhkZ6lqbjjIZBTS54G0JNKQwSrzgq1jg1rDWQT2NDIdyIx8corTaBcHIx2oSUDgO1DmOkyBwx7WImptcwnvixREqAEyg8pnIsly1Hiw0PL8/ofEERo4y1iydhEb7xKzNO8ptJTWZhDBgyqTgfThQRxZpAKlaUwoSRFYxHVLIBXOuCpKD3JpBPTKGcCxGX2FAo93GmbhCljykfhBM91Xg8Jhbmw2OG7tw2EWxUOdOKz7pDznxD6wvWrsz3F55fuL/Oh7GY3geiLcVR24HCuDw64xi7gDblxbGWFMg81JYMmm87YxszMb1G8eb3fr9qUwTJdVR1Y5WqGjhoWm4uznnd4oSLoab1BSbqixa252Z9nus7jempZcgF7jNCSld6T+dCXUZihFMVLkc8d6urtEPBOsoK0m0F8D6QkOo4vpI6fE6FzVCwiTWtVPx1KpEkQq3JIfRqsoapxPOsgzOt+Gh/Iw/u3u4XnPX1VrSUIrmzLnT9DsoN+7YNNTG6/HxWcX4PRjKbIumvUhF9v2xf1ohpVn7PuG/xpv/kh9Uebn94pXHUex3X9lc8vDzj0cUZD1dnrGybO2GHxYbHqhNeXz3Lytd0GohnWmz+tB5wMYTieOcthfE00TCutG7Lo8mrBPKIv6sKF13JalMz9BaRYDhnjAZBZtQ/uSFdHsjJOcPZug6eT2ZgYTuO7JpSXBZeejHZh+nArLEojfRcaMVnh0M+0V/j4+01TvoFF0PFaqgy+VbGbUWENhbFsS2N6XFi8mtw5qJcIRJ2Yze4qEB3USmeOoK1GTi2Pa1/eU/DuSs3477DW7//KeUmuLWFwSDLASmVo6MVD++fc1yv2bMdVexwPV7fojSOW30YpF2alkocKyKxYFhKSykDB3aDFWU1FHnYtbRBbGnFZ4+m9VCGulNM1SAUvkWUwVmGPnbwjMeYqD/ygneCby0IeCfYSFqqhqELtymNZ1n0edDXxlrTRip6tcFULvoxdWI58wtuuyVnrsGrUMQUtTKOzield7isNI7DesN+0bJnW6z4TDalcZy7OpMyBdR2wEV/pOnabiuapQZHxZpn+v2X7w3WucY04z5Ef91DPNmpHXsHG6pi4JH9c67XKxa2z233oAkK0UBqg698zaf6IzZa0quNA67B/+jMNbRuJKXCjKmMEQ0pi3BHGiei1DbUaqzxGOtRBWs11JD6SFaDiUZQ4HuLGJCJY6VMUkSnho0WlL4MEY0daExPqY4mCjI3WnLhq2iFEiI/U7QsbIcRz3kfSKayjr2iza/Lnu2y+0Dri+BWEB93rwhR1NKE+1i5mjZGTI0JbgaHbLDiuVZc5Ejr5cLclZtx3+FN7/nhMP/mgv8Rse3elAPLqKwuzehnBKHtnU4cE21pN1rmE27jS05Y0GuwCAlRRoiOBm9i6TmSyaT+kTprUzJpXYGNrpXeG1Sh7wr6TVyhMvUEj/+MUcpyoCgch8sN15uwpCAVooEQrYkLNidmiOMolp6Cla85dw0rF5yZUkexFEdtHK0P2qN927JftHmo12FyhJS6kdfLC64VZzTRwSC9dkEz5fJjp/GaRvo4z/fyFr9nYppxX+ALv+9p7fc9UocPrBZhcUC57DhoWo7qDY0dt4vUJkRNpbh80iby8GrogVYLzoc6iy29GtqY+lQmRD+9WIbYeUsdLo/BG4ctQxo0pK5bHFuBEGk5oB8sbjDB/9sEq12x4X9jlaIICw+WVY+IcmOx4ka94rhc5egkdc4g2KOkpQUbLXl22OfT/RG3hmVWe9dmyP8K41m7MkaEY5SXxlQuhjr8HaGPeqveF6GeFUnxwG7icYzRo8VvvZ7f86V/7WVjkrn4PeO+wNv+1FMqXijPDD0+b7ktFgPHB2tuLFYcV2HMpFdDTZyoNwNWPKf9EiATVUo9Nr5k7as8GpKQajGVCbohE7VAmPRN7llGI7jOB43TeggapW6wFDb8TSEM+6YxlUhKxirGOopiNJWrYh1rv2w5LNYsTZc1ROF5hePFwEaDV/htt8eJW4YunkqQL0SP8FIcjQlOlicscnF65SpOhyYUviPqSOhehZWvYnor+TU7sBuWZqxHQYjgElm6e7DOW2dimnGV8dY/85T6BopzkAGQMGIiTdAq3Vxe8FB9zl7R8ly3x6AGp30+OT2SldzpRDVRk9P6IuiNYj3JRJ2QFUcRf/ZxBMSn+lJE0j95FdaEubHBmbi4IIzb9n0RXQgAu01KVeWoy56mHCiNDwX2KGVIx5q2oYyGbyZ36EIa1uQOWm0GauI4iwkF8zrWo3prcYTIrvUlJ/2CzlmaOCuXNEhD1DddaM2gBoNyUG5CtxJDSUiT87BzJConLz+JzF25GVcWX/pHnlY5DDqgtCHXHbggC1j0LOsuzHsVwcgNggtAqsukD3eKkhKx9GpZ+WorjSl29DopbUlygF3rkMq4bG/SO0sfSQmCCtw5gxsM6iVsUDEeMUExXhSBiJoymMrVdsgdxCrWyMbHN3iUNj6nFDlNh31L46gZMlHYOPGfkJ7/gBmfqw2RUkrHBj86EAzxsSozMPhRPmCtp5JQGG8kvN4dlkpe5iHeuSs346riK//gU+qvhfVKNp3wC480jrIeaKqepgi+SSnCyOMXUbuTkEhr5as8C3fhak6irUllJ7NnETZGSD62yqdF72Ey/5bqTtYoqh6NpORj580YRQqHtRpdCcLgbxGHf2s78FBzzkGx4WxoWNg+E2iKlqYk1avd+pcIN0Uw0yJ0VnDrSJp7tuW4WLGapLDJhsWr4AnPqTBBaT5NJxPh7W4KvkyE+fliTuVmXEm018OWWwi+Smnj7f7BhkUkpUXRU8YxilIcBzFy2iti1ylGD6U4Wl/kk7F1YVxj48o8qhKuP+4zq0yIJlK0VIintsPYnYvXLYzPNZreGrohDPo6B2KUqhyoy56qcHHQV7bGWYwoR+Wah8szgOgDbjkZQl1s2plLz8lP0jsbd9MlpDm33hdggr/TyldR+T4W0Yc4A9hHqUTnLed9jfOGRdFzrVrzSH3KzfKMpelopOPQbjIpudylNLz8pm73rvgtIu8AfoRgAvoXVfUHdv7+RuAngeN4ne9S1ffv/P2Xge9V1Xc932PNxPQA4YkffZdKL1S1QYZASkjswtWevbpjr+qyiBDG4utD1RkuNvdt9FDqY7oTTNJCPamPJ/fuGEXwFjLZFcCL5pMuuQ2EEzxY7aaUp0wRlwlRR11CVQxYo1TFQBXV4j6ud0rOAxKjsrTOCcjX6wkRmY3uBVP3SoPmjt00QjLiaWSgx2biaiYRT+sLzl3N7X6R7YJTJNg7y3ooMaIcVBsOizU3y7O8LXjPtPl13vgyPkYYMO5eZj8muDcRk4hY4EeBbwA+BnxQRN6nqr88udp3Az+tqj8mIl8MvB94YvL3p4D/7oU83kxMDwi+8PueVh4CM8Rv41rxFfhScQtPtd+xiDWZwoS5t0AiIV1Z2i5HFOPoRDhJEykNOn7D7w6eGvFbH6Zg4pZcILcjgyHKBMLtRpKxoizKYHuS7HlT/SpFWylKS6LOLkY1uRaWBJaEln2OTmIEmLC07VaBvBSXvcOzbitGVGk/3tpVbOIGmKk3VIrmFkXPQTkKMQH2TMt1s2EVNU29hDpXl8SpL3NX7h4KLL8G+FVV/XUAEXkv8I2ECGj68Ifx5yPgE+kPIvKvAL8BXLyQB5uJ6QHAl/+hp9U/rBQnhmIlqAHXwHDokMVAWQ8c7m1YFH2c+/Jhsj9949/lW9tHh8jWFZGwtgWSQBxwHTtyCYMfp/0HsVvklKIfj6A6Rl5GlLoYckG7isSU7j/JElL6BORjqq2PtirjmEiqcZl4H1NySkTW+hJP6B6a2DFL123VsPFliHLUZkJtXRg0TvW4lF7uRfO40oQUcqNlUMjTZccBF8nIq7kn0VLaavwScFNEfmHy+3tU9T2T3x8HPjr5/WPAb925j+8FflZEvh3YA34PgIjsA3+UEG39ey/kYGZius/xpX/kaR2Ow8/1LcF00B2B2/OUxxuOD9aU1rEsexrb59pMIT4quc2lxOQw4W8xZZnWkGDqOnnnWTBouF3S+xTGby2KNKI4yOSRkGfqIilVZmC/6NizLSZa0g4a6jvptjYqx6ct+KQlms6nhcf1l9Z0wk45iYSRCto2+4oHCxSbpRHOm7BUwRus8dSlsiz73OWsYy3pzC34ONfyht+kmt/4QFj3Ci9RLvCMqn715/nQ3wT8hKq+W0S+FvgrIvKlBMJ6WlXP5QXKI2Ziuo/x5I+8W+V1gBdMD6YPkxq+Vtjveej4nMf3T0IB2vjctSqMy52zUCCWbImbfYwmLf4pKaWZtxQtpJPd62h1C7BxRa67FOJpzbb6OWG8H6U0LiwgiKS0sD3HxYqHq1MsyolbcDIswu1inWthe/bTlL8a+klUlzphdtKpAzJ5WXwesm3VcBZHa1a+YuNLzoaG075hEy1KpnYtqnFRZ5zzOyg3wUDOrnNt6sQt+GR3xEl1whuqZzH4PDTc+pKlabfqWC8HlHvWlfs48IbJ76+Pl03xrcA7AFT1AyLSADcJkdX/UUR+iFAY9yKyUdU/f7cHm4npPsUTP/ou1X0PvWAvLGYIfmSuhmFPWR60PLI842Z9wflQUUrYXrI0IdVIxWu/0xKHsSA+nuBhjGMaHaWIpXVhe0jyxE4duY0rc0cuX1/tRCIQ0qZCPJUN65/2ii7P6sG2s2MpQxyVKfP8WW3CGqmRlIKY0aTREhln0wBIrX0kpHBitrRN6edzV9P5gtvdgtO+oXcWa3w2tvMqQVMlsCh7rjcXPLo4Y98Gr3BHGE0JSvEF18qL4GgQ5/Dy8xPd2iL88uCedeU+CLxVRJ4kENI7gW/euc5HgK8HfkJE3g40wGdV9XfkoxP5XuD8+UgJZmK6byFOYBMJpPF0C+hugBx2HB2teGjvAiPKc92Szllu1Cser2+FbSL5JB4tOVotxtpMrDuFln4ginJShA61npHMUj0p/B4IKq0Pt8bH9UVmy9Q/rWU6KDfUkcyuFascQWTCUOFkWNLbdqvLl0Zkgq1JHDkhSAZqM+TidiKl5CTZmJBSWcb2fy+W3gdXynMXhnLLKHGo3BDdNEPnzfnwPKxRmmLgerPKWiqvwq1+GR+/C+vMbcdDxRmN6WKxPTwHRxhhWTEay11lqOogIt8G/AxBCvCXVPVDIvJ9wC+o6vuA7wR+XES+gxC8fYvqS6t4zcR0n+GJH3uXqlXECuIENYpWiiwH9g/XvO7wlMNqgxGlc5bTrsF5w7VqPZnP2h7VSGmRg9yJS+3wNEOWW/FROuDSfJlxNEUPA1kCANFGNzs/GjoX5ARpUNebcZB1UJvdbpNdSIqK2tjNWqW1SLFLNo2m+hiJheJ3vM6Ov3f+XzyooY4K7FBLSx3IcrRxMaEA39ghL+zsnc0F+NI6FkVPU/TZkSBJClLN68iuogVKWKR5oZYLXwdCcjV/4sv+v/cktHmJxe8XcL/6foIEYHrZ90x+/mXgt3+O+/jeF/JYMzHdR3jTe35Yl49esFlV6GkFDrDBfXL/cM1jB2c8vjxhr2gZ1HLaN0FfJDoKGaO1a0pfpkjR0hD1SkBUMIeIZvCGliLbwpYyZM8lbwViC92L5PtKiwWAoIOKadECjXNpods2eHvHFH5pwrpvPymYNhP9UUqZkidSSTCOS/YsAGV0EwjXN/S+xCEc2xUP2VOec/ucuEWQQ/iQ6rXeMmgTC/jbjQGNIs8kUi2SKFMta1+NBnnRVG/PdPRqOfUlG604d012bLhXmJXfM15RmL0+jGNYxRuFArTyLPZbHjk450Zzkb2oU8SRtD5p9VI6iVpfbE22l+JyJy4RVoqIUtq0IpChR6ItSCCWQU04QSfDuUMUOTo/jqQkD+8ypnEL21OZEJH46B/extZ8Up4f2A0u1oSA7BzgNXS42kBH0T8pmsHFjb0QyC2nbFHz1KulrMJ1L/o6kkWdo7uNK7O1bno+EGpChfEsyp69oguRImFJgxGfFxRM0avls2kZqPj8pXA6NPfkM6I6E9OMVxBP/Ni7VBeW8/MmpD1W0UIp9ztuHlzw+r3bYYg1WnYs6YLvtAnpyrVixdJ0+QRP5ASjadsUZVw+kE72caYsdNlShy+lgXnKPs7cJdvcIdatNJLSoug5rtbcrM+z6RqEMZalaXlmOMj+Twd2w4FdA3CbJT6mYJUMdATRZ6ot7RdtJi2L0hPm5I7tCofJKdQz/X4obFd7WJSPddf5bHcQtrvYQHiroeLZ9TJ2Cn1WpyfB51G95iCO7rS+4MJVQbAqYUbOiAYDPbeHQ/h4e41ebV5lvnYlZ/29ISaYh3hnvEJ401/+QRW1yIXFtwZz0FPs91R1z7W9Na/bP+GoXMcULKQSS9tyJCseLkOUdGDXLE3LGYvsb72O6USamUtIBJeU1E4NRPVzZQauVxfs2zY6ODa5bT+I52wILpYpNUqq6LRW+2ZzziP1GUfFOhNbKlanxzwq1tTRnjYdVyM9PcWYimrBSTR4K0ywqT0wG/ZMIIyNhnb848UtnnX7XPiak2HBZzYHbFzBZ+pDzl3Ds/0e50N4HUwkmdubBWfrBms8y7qLSw5c+L3ouFlfsGfDiE3fG3xM31Jk6VWCtMEtsqEcwGBs3vC7cffu1LtXNaZXEjMx3Q9wglkbjANXKXIIi2XL8WLD9WaVv+mBrYn5RnqseDotMART/kRcyQyuV4OL83AJqXi7tF0uhuc6Ttyj1pie28OSi6HiWhWOoRPlpG9yLUliWpNa7Y0dqE04cZMdSCCiFQ8VZ3RacGRXkaCGuNLbx6WVYbV3SvVSSmZEuVme8YbyOY7tRR7cPfUNe6alkSGPlABbO+DS49so3lwNFSfdgou2wjmTj78yY6G7EM/CBBvi1hes8hpxm50YerXBqzxu303EHKxRLBtXbpnNvdyYU7kZ9xxf8N7vV+lrzBBsr/3Cs79sub5cs1+1VLGoPahlz7YcFets5wrQaairnOgiSwMg1Gps4Tl3NYNaBg0dp1I8pfSxJR/M0gIJbCuVV66ij95KSUqQitjAFimlmtJRtWGvCAOt531YwX1crjgwweVxM5RZAuAxoJ5grZbEnZ4y/S+OIxsiq0eLEx4qTrPPUY+lEjeZhSvo40KAMMAcJAypG3cxVJx2YZHCZojXK4Ln037VcVSv2YtbeG91C26bJa3vOR3qrNfKu+wwebaw9XZLae7j/GCSTNwLKDIT04x7izf95A8ovghq7lLxjVIetzx6eMa1epXn3lIL+6hYc7M4ywpuN9Ea+Tj3BWwNs8IoZExKbiDrmJami06Lhp6xQ5UsaaemcImU0oLIQkJ9Zll0HJWbvGkkjXjkxxfNxOEw46JcIQ7iRlEmfmtZQikhctszbY7swshHxZlvQldMg4q7lCE0BcrR+rb1JRdDza12ye31gm6I0aR1NNazV3XsFeFfIT5HO7221Hmo2IfNL3e4LYTXI3X1vIYIatqtvFd4ADK5mZiuIt70nh9W6QVKC5VHa48rwSwHjg+DoO+x5oSF7UOb2pXUZmA/+kt7xsjIiLKUUHSdugek9GwULfYTg/xRBb003daEPYzEZqJWqVcDavIWXBGlYJuUjstVLnZ7FSjIa6G8BkdJF6MkxIzHq5KJKaSnHVWUFaTFAg6h83WeQ1v5mpWv2ZiSM1mMr0PsViYd0bmrORtq2ug37rwJ+qRyYL9qWRYdlXVxIYHQuYLG9hyX6+wgMK6qGr2a0lqn3egoEZKq3CHVeNkwd+Vm3As8+WffrUVrMT30BwqLAdOETk+z6DioW46rNW9onuPYrrjwNc/0B3gk1pQ0pkDjSd1In1O7jS8nNrDxpBLHfhw+TSuZUs3piLCoIEVB6ecipUPx5JvanKRB4coM7BUdh8Wao7gkoFebC95p/1qKkpINyHRMI8kbUvpmJwO76XrJ2yi4AASN1fXinE4LPt0fcWA3IS2daKBWvgrrpuJAcGFDcXtR9VyPCxpK8bGOVOaU7WZzkXfseRX6Ino/iWaL3WCkF1aWT+1dpqR0TztnD0DINBPTFcKXfNfTWjWG+hZh22wFWnoO9jbU5WgD4lRYmo7r9pxG+uiyWI4pjyi9hhN2owW9hE7WeYwS1q7K9Y+F7amKFG11nLsmF2xTwTtFWKlwniQJpdSsIUcUYY+cUtlg27uwPQflhsNiw36qe/lAbGWUMmSNkRZ5RMZMoomUgpZmiMciOBGcWsDm6zgMlTj2TMexveANxSm/tHk9H+4fBSbulDGdWruK077Ja8yTD9RB1fJQfc5xGWQG9A0bGYd4p15L0wYC8XWYklLScBkmli1s28bcC8wR04yXDW/9009pKUKxgvJC6fcEt/TcOFzxhsNbLIvgy33aNTzb7vGPzON8pLgBkDUyrS/pjc1iydRST6uF0o607B5pUkrkg/gw3te0pgNxh5yrGfwYueSNKRGp81TZnoOizfWkg0h4ae3TmWsywfm0JUTHsRCvBiZGbYlM8NCi0T63yOmki75HB2bNjWLF64oT3lzAvtnjlzbbXbyVq4NmyRdcDBXnw2j4tld2XGtWHJVr9qPNisFxsz7nZn2eI6Eujp0sGDuhg7d0CBdDxWqo6J3N+q2EwoQxmlSL+hu/++l7xh6zXGDGywa3CJtM1EB7PZi8Hbz+lDcdPcfrFie5Pe1VOO9rPrE+oq0LDotN1s/0arntlpmkUv0onVSDtxTGcWC7rFFKJ8+nukOGydT+YbEJAkez4Tzqnno1WCQfR0oFU2qXhJepnpTIyxEGcbf2rhmw6jHq8WkDix/lDFY8JjsBFHgjlGwb+Ts1rHzNc8MetvR0uuLMV/xq33Oq8OvtwxwWa6x4ToYln24P+eT6ECPKRV/lgdxF2XOtWfGGxS1qM4TX2NWU4rhZnnOzOGPlaz7WXeOjq2tAk+tzQWYQUr1VX9HH1E0IZCSTul1y67yXuIe2J68oZmK6AnjyP3q3aqnonofa4a2yd7DhscNTDso2pxEL2/NocwoN7EdpQFI6AzlCWkm9tWCx9eGbPu17S9P5VnyuJ6VV1+Ooic+R177d4OJJuPZh6WPavJscCMpISos8Vd9urcr2SJwf67Y8w/OWkRgxpWPO7Xc1rHzFkVnTSIjA9kwbtunG7ttnu4P4OCUflRu0vuTj7TGtL1nYjpNhwenQcKtbsB7KON8mNEUwd7tWrXmoCqLPjS859/G1KMZxFhfrQoMaTCxwd96yGirWQxkK6M5mhbs1HqNCGettBqW0oS7113/nj9zbltxMTDM+X7z9jz+tjRi6I2VoBspFz/6y5eH9cw6rDb23nPUNQ9xgcqMMlskHNtRtKhlyDWgTBZQeoWScWxvrGj47BWxZ0E4KsmEFUTjxVlLlwnOYYwtF7ouh3pofS6S0F8dCljb8v2fabEtrUJaxCD1dpZQdJ+Oa7en83tQGt5aBA7tmz7QsJWy2xQQ91kPVGTfLs6y6DmQb6j3J0ndXorBXdjzUnPPGxXPcLM7z2vDk8x1sSzZ5pCetCd8rQoczD/260M3T+FpMhRj5NeLOkZ97iTmVm/GS8eRP/WnVWxWH5xZXB+dJyiCefPTgjEcWZ7QuLFA0aqiRvA131zJ2inQyT096Fw3bUkcL4qR/lAwMaoOdrRmiVa3Pa4sgjFo4DGtXxTqLzVGAib5Fe0XLkV3HSCkc53V7zpksMtksTZstQFa+znWlVGSfkl2wXAmbSgJRtBiida6MwsVGOh6rbnNo1nRqOdNFJD2T59hSYX7qFFCZgaNyzWPlba4X53g1POv2A6GWt7F4Nlrm19DEgWJfhWM+6xtWlHmXHBCXKoye5hpTZS+Cjw2Fn/u6d9/7cGYmphkvBU/8uXfr4vUd7adr1BK25NZK2Qzc2FtxszlnYfswtY5SG8dBsaGO0ZHPJ3QJJumOQs2jFLfVRevVTlZ3j1tEpqQEZIva1I1rfRkL1YY6anRSx2nwlmXRxSFfx8J0HNgNR8WKPRMIJAkf02PBOP7hidtulR1iiosD4khNqncZrzld7dXifL3lt9REndbK15wMy1yoXw1l1hElskjPv7IhrVyaQKQbSiyeY3vBo8UJFs9n3SG33ZKNllg0K83PXUMXd81NC9wpYpp+bWgkRecNf/cbfuj+z7FeIczE9Arjze/9ft1/U8vFWYMZhPa60u8req3n6GDNQ805+0UXIhNnt5YnejV5xsyg8SQNn/UpEU2tci0+r9Ce+nkn0/10X/u25XpxQVgYuWAdI6bVULKKGp3kQllZlzeZ7NuWw2LDteKCG/Y8R3TJrK2KM3tOTJ7yz8ead9WNIzEWCekpZiv6C/+K+DwMPaPLpcPQ+pLnhj1u90suYmS3cWVeIJDSqTp2x9I2kxS9bbTMmq896TKZptct1dxq+rAQc/I6ToTqpEWfEJYWJCSDvHuPeSRlxovEb/lvvlsfujaw6Ur8RYk/crjGUS56Dvc2PHZwymPNCUY0m7wtbBAhBisP2VpnndrpG18Gp8edGg2EzlCB3/KaBnBiMPEETCdYMkybDvR6NayGYLubBnMbO3BQbFjYnuvFBdeKC47tBYdmg8GzYZyrS9GTw+TtIMmTaJouGvSO0Y5ewzDws90+fWlDoV88qJ8QSojuToYFt/slZ0PNZggpViIGKz5ESEXH9WqVCdWp4SPdDXpvKY3jZnGOx3Dmm7yMcqqgtzHKG73Ow7EnGsie4KL5sX0siP/i7/v+V44t5lRuxovByekyfLA7i70w+Bs9R9cuOFpsOKw3PLY44eHqLGzpiLvcgFzYTnvRUicu7SpLkUOyl51uO5muAU/3FQrRLQdmw5lv+Hh7jWf7vZxKlSmdMpN6lAsEVhcDy6LjsNjs3G/BhQ/2Hg6hEpedK02ca3MSzN2SrmiawoXrTRYHEFTqa1fyTLeHEc/1osx2uGFnW8EqenSn+tdmKHMtSWJhfll0NHbgZn3OE80zHJgNvdrsxeRU4phJz8aXfEYP8mhLcmRIr/Hp0PBcv8ez7R69s1nlnl5rpwbfl7m+pFFV/ophHkmZ8WLw5qffrVpWYEAkrFg6unbBG45vh3EQO0QVcfiWvlatsxDydAi6mX3bcmA3W8LDNrb780yZjidKLlCn9UXxNolQ9kzLRsux9qNBLLjWMtZoqux1DWEjyFG15nq1yksAku9QLaOn0oFZ09g+D/2mBY8+plxTUrobpsPH6f9AaHV2tExRV1Jcd7GF73ywLDHRR2lZdByXa26W5xzbVXAy8CXXi4s8rjK9fBXrSlMh6Fl0uTzpF7n2Z41HNOykS5FkSneVEC29opFSwhwxzXgheNuffFr9NUVrD6Via0ez6PiC689wrVpn8eLaVZwMC0pxPFSd5RMjEc205nLumnFDrB+V2peNOvRq8wxcOuHHqCXUVioz4FRYuzrUlYYqj6ZY46mMY69ss0tAIrdUjPdx80gjPXtx8BeiO0AcGUlEsoqdMksY2PWTQw5E5OkJe9+S5qlXw8mwYGO2HTin0VI3MV8rTKitFXFLbiK2M7fIx5P2uqVZwiBbGAeG0/GkkRMIbgIHRUtlhmzBm+puhQkjN4Xx9M5m58tXHnPENON58OSPvFuLc0FL0IXHLgequmd/0fLGw1u8bnECwNpVlNHSI81jNabfEhymEz3VVM5ckyMlYCt9Swi+RsFNIJ3EibjOhzob4k+XECTR4GYIJFbGQndjx02z0xQuzbs10ucTvYz73ADSqeli5zAJOpPy3ODi8oLRa9yrxahm+9zCOAZvOR0WeYo/Kc+T79Ewub2NpLSMG0zSbc6jk2QtDY3p2bcbGgnq9ORMAHF9eHSCWmk9vp6kxQye0kzsTMRS2SF36ZIS/lWzuJ0jphl3w5v+0g+qdQXGCUOpSOWo6p69puPhvXPetv8ZgFjbEepYUL5eXOSTfndzbVBbB1JK67IhFYyjXcgklUuklmokQU7QR/8jy9oVua6TiCt1stIIRWlcJKSOPdvlkY3UeVuajmO7ympsYKuVP8X0OEgRF9tK73DcaW4uuXIGgl27Elx5x8ryqb9RmkmrrGOvaEOROzot9Go5H4IdikeCop2gb0qduaXpaKQLg9DObtXDYGIP48mOlV5N6PB5yyAmK7//ziuhWboMMzHNuAxv+c//lCIl4gRxUTxJKMam2se+bXm23+NWtwzpQRlIad9usrjPANP11m3swE1b/U4ldrNGBBuO7WNKpm4LGyKcc1dz4euoJwqui92UkKKTQROjpYUNbgAQLEPSZpKl6Tgwaw7NBiDYj0zcLn3e27YtosxFY43eTpPNwNP1UTbap3TZqsXQOZtN1xrb5+gkkWxah35YbDgq1rlwPZVQpMdLf9voOFuYLj/zDSfDgnNX58ZAchdIindbJK+rcN/JreD5RLD3FPNIyozL8Kaf/AGtlho/IGFQXg2Xpv1rX3HSLjiqw0T7tSKMm1yWAmRZwOSbu59Yf+TbxajJxf8TSnEUxscV4aMPdoicKi6Gii7ui1sU/dbmE68m7JKLl61dyWc2BxxXwcY3WZZkX6TJSR5+D/vUVj6kjgvb5Y27flIAD0X9seAcjjvuhItzap0LqWYamD2sWhZFn2tRyTkzSQKSo+fUE72UIXcNNzqSrJXgGPCc3+fcBVJKw7qFcVs6sPQeFCZEm5/ZHIR15bZniMPBrxbmkZQZd0DOCrrOgFWGGwODVUzl2N/fsKx6DuqWw3LD0rbs2TZbbTSZaMaUB6BnJKW0vjpFPUYVo+NJF7bIhgWRRpXSxJm4yUnSahFa/9GsrXc2W8amLSjLouew3ORIBRhV2KJ0Eo7hOK6E2mjJ7biqyEcbkqlmaeWrrfpNijo8cofuqnXBCQGCK+TUGXIzBOX5qq9Y9yWDM5R5DXnwgWrskFXsYf3TJhNRKUOoHYnnzC/oogQiEY7DcDIsuTUs8xfAwobxmloGPMLJEBwxl6aLhnEDt/o9TvuGg3LDIvqOv6qYiWnGFG96zw+rHA+UpcMW4cMuohSFY6/u8vbWdGKW4uJEfiCa/I0clc02pzcBWwsYZfuE9rmeFKxJSo11KuIGXV/icDlVS3WZNm74gHGhY2nC+MrUFG0s/KbNIQNL2wV9kgo9Qdzp4hDtLimlCCKRZnoeKS0NEc9Ya0op3UX0j1oNVZjgn3QKk4WI8wZ2is1p08sUYQ3V+Fql620R+yWhrSGJK0Nk1RMEmWlvX2vLnO6G7p65p1tQPifmVG4GBELCBOWytpYBwqbXqs/OiIsihPnLIrg6pvVIozGZ33JxDAXiUdk9ehk9f4qQoiYT1dfeSCQcFw3Nxrc8OQV0cVI+1X1SxLFvW5qyj8cWRkiyfUl0EAjzYYZNlAWkhQArV2eJwuBDez7JGaaWLFO0cURlSk5pAHeIyzM1joBMSUgioaZoKRW9x0UN4ygLDCBhJZTfidYcEkWdFX1U3Temz1qnRLS1jP7qaaYvd+FkrIu9WrjHlk+vCGZi+jzxxH/6A1ocOoZ1gaxsqCsZRQT2qp7jZh0n993WSZMGbq8Vqy1VdiKm3Y5aODHtHds4gtZnu04zeJstP9LutWRpsp503TxC50bDfINml4HQkRt4pDxhz7Rc+Jrbbsm5a6hNzyPFSTy+gk5HgWc70Sptd9bcpVFMKsp7tQzebkeFjNtGnDeZpKapqcmk1Gd/8f0i+EGF12aik5IhkJPeGTVNZw0hOCqEId8uSyK8mBwlHdl1Hh4uzRB3+01mFF8tdoi1zfsdMzF9Hnjzu59SHoojAJ3BtOEb0/mQauxXLcfVKkzgx1b70nbUMmxZacD4bZ29k+KQbip4O0wuPk9FlKlGY+Jqajx4CSZuvQspRWprp/pNGtuYaqDSLNl+0WVfo5WraaqeR+1JFja2PngWHdsVvRaceRMHcYt8vCtX5WNOUdJlOqvd+lKvu+mphG5htKrtnY0ygVGvJDE6aaJJXZotTCZ1XVoLpSa4ZqLja4YP68bjuE+f60rdli2wZUwT96Or516MljZa0kiwUEnPyRAK8K8OZE7lXsv48j/0tNb7Qisl7tAhfSAlXypSO/abluv1ioeq89wNa8z2tpL07durZePqLVtZH4lqu8W+vcp7t3tXStj0EU7wGIHELpWJ9zl4ExwXXcEQ1xXtlR3H1YrHmtPsMPlstw+AWwgHpmNJz6lveE7C5ZU4fOxmdRI2/TKJOlKkNiWlsbZl8/OaklMyY0uDsqkG5SaklKxLRJTS+Cj+HPLSzWQUl9LPoJWSvAghGbZtP65ks7r0HiXx5fbrO3BggpC0SqvL6Tmwax4uz7bU9bsatFcUc8T02sSX/7tPqyiIJ2iVKo/ZGzDWsaiDp9IbD57jseY024AcTNwbV77i1rDkseqERvp8UniEWrYtb1OxupZuy0tpN+VJ3S4rPrg3EgvJ8UMaIgKb7Uv6mBrVoiyLjseaU56sP0spjmeGAz7hC86Gml9ZP04ljqW0W/qkCx/sexvpscbnv6Xu226EFArjExLYIVWXo7eQ1k2jwkBOo1tAqFNFrZXxFMbhCfWytasw4tm3YRnCtfJiK1U+9QsqGTAxzesmW3rzenUz5Mgq18XiIHIab3Fxp50Rz3V7Tlk7nhv2OXGLz/8D9vliJqbXJk7fFj7oWnnsfs9j1085qFqO63WoI9lQ61jasMXWxG/tcfYtWLc6JJuQpbmzVOROyu4i2spO6zOhPjR20ixBVAjEx/O5xtF5ix/qXEtKA7llTINqO2yRQCkDR3bFQ9VZ9CuyXPg66KKA68V5LnDbuL8up3C+ypFSiYsjNeQTZTeV216fbXb+D7W2wRvaoQj2tbEbV6R/4rMz53TvXVrn1KvFohzb1WRLywIvklXnaYtKeO4uEvwY2U69mMJM3bC1yTjVAsto/Zve51dTx/QgYCamF4kv+v/8CS1uRlWyVcpyYFn2NNE4LdUWerWsXBXm33a+wlKqAGTRYRqGTaMheUuugVJDzcfLuEV3el/phFy7cvSnnrgKJP1PssMoTegSVibsqlvYPq8UD53BkFKNIzJDbpczETxutN7yREqzfaW4nIrtDiLv1pXCa2W2IsA0oT/EKA9C560uQoczpYfTjSPJuC5FOKNCe5sMy0jyu6Q0vpYxCpzcLtm2pNdhqsYH7uju9d6yju/rq4I5Ynrt4Av/39+nNw4uONoThhh1WOPjTFZHU/TBx2hS6+ixWdBnCfawybKE+A2eWvB9HEjNIyHiaeOJaQiEkwhqd+9berxUmC6Mo1BDETVA+ZiQPPt2ULS5KB4scodwoorNtZmjYsXN4vTS2bdU7F75aktAuetwcFmhfgqPbEdOTLRNk/GVIr7e9WRYNl0/eJq7rXQ2CSJTxDfOH47p8GWklI87vrY2RqSVjO9jSgPz84ryjqmlcetepVNrHkl57eBL3/c9erzfBZ3PpB1cFwN7Zcd+2eauWOoKTU+eNMOVvq0zKaUP8cSMP9U1UhE72274IE5M2K3BpDpVEVM+b0Y9VGVcFg8GE/4ND1VnQbYQT96lbUMa4oMBfxNb4odxdZObpFouHmeoG5lMqOF1icX7S7yWpnWldDypyzYVNqbf03iJseP6o1zIz6JM3UkJxzlBF4eeRwM8txXtuGjVYuJ9ThXgJaHAbyIZJdU48fJOif4DJt6XmXRIdev9eaUx65heA/i9/8O/q48chK5QG1f1OC805UBtB27UF3lxAMC1YsX1OPOWIolUo0i2uAk2SgJWvsrq66kcwIoyeAEMXvSSeINMZun2SaEN5EHXFBEF4vJcry64Vl5EJ8dAiqk72EbXgFBTiQOq2Y7E5PmyXJcxA6UWW4XpcBuTp/rHY92OjJJDQPo5PR8YrXaTp1EgKZdraV41bwaeGuf1arHe05sxhdwQ3oO05GDrPYhkFYrbbvxikEBYlTgMo385jPN7YfzGbD2v9D4vbHeXT9QrgHtETCLyDuBHCAOaf1FVf2Dn728EfhI4jtf5LlV9v4h8A/ADQAV0wB9R1b/1fI81E9PnwMdPjjhcbCiNZ3CWdVcG7UwRPaTLi7DeSPcoxXOzPOPx8hZODbfdkk/3R1ukZGJakNBrWAW0dmWwPpFNHvh1Ma3b2gd3iRYokdLCdOxHv6RpbWfftphi/LQmD3EYT7K00aQzxSRNMjlFm3p2p6JyKQONDHiTJuzN1kmfcNmoh5uka9Ofk2DS63ZEmJ7L9DrJ4iTZoqTXYWBMRxORhWP29GIn70WMZBk9vUMM5PN8nYnF75TapQiqZyTsNIoD4cumMT29faWWD7wyEBEL/CjwDcDHgA+KyPtU9ZcnV/tu4KdV9cdE5IuB9wNPAM8A/5KqfkJEvhT4GeDx53u8mZieB29+6t1qXl+wtiWucHiF/aZlr+q40VzwcH2eva8dIf2xhFZ/nrLf8hkKKUVKgSApt2UrakhIdrfPpyJOaV8q+Cbx5toFrVJ6/LSyOxFW2C4ynkxp6r7RPo9rGHw+6Xz02V75Cq8mdK4gRyxTfZXT7W7b1MIk/H0kostm03axZRUsY1F/XOS5/TsAanBRcJrTKjHBmA6JhXxP74u8IfeyQ/FRKR4oyoQ15UJeVBAK/pP3OL+mr56O6R6lcl8D/Kqq/jqAiLwX+EZgSkwKHMafj4BPAKjq35tc50PAQkRqVW3v9mAzMT0fHmvZX4bXTkR5w+EJX3z4SR6rTrKAL0UeR3G0xOK57ZY5RUrRUhq8dVqBkjtCqfs1na1KUcHUnD9Zzqbh3cuKzIkcVr4KaVxM3ZKK+ciuSL7Z08L70tyZdqQCb+/H1nvry6yOBnIHsI81srQ2ahyjsTvEvH3m75JSElci28O1UzIK68s1k1sixuljJAIMHb5y27IkLFmKc4g2R5eN9Nly1+Kp1OEY01IrPtaVQmc0RI5xBi+9D5peu3GRw6uCe1P8fhz46OT3jwG/dec63wv8rIh8O7AH/J5L7uf/APzS85ESzMR0V3zZ+75HH73RUlpH5yz7ZccT+8/yRYtPcKM4Z+MrnnX7mXxu2HOseJ4d9rNhPiTHw7FTl07yXA+RcWo/nYjjUgGP3SoKB3JK7W7DztwZks35XbQwWdg+r7s+sGt8LGyn+TYY/a3DSIzZinimnatgKTvkCCvUWIqseE7PMUkddp0mp0iLFqbCyvgosaAtO5FSWhfuY70JvI6ds12kqCh1+aY+VYbgNpnuv6aP9+NZuTr/nNK2cJzBmQCFniKS2Bgd5dpUFGh+9xf/N6+ee+VLi5huisgvTH5/j6q+50XexzcBP6Gq7xaRrwX+ioh8qWp4o0TkS4AfBH7v57qjmZguwdf/3B/Wx48clXFUdmDwhhv1ijfWz/FwccYy1mMqH9KmSgYOzBofv1mTK+TWBztGF2nDx7RdvbRdVnqHOskYGe0iR05sRxxJnpCisMNikwlpaTr2TBsKuKaniSdiOrkScWy0zgXrRJRJ0e0nJyKM7faVq/NygTQMmzVYW8ctzxs97aKYRBz2kogp3cdlpJeiptFDPA7yGoJ/Vb48dPCSIHOqEeu0oNEeu5Oi7koeUuE9RWRGPPbVdmp7aQ//jKp+9fP8/ePAGya/vz5eNsW3Au8AUNUPiEgD3AQ+IyKvB/4r4P+iqr/2uQ5mJqYJ3vze79fFouMNx6HQ3BR9tiW5UV7wSBlGSNI3Y+jW+Ml4g42FU4e/Iw0jq4LTvyRGtOLzqu9hy5Hy7uSU7nva+Uo+R/u25ahYcWCCNUfS4gC5mGtRXBJsMq5SyhFSWirp6jtTruhPlMzrprfZ1SDlY06F4heRZkwJadqpnP59ShxTbKV0WVYw1pG29FVJhyRmOy2MdbatY7rkrE+3seKxul1vezVwj2pMHwTeKiJPEgjpncA371znI8DXAz8hIm8HGuCzInIM/LeELt3/+EIebCamiLf8539Kq8rRtgXnXU1pgxDxuFzz+uoWj5S3twz304bZJLQ79U0mkmAmFjAlpaQrStofIG+fTbWodpL2fS5kI//JGMdYT1pzaNZ5iDUh7XjbxAgoLc684/4krYmqt6IES9zmorqlv9rVVSUy2DrenQjnboOuu5enVC4Rze79vpAC+vTYUjqXOohJy2V0lHVUMjxvAXv6mtpI1L24vAr9VcU9ICZVHUTk2wgdNQv8JVX9kIh8H/ALqvo+4DuBHxeR74hH8S2qqvF2bwG+R0S+J97l71XVz9zt8WZiAt7xt/+Q/qGv+If8zWe+iI+eXmNZhs2t16sVj1W3eXP9aY7NKtYRwrvemJ4bck4jPWd+wWeHw60PdKupzS45DZpqbabbQabdpfRtGyIhJhHDVOV9ZzoBQSG9tF3c1OtjrWpCOPg853bhg8F+KWFVVIoM0rH2caHkNOW0+JwOkaKESdo5FRhOT45x8WZYqDDEkRkY5/rSrJu5xJrWRg3T6E5gdl6PcHzPF40lh8wppvKGRDRJv5V0TLsR0q7JXZAHdNtOBK+isQBwz3RMqvp+ggRgetn3TH7+ZeC3X3K7PwX8qRfzWDMxAb/1+m/yeHkLgHVXsiorHl6c8eTis7y1/hSP2lNKCUrsZK9RqmNDASaMZ2y1yxnrMdPuF4yt9EQcu06OOfLQMb1Ll/tJoXhaa5ouGkg1JTtJ9bLGRth6zDGtLLLAMg3kpp9rM1AzsdiN+p/d+lb4f/SGSmSxFUkhuegdLFx8/n/qQ1UYlwko3V8SjfZYzGSYOd3GI1u1p/xebHXpgoTAqOaFmtNtMqFg7+kpgIFy8rf0xTIl8uQjvic9tTg+zZ2P/0pDdFZ+PxB44q/+GX39I1/Ir+w/ylnfYI2ntI4nl8/yZc3HeFMRCKtVSymeMn0dCrjYFWtMx6GuR83P5KQau1NJyxMFf9hYx9me2UrIq43EbF02ve/WF8H+Q4L/dBNtVVpf0tiwVim5T67iqiYTdU+lDpTigjpdC5wP9zt1n4RQmE9Ioyl9lATsdt/uOP4JvErQValkN8+ph3jnizDzZqYzbSPx5hqT3umnlJoNl4k4L8Nu6jlNDV2cTLQyKr3Dcy6y08DStBxKy9IMNKI0cVToxPeZuF5VzLNy9zee/LPvVq0KPlUeshkKmmKgKoJx2rXiInffVlpwoVXoZkl0VoyCw9CRUQ7smo2vuNDoFjCJkJJzQDoBkhHcuKrozugj3MfdaxVJ6RyM4EaxXxoveShKGA6iRmnlYxscZc+uKQnuix/tb3DuGlpGP6WVr+h8WNeUN5pEqUPSKU13v12GMaobj9eIUsSRmdT2H4vyeofAcWowN71sGkXe8Zq9hJPSb9WLRicBM/kSagiOAyWOChe/pJTkULVRpSOlvPdlV+5K4TVLTP/83/j3FR7BtIahszgvPLwMO8hetzjhoeIsroguOPMNp74JSx0jWaXFALst9I1WQXwX0zc3iZjM5Bs4re1OSCf9bv3kMqQIJW3KTRP1qdOXFlM6DBu1nPlFnLAP3+Yljipu+0h1r9QhhFG1nDRAiSAHH647qN0qZD/f8SaCyuMfJnhAJdFjIpcUKdXRumTXQeGlFJTtJVFRkghky99oD5OGeUOXVLfIJYzehBGcdL0EBzhVLnw63lBzejUxp3L3Id7+3U/r//mdf5O6eBtahiKtLT3Xl2u+6ODTWSF9bMMg7iYucdxFaLd7usn4yYWv82LHdLLDmDokB4BESsmmJCnDk46ptsMdnafdk9+KUpvRR7wUx8pVY2qklttuCcBnhkPOXZOlA2FUxnARvZRStJU6UkmxME0zc6T0Ikkp/W8EipQimWErPQOoJVyW6mPZnjcOOru7nGwvpHs5bSBM7X7T8y2fZ6NJipIa01Ox2+GEXtPPQoXDS791nRkvDa8pYvrKP/iUrr4qrMfunYX9Hlt6Hrtxwpcff5wvX36EKjpJJmvVCseeaTlkQyNjTaRHc9qw0ZIzt+A5t8e5a7ZU0NMTMJzcZd7zFpZXdvFvJqdHxU4NJP09IXkPJYuV0gz00fw/bd8984to4lZyMiyzY0AfIyinEq7j6nxyZxcEdVEFXW2lcMny5PlwWcSXum7J5eCyNvzSdhzZdbQflryXLkWcmYBSzS3W59Jj7taXptKCkSA1vx/J23vXh2lLGpFSN0npm6NkTNU6NVTiCZ7ingPT0ejARl/l02qOmO4fvO1PPaX+zSCLgQ8+9ya8CjdvnnFzecHbDz/FV+x9hD3T5hm3Ti2l2rBXTEJNZKOBOHq1dISZswtfc+YWnPkmzpLF1UiRXKZkkaKAtSvvmCObInWrpteZRlBpYDctODBRoGldiAh6X3Arbis5jZtjH6rOSJtYLqhZ+bC2u/eW3UJyKQ7vA6m2OydZmlODFK1MjOjSYK6O4x4mdvEK4+IqpG1r2vTcAlEMWwLU8Hg+bhWOXU8P03VVLxb5fYnpZUp7vZpg+WJSwX3gwGyoSPINwSAcSJ9TPUPodNakLytHH4/3VcPclbu/0D7eQ2/gouDXPvowx9fP2a87bjbnPF7f5tG4J+3MLzj1izy42WhPj+dCC267ZVh/HQc4pxtnU4t9S8sTkS7rNfhupw6UlSBSbBm34dZm/AZPRnHh/rYdFZNNxxS7g6PBHiR5CLkcBd4a9nim36fzBXu2HbVT8fH85Pa1GbL97xQvKIWS0ddoulcukWkSd6Yoa+XrnAanY97qmE2ixrt15S6rKw1ZmR7+K9QxeJMdPNPrmFO7ia/350rL0lF4oI+1v/KSiPAVxUxM9wee+AvvUtlXVD3SWrQLH6dl2XFYtEHDQ9DzBOHh2FFLRHTha878YqLxKdhokSfrgVHNPUGqG/VquBhqVkNYMhB2oQ1b1iTJCWDQUIy/GMKxhBQonIBFTOHS8oJ0Ulo0b1hJhvp9jPie6fdZ+SrP8T3T7/OZzQGDGorGsSy7nDKl3XZOtwn2brKAKVJx20wKyYXxWS0+NWlLTgyGEKkkcqpNT6lurM9Nupu7tsK7kdN2VDmui5qWzae1pXQs6Vgb6aN1TYyAov1LKnoHHyZDr9CIoxalEsGphv16jDXFVxUzMV19fMEPPaXsgbYGCoX9nrJy7Ncdh9WGhe3warIS2mE4tisO7DrOxY0jG9vriJKZmuQTeazFjDWitStZuyArCEsmw3U2rmTjymwVa0TxEgSIFy5EKIMPtrg2dt+qyXbY9NhpGn66ogjA6Lhe/KRfsHYl57ZmaTrO+obzoc5q68tmu+4mYQi/X94hm9aSkpPmLhHs2pQkpAjKyhBFlNE+V++e8m7X4e4cY5kKKKcF7yQSDcecFOyayXL3uBJ6tVkOcmw2eammg0hY20PRrxbmVO4K4wve+/0KMNyISpPCY2vHctmyrHquNyuuVau4fyyE9GFDRpdJKVl77GJ3Ri19m6d/4b7Ct3XnCzauzCdGYcLixY0raF1BZVze/AGBjNJ9VDY4HIwtbR8lAuGEmLoUpJO/V5sXCvRqea7f49l2j0Icy6JnYXvO4jqnyrp8u1SwRy4vBH+uebRxrCRESIXxeUPMlJSmvtsJ0+4dgMmWJS8MiYB2Z/rG+98mpWnqmmQS06HoErflJOAxuNgpPPOL4G6Jo8TjxG8dp1eT9UwzXjoeSGJ663/xJ/VfeOuH+fDpw3z02WOGwWKMZ9H03Ny/4Khac6NecaO84KhYsWdaGgkDudZoJiVIjgBhKWIXa0jTYdxpipH+z9+8kpZMGgrjA8mYQFiqYYHjIIr40fOnHcYll4XZ5JMqD5rG6zYy4MWwIXT5vAilHZccrLTiwtU80+5xe7OgtC57gHdxldM0EprKAtJjOk1Eue2ddDdM2/EhCdKtdGm6KWaKRFTTL4FkyLb7Gm/fbpwRhGhpMrle8khKyMX6S3KdpOqeYnSvJGwZJozrYOBCqxCVTsZ1HEKH5Xc98U9e3VxujpiuHt76Z57Sa1+5yt2gqhqw1lNYz9Fiw0OLc65XK46LFUfFOrTb874wTynbJ8q0zuRJXkUe0ok89RiKJ0LQxoQJ/CEXsMeW9RTB8zqOmAwF6z5ELlUxTDaChHGOloLWFFwrVhyV6y2rkqS1CendSEqfXe9z3lbs1x2UXIqNL7kYano11NFcbpoabi8L+Nxpyu6WkCk53a01P02BshvmZMD5ssfI958V2qOUYIoUyQ6YnDJnj+9LUsvguhBMeB1pQDhY66ZpgLCctMbL6Lt1t/GiVxRzV+7q4S0/9JT2Dw0UxvPhk0c4aRvqwrFYbDisNzzUnPN4c5ujYkUTxw4a6cIwZtSrdDpqYxzB69pF/U4K70P3bawtTT+MYZFikT+kyQKkc0WOPobUQYrf9IM3OJ/WdkNpw766yg7Z8KyPq70L72kn7pNWPAsbVi09Vt5i5Ws+4m9wPlSctAtON0GzNVr1hoglLYtcR63SZ9p9OldwWK3DSW9C4X4d613T6GqXXKfuAIkkMhmhk0K24kmrtccCs4u1sqk0YSpOTa/r7nFMhavpuKYR2xRTA7xESimFm7pUBo8tA/EzAUSv8zBreGza0CiJpnwXWuXbb7S8Yyj7VcFMTFcL9Ree8OThKZ88O+DjH79Ouex53Y0Tnjx8lsfqE46KNUd2xYHd5K0gYTq8C6polDPf3HG/Nra9e01anbTvbdynlr+VJ8roQU0mpHCdkEINKTXZWSNtRWnKgdJ4FkUf0ynJxe+aIbe4N1pGYV9ID5e2za3yJEtoXYH3BpGwtbbzlvO+zhP+4aQ29K4OdbDJ2MbgQxexTWuhpmS0ZWky6pSyjGFCTmlGMHUQDYKJ2q5pWtxqwUnUXMEYBeVU9o4CfNzlpndeP/08lU8k58rdWlNqbpiY4oVISUcrXYgd2JISh8fktD5p3vJSAsyljYRXHDMxXR286Sd/QB95pONas+K8r+AG3Nhb8eaDZ3nj4jmOilWsbygHZs3jxe38+9geNtkILnzoJ5FQOhGQXP/YRTDmt7Sx+zak6CieVImUnA8rsEe/69Gd0UhY7FgZl+8TfP5bEQvKNkYf4bgt5y4Y1Z25hgtXM/ggFiwLh/GhptW6Im721bBF2AyZwLoYVXVxPfkg4XmkYV4vk9pQPGEL8aTtw3n2LP1LYyCTsyRIDpRVnDMcX1tzR4TkiSLN6Io5fZ2mdaRdp4D03ln8He/RbjE+XDcV2hUm3udOhFKGOLpTceFrLD6Kb4uo4i/uSN8uW+zwSkKYU7krgyd+9F1KYzhb19yql1TWcdC0XKtXXK8uOLCbsAUjpmFWPAemp0TxpAL3OIQ5rXckEvKkCGlbXzNF8hvKpDRZAun8SFK73/4uRjVWAmFMIxckGaWlqXx3R5EWwsm08SWnQ5OXb5bGsSz7sdPnw+LM2g40tqexA723rIZqa8h48JYh/p/taBWSynvqcZSe3/T/9FpMqy3pmDe+pI3zeenyZHu764+U3q98/0wsUWLEtetAsEVs6FYkNT2OfJxqsNOu3CT6+ewQxnxWvqL1JbXpcX6MlqcWyc1k6cSrjpmYXl18yR99WoevOUOrJmyv6C3roWRZdiyKnmvVOssB0mYQSB++8IFMpJQ0KDAavaVu3Eanym4Jc2mTb3lIBdvttG6rHsJ2jWbamQPybrgi1n+CrYkJBXBCKpe6XrtIA7atL0L65cLzbGyo5bSuoHd2S2yY2vkXQ8XFUNE7SxkN2sJro5lcC+PvIKfpDNplx5M00bkzNyH0dPKnaCdFIinSGX2nQmqMhvlAZDtq2iWdOzp3OroIBI+lO491WpAP9cCQorn8mpZbEZEXk830wgZlE51D21ff7gTm4verjS/7jqf1/Cs63nR0xkdWJeoFY0IacVhtqIzjuFyxtG1u/6f832O47euJQG7sOKWFAU7DcoFu4vI43aE2rS8lUkijJs+H0PofoyjnBRGliHWgVJTunAULnp0VTSqTb/WxIJ8K1ReTjSWVHcZIIKaP045ZH2tOq75EmBJqKMIP3rBxJZW6vLq8IDgFXEaQCan2k47j0ugynvjpXB6L+dtOBolkndkeiE6PA2zNIo675nTiKdVf4vU0Cit37y9tskkr3oGs9eolkNLahUUMYayn42Z5dtfX4xXHTEyvDp78kXfr9W94jn/xkY/wy7cepagDwSzqntoOWTh5rVxlOUAgpyF7Nl/4GmdMHtKEUbMUNofYcR4ubq1NpNXGSf504g1+HMydfntPlwRMkTRE1nisCcs0yxgxaezipds0VnJXjui3HZwrq63IY9BU25IceRnxeBNSj/WEkJKWqXMFqz5GSzbsWtu4Mj/2RV/TeQtFtPUwQ04tn2+h45RksmPnzrDwVkR0CYY47Dwd82mlJLmGptc3uGjGkZ5o05tm/LrkiTWJ3qY1r6SpsmgmtKA/C5FRLUPQnU1sktPevrOh4WIIXwJFvA8TnQZedczE9MrjLT/0lC6/8JQ/8AV/lw+vHgXg4eNzFmXPQbnhRr3ioeo8+yotTcue6bJhfFJzp/kn2HZbdEgU0lVRv1SRN66iW8SUUoleTTgJdFwTlJwBBm8yETm/XWNalD2VccikaFzI6H9dJC1RJqVQCE6DrlvCzlj3aWy/1b736hmKUN9K0YeqsB5KOm9pXdTp+CDuDPWuCudNiNpIqaeL3Tef08vdVG7aoUwk6PLrarLdyxS7m1NctKkd/Pbq7SDBMJl40uOESDV8ISzosbbPf5vO7JXmztpcmVP5MAJTMs7MZcHpJPUMUWl5x8xjaVwuol8FYppTuVcB6Qv0Nzc3+Y2LGwDUxTAhpbPcGckDn9FXp4y+Ot2OybyL9Y2Usl1WV0rXnZJBUHYHEto+iSWTEtxZKE8klMZRimhzkk76XSQCSA4Epfit/XNTF4LtjSMh7dqjw6BsTJG7cL2zYf23H6O6IaZ7gUQF7w3GjF2xFMm1PtWjbIxAfE7BpoQ9TelSepZ3vDFu6d2OKMeGQYkPq7wR1q6kG8rYmQyvk49dztVQhddQQqdx8JaOInfgkktBqnclv63d19dhoq/VqKvqvZ2QUoiWEikV4jgoWw6KTXAsFT+O9sz4vHBfEdMXfc/T6h/ztG3B//TZN7MZCo7qDXUxsF+2HBbrbJ6/ie6Qaa1O7gpF/U/gCp81KWlhpcfk9G3l6y1iymZsESkqmlrkphRjOvOWkDpvwEQWMOQTbXdjCEwsYVOR3hmGnaghp3pMx0LGPWwYR6GGQg2DjjN5vbMMbiSnXJQnRFWqQh1FoCnq69x0tbiPbpvbq8SRqC+a1I92FeOXkdLz1a3C/RgGFQavW0ReiM8arW6S+l2rVixkfP1Sp/Buliap+7a77nztK077htVQ5o5rqOGF98+rcO5qlrZ79ZXfMKdyryTe9ief1u4Rhy4cbrB88tYhTd3zuv0TGjuwX3S5nZ46Jh7hyK6jmjfUEdLK66ADCmSUUrf0oRo9l2y2AYHt1UuhGhG0QYNOaydm63fdOfGSxkckWMxWdvQcCssFRv+ladqCktM3v7MxdvBjtAbbiwqmxzXtFiby6Z3FOZOPUya3sdZjTYhQUtfQEwaTC+9z2jR9jPjTHZdNN/GOyz+3iWGIOrBdshr35rlJihy3uBQdhXFsXMFm8l4U4u8gw/E+R2O76c+JlKZfNH0swK+GktUwWhdXZsjR7e6uwFcVky+E+xlXnpi+4Ief0uFGD68H24R6jALeGYq4LXdhexamC7m+jjarBg0LKGNRMnXawt98VCabTErpb91EOLe7UADI5OK8xDRq7Oqlx9496aaElNORqWYppkkp5TDCmPbo9szYtB0//Vu6r3TyjxGLYePGNG48XnDOMPQjGQiBnMQoxoSorszRyVT0eTl216Lfbc5uV0rhYl2umxBTep3MrvQipnAewTi942+FudxaJbw2ZrtIvatXS91Cxoip9QWD2kDeUxHpToo9eJuN+V5NzDWme4wv+g+f1uGNA9VBR1m6UO/wBh9b7IdNy2HR5rB+qjZemi7OxEVPpSySLLb8ldLvDpPn4nbD8WmqlDfPxvGUYecb/jIBZaqpTEkp1YHS/afUrzBjlOQmBLQrQ7jsMUYPo3GxZDqeTexwJfcCiEr0weAGgzqTP9FiFGMVLcZkp4imb+E+t7tbu9iNkqbR0S6JTmtNQ3o9Sauu/GScZ7xOaiRMC/Qau5yVCdKGKuq+vMaV4JoIfyTXRFApmoZxpi6NFk3fXxu/TCCOvuS0PLzuF65iwau8Uw7miOle4qv/b09pcVNY/tOSdWeQR1bUlacqBlSFMu5/Sy3e6dBmY4JJ/5G9oIyDuVaS5kfGLpuOKu904k/V3UY8RrdtMvIHNw7VJoT6zI76WSWnRpd5EG3PpqVv6RCp3A2XeoBP3BC8Cl0cJclF53hypYJ3Enb2zgaiHww4ISgYAVXU3KmQ9qqZONMcn1OhuKQRNU3d7nbcu0gjN5eNoOxGW1lSEe8u1Oh8JqXajqNFaU7OS7rdTr0Lyd07SyCZpJ5Pxx9St/GJVsblkZxkiHe7Xzzv83ulMEdM9whf8l1PK48IxQqaZxXxlou9mur6QF0O1DbYwR6Wm2zfWpvhjs0XocOW7DvCfe96/iTXylBvCi9HsqtN331Wgko6zMGNKVH60Baxc7W7EfayUY3plD9MUrhcR9mxBrlL9DVdoDlFqr90zo6piRv1VapCN1i6oaDrbCAlHx8jDVoZxRiPtWH8ZD2U9Caslao01MUGNTkNCq9REm1uf6TS631ZtzEcUHgfShOm+XuxOzU72SKipJifRqZF3J5cmSGT0mIiG+hJrp7bbp13S0lT7RBGsjSiOVpL40EL23FYbLhZntH6ks+YA/7y1/zlV18vMBPTvUF7LRaDG2E6rF0YT1MMLIqe42rNQbkJl8WRkzoS0zR6yjWlyYmRFzpGUkqWJtP0qFe75eddxgWRXdSyjKQUCrJpXMKnRtiElC7T/KRCctL8jBKCIXfmem8vvR06zuVt3d/kZA0RTVKKBxM5/EhUXWdxvUWHkJYigNGcxhkbIhBV4aIL1ieVdRzWG5ZFz6CGzVBCEbpzmNHtc6pj2j72y8jJUOLzLr3bfrH1HLK7gJ9owth+nsl2OKVxibCL/CU1OhSk7Si5M3fJqEw/SSdTE6KHUOtifG6tL7jdL/Eq+RhedczF73sH8dBdc/RH4EuLW3oWhxsOm5aDqqWxwSJ237Y5ShpHDO788IcVStuX9XluLnouxfrT9OTxSJ6HOiw2eTo9rbPOEYsZB153Z+LuNlO2Ox4yncifwm+RzygBCErzbWJKJ58RT2FGc7REFInjnTO4weJ7G1M4xvg/Rk3GKIWNJnV9gTKSbWkc3WDzLF1vTG7ETYehd1dOwfb6JyuKjd88Vd43N1qfjK+VDdKG2KafPl8rnsb2obs5iUJ7b1kUHQsb9tSNNrnxPdLRlG6LlNIMX3KemBy3lzCSk1TvF0OdPdp/8mv+0qsfKRHfvlf7IF4GXDli+rI//LTqI0DtkcLTq8BBz7X9FfuRlNI3Y5IHAFHgZsCMGzjCCMqdpmF3Q1Lv5nVDsSO29hX7tHn7CGwXbVMEY0RDkXUnWkiF1t3FjAVui5wGDYV9dr55x0jO5BM51V08krtlMEZOCUmPlDA4E+QBTth6WQREGFXoJjgdJLW6TAhhekyDtyFiNGONK1zHb58hSt6g4pAsBJ2mpA6TB4nz8eq2fUwacrYydu2qKFLd/QIoTLLLNXe6WqbCfCSxREpprCjVqKYw8b6SuDO9DleFlDLmiOnlxdv+5NMqx+AWipSeohrwpefa4YpHlmcsiz6H1rUZQtFxUnMhKaAnJ6rFvyh9iSPsBbPiY3o4ZBfHMBA6FlUHb/PqIYA0OLvbpQv/T4WZ8fomnsBMB2gFKLZqMtM0bddyZBe7pDS936zsdgb1ArH9jYROHEaRmMaZibByaskCbC319BKK7VOZRBr0vRsSKaXXNLwmIWUuxIMdckdsiqSnyp0xNBa7Q/o7RfaIQuOChXFeLmHqDjFNg4Mtst96/FwXlLTpJVz+U//cj18tUmIufr9s+Nr/07v0s19pGJ5o0dZCoZSlo2l6mnLgiaPneN3iJEcJJhJT8mxOYfllZvLdJW9SOrFzGjct4uYxhmEr8inFbRe11eNl+zNZ7CiypyZx03m8aVRzGYkNPkR+0yL5SE5T/3CPYTuKSa3uLqY+6T57Fy7r+wLvJqRkQ10JAVOEgndRhJN/iMrwwgTPdCvK4E0eyRgJb1sykYaN03FOX+8wD3jn9pmp3imlypiwEbiIzQcjYRZwWnsqJFgLTx8jvF9+nI/T0WvqMi+r8T2dvKbhDbgjlZ4S4I9/zX965UgJmCOmlwNf8/vfrX5pGPY99bKnL6MtajVw2LRcX6x4tDnlZnm+JXRMM0+pkJmmxDMBSBBKXrb9YjesT5h2bKwoDR3eCK4IhHC3OSgjnoLwTZsinSTOSydvOJFcrPtM/H3i37YjK58vT/cfHynfrhCPsXeKCwe10R0zkFJWeHtD2xdBsxS7cFIopgypkapgjKcoXI6M2iGowpd1H4rnhGjpoq9zapfqWMT6T9IfJRHoVs1OTV4PtXu5U7nUNqYQTxMj5TxAPHldrGh20fTpGFILP4tVd6xjJmLZ8T3UONQ7qtctwpRcU4TmVfjzX/VTV5OUYCamlwPPfYlgO4GjHms9VRkkAQd1yyOLM/biqAmQzbimzoFAJqWENJibXAR21/ik9d+7H86U9m20pHdpA0kR7lsuITimvtJu6xs1pZcbV+RaCMSoyMMQR1pQwzC52zu7cH5SgJ2cYLELlh7nMmEnjGWebgivkC3ScUQDtWrIQsuiCJFRkUioL4KYtemyta9XoVObRaIeJsSb0rIQbVTisvvm7u648flFwvbbxz4tkhuUxg7BV3wit0ivd/IbZ7KGfLr5d2tppb/zI586mCkS3rJJuaNeeHX5CJiN4l4OPPHn36WyHDU03gvWhLb0QRw1mRZDl6bD4sMs2xBm2XbN37eEeKSa0ZiGQfog3ll3mtqoTjGdSk+3TydjgcuBzLQDZ4DKCJUptjVHO5/raYdoPHlHf+9pPWYLEkZKLiMls3XyxsjGGwRoqp6hCEV2Y8LyA6/QmnKMgqZLN6uBZRl8rlJkNVzy2u3ixZ7Ahkhg0xcoPkcYvZa2yclnIkrPe3ep5R077CapXXrtHZevHL/8eRn+wj/zV682O83E9NLxlh94SjkEVfBlLL4SPlx1MXBYrdkrwiaTXi0rV2WdUvLtTkiWE7tIKV8bF6qlD2najlHK6KHdaRFEct0hp0PYlJJ2rB3YzZZwMh2niYS3+62aIq80fT+dFbvshB1rQTbXTab3OTVDS7odN6lhjWMb4++eOLahEggs3l5i9OZFKKxjUaaazRhVeQ3jHU3VU5cDTdHniG/wJqdIUx+py+QO23U0k+tE2ZNcPDAOB6fnl19jRhV8et5FjIqyZe4k/VqaLntvp1rkdJtyHkUSvzV2lDp3JUGrhsaxo51u7pVO3yaYI6aXiC/6D59Wd0NRo4gHX4UOVeoipYJmSuHS5PbK1TRpnXesHYzdoOlGk20v7l2EUH9gE7VMu+byU9+j6f1M10Zv6Wn0LifkXRQl6TYp2kk1ofS8sFDEovIAdyw2yKlT0lOJbhnTOY2WJt5sEZqIYs2owCusoy5CE2HwhsHFlrx17FV9vs2uRAC4w9wuRS+7xOtUJn7h4T7Wroy6IJ8Xg6ZOX0rRYHtlVDFJ06bEZCVIGiw+jyIB9Izi1HHsyNyhmM/Nkwk5pdm6fhJB/dmv/M/uC1IC7lnEJCLvAH4EsMBfVNUf2Pn7G4GfBI7jdb5LVd8f//bHgG8lLDb+d1T1Z57vsV5xYvqSf/9pbV/n8Y1H4odWy9ANCjYb4V+SBABbX1wpCkqp1VbLN89njXqa3bpQEtKVkbBC6lYweEtteiw+jzPk2gXJQdFupQ4Qo4vJRzabyN0Fl6Vl07Z+YQJJdDKORAze5KJ2OvnTooHp3aVxjURI6U/WhJM9kUlK2crJMHFhgkTAAE05cFiH9eRprdOWqpyxZjYl6LshkVNQ2BfZi9tNJvHT/rpattPX3XQtbzm+JL2e6szw29t9p64TiZymSzl7tZmcDI42Nk4c5v4iJe5NxCQiFvhR4BuAjwEfFJH3qeovT6723cBPq+qPicgXA+8Hnog/vxP4EuB1wH8vIm9T1btaMbxixPRb/4136+aaYfMmxR+4oDjuCN+mjWPZdDRVaPsuiy6QhEQdiiHripIdqt/5oE33kuXNrPHDPV13nf5mxdN7y9nQcD4EndJxGUjJSJdJwojGvW01QGxNp8JvSFHS/Tk1WUaQFjHm1nc8Uh/JbTpXJxIUxUl+MJJLuTXm4HxaYBTqcOiYBuZa00RPBOGEtXb7/TcTgvIIxPVRZfxi2C87jqs1XoVz6i2FOYwbXabY1WvtdsK2HQRM3puX6lWXRalTUsrEZEZHyvQ+pL+X4qjigonwHozeW9b0W8ZweTHFRAGeLp/aFt9vpHQP8TXAr6rqrwOIyHuBbwSmxKTAYfz5CPhE/Pkbgfeqagv8hoj8ary/D9ztwV4RYvot//ZTqseG7gh8qTAI0hlMJ/hKKWrHIwdnXK9XDGrYK7o4w2YoI0G5nTrB7oxT+iBlIWIaQzHj7rJ+EnWUEkL2ZMAPQLmmMX10vxznoVpfcDY0OcVMJ4WPRJdOFOJl+cWVMJRq0K3tt1PLjyDKdFtCSKcGvIG00sl4jFc6Cenk4A3nff28r/k0rdqq28h2bWh6eWWD1e9e2bJXtHS+4Hyot+5nt540dgVtJutkkTKmgEn5HiKVZdFtRUVZIMvEhUDGrb6pvgTk+pbN6Z5naTqWcU1X8NkKX2arIaz1XpqORmKKp6MLqVehp9hK95ONbq/2vqkpbeHezco9Dnx08vvHgN+6c53vBX5WRL4d2AN+z+S2//PObR9/vgd7RYhpWArDErojH9L5zpAibgqlbnoeW55yszpn7aps+l6bgSUd5R0jGiHSSAOXu4Q0eJsXBFRmYN8GMjodmrxu51qxolfL2VDz2fV+vu+Loc4DpYGQam63C4woN5vzHJGlFNCrYO04fmFEqWWg1PTNG3bWmZjOTNcitVFKUNshWrQa1kPJug/EeFhveNPyORa255ObIz5+fsSqrdhvWrqhINisQFUMeVZsExcKJDJJ0U0Z/56K1ikVS5a+MBqdHZRtHMwdsnVsem6p1rNLbLCdpo7SAZv/6neuv2uNMnbm7rzv9Pe0dtxPIpyb5VkmnnR/hlD3aqTn0IQvHKeGjWomokRQtRln5ZA7myj3HV4aMd0UkV+Y/P4eVX3Pi7yPbwJ+QlXfLSJfC/wVEfnSl3Iw95yYfsu/9ZQODwnDUsnTIhI6cVo6WARB31mMAJwGU7NCPIfFJrd+0863cB2T/6WwO5HAdIat99MllIaLoWLjClwpFOaAZ9p9Pr064HQTHltVeNbsRaJwebNIOxQc1pswZa4W78ah0FSMTSdZ6vKFqAdaCUI9L0oft/FuXMl5V3O2qTHGc1B3NEU43tvrhm4ognOkddzul3y2M/zm6Q0+80yIkqsiEomzOG84X9d4L0E4KUpReOpyoLChMBzIMpzUo0gxEFZlXK6ppUWXiZRTLWs6AnK3WtKdG1O2a39ehcGZOBZjs7nfFIVJbpnbDhHpsXfrhSmNm17XT0SojYSO6tKE7m6Hjau4TBbeWvEYDSvX0/aZ2gy8+7f89P0XLfF5rQh/RlW/+nn+/nHgDZPfXx8vm+JbgXcAqOoHRKQBbr7A227hnhLTl/57T2v/qNDvhTkstcQxiFDwlspT1KGIe97X+Vs4CfRSWrNy9VY3JYX+0y7adFMIjDWPLha2PULngm3JeR++yU/7JgspjRDU0S64PBbG5yJxXQwclhtqO27gqMwQdtbFaMOpuWN9t5EwW+fdaC7XuTAp71IxOT7mZig439SsTptALvWQPbnXfcmt0yX+okSaVBuJqUhvGSa+SlJ4RAakCrNtPt5Hb0aluBehkCBa3CtaDotNJvepcyMEyUSJXEpK05oWbEdMgYi3Fe6DH9dcpcum0ZeNEVkm+xT1RRIxaI6ex8WWURCp40d5+qUR9EnpS6zI23CmWqdUm6pNzx/8wr99XxLSFu5NKvdB4K0i8iSBVN4JfPPOdT4CfD3wEyLydqABPgu8D/gpEXmKUPx+K/C/Pt+D3TNievsff1qHa4pbKL7SyWwWqFUoPaZyFKXLwj2vEixR7WjONbWlmHbDUl1pSkrpRJk6Q05n1tJ8VzcxewMo7ajKHpzFieZh2eR5nWpL/YT8krtBkDNsiyWnK7DD7yY7S6ZNHqne4+K4yGZTohsLVhmAM2e5WFd4Z3FtuNxWIcJ0g2UYbPDr7i0Mkt9RkWBZYo3Hx3m33hpKG4gwHVPSaaW5w2SEl6LPXBdD7xA25nR6x6N76vkddsTteKLrpEg/mWHbTQMDGY2/u+m8W1Lik+qAZbbIDdcPA7yVGT2XpnbKSHA5TZFW8ux6IEgJEH35mUlVBxH5NuBnCFKAv6SqHxKR7wN+QVXfB3wn8OMi8h0EevwWVVXgQyLy04RC+QD828/XkYN7QExf/oee1u4Q3J7iavC1ooUSmyWoUSg8pvDZJdGatDXEZbV3Fd0DgPzN22NzmjRdFjAlpWzED1nXMx04dd7Qx8tT5JKgUYyICqoWrKNkMiTLZOI9duemIyEQuma5+B7Rx/QtRG/hcoGtCX6Nl1H6EF32Brc2OMpA6IViFgN109M7w7qt6DYFflOEDme8TloikB4DxrVRSeA4NVXLYxuMfzc+eGC3Q41XE4lrrC8RX41U57nMTXNLiZ7sTcRjZHsoFiZK9x1hafo5vc69Wqz62GQI2iOnlhNX0/oid+xq09PEOh+yLRuwkbTSWq8LHxaa/oEv/PkHgpTuYfGbqEl6/85l3zP5+ZeB336X234/8P0v9LFeVmL68j/0tHZHMCxDlOQrRcuQxuElvGA2WJrYwlNVceGjdTGt6FjYjn3bbnkt+YmHxnQr6u7Q53RXmUfYxG2zzu+Y2KvQDUUWFE61Pdm7aNfzmmC3mk4AGEWXYxfQ542z0/m8i6EOxOTCpo3caRNwPkgLrCiLZYure7q2ZDipKE6DM6ZrPGodYpS+t2zWFe6sRFqDcaCFogvFVI503g9ujIyacuB6s+KwWufnU+/4WW3VyGIEeeEqOm/Yi18U00WW6fXfFUZaMVvvQ7rv9Jx9lFOkzl0qvtfGsbDdHTWjaWrska1B6vQl9Yn2iIuhZmF7Dos118oVjR3C+i0twwbjPP/mt277QJFSxL3QMb3SeNmI6c3vfkr922IEYEO7Nn2LY4LKGyH4LJWOuunZqzv2qlCnWRahq5Jaw0vb5jqCVZ9JoJ/UKpL1bDLwQqHzltVQBZuPSEpOx/Xczod0resLXHRvnJr/i0BROMqJcDB1irIVLrolvIRtZ4KEXi0XQ81p39AORfASso5Sg482hA6d94bSOppywFlhddpgz23uXIo3+F7wFwXqwbZCuY4nfaG4Bbho/KgKw2DoTIGqUNhgR3ytXnFUric76EYT/Sw6FRf8hqLvVNpse1hsQq1Mg6PnWd+MzgkT3ZRRYdo/vWyOr8hRm8tpZG36rUJ4jjY1vK9Jv7byVdgXOEmRB2+41S3ZuDI/p2vFBTfsOc+6fW67ZX5/SnHsmTb6NHk67ANHSsA8KzfFW/6Zj/DJ00P6wWKMBvtWJ2hKXUQpylhPMEpVDDTFkJ0Cb3cLzoeaZVGzLkuOyzKPF8CoV3JMx0Lu7AR1rsidtLQCu+1DC1012Mp6ZxjaAk11GTPO6on1uFKgJlvLwvYa7q3h2IkQcypZSMR54aq8YmgK5w3dYGnbkr4d3wZdW4pbBbaLkxJOMF0YUUmeZ+lpewtiQXzQhXlXQu0QgWEYP529s9xql4FwojQhLW+A0fgN2e5+pchw37ZY8Zy5hothTJuS+HPISxp21l5lbdb4fhVxxdLC9ixssL7NYyS5mRF1RiJ5tfvSdKx8WNE9bI0fhS6uV2Fhe26W5zxe3mIpLZ/or7HxZUjfjGKlj7qoMYJ6EDFHTBG/7Wf/qD687FivK6p64Gi5ZtMXtH2Jc4pqIKOm6rdUxIM3WwsYazuwLALBDN7Qy1hTmgooYVtR7XT7m9mg2T8otdSHIUzUp3VFurHIEEdijBJKRIoWgthgfp/SurR+elBLZQYWOq5FGgu1o+AyLSzoYxcuGein02lr8NaZYI6ngBfMJmq8NAyYSSQjM4AMkZSi3AIzWVTiCSVJFXZrn52zbFyRh2dTmz37Wl0yRpO0Pou4cn3lKp7r9ni2XVIYz17Rsm9DG34tVSTuYut+si1LvKwAKtNHdX2oE00HlBO2ZuLEs/IVJ8MiR6epCZH1anlsJrhDPDvsc2HqnPbVcVFFGvCFUPB+51t+4cGLlmCOmADe9BM/qG96vedWu6Q/qbE3PEf1hmVpOWs9q67EOUNdDuzXHRddyRBP1kQohQlT+Ptly1G5ZmHH0H6qVYI77TSyZikNaEpY5WPVR7IiElIgJXWC9gZxggwSmoU2FuWTAlIFkVGc6Lzh1hBSgqNqR1QoGiI4z9Zqp2ntxRoPMXrrfTJyCxP8CuAEiR7cphPMEOtxCDKA7cB0ZCvwYQG+AFcrviLU8qyCKGI9tnBU1RBFlWRf7NoOW5HedONs8qhKk/fnruZ8qDgu16SlDCd9w3ObveBi2VQ8tjjlsFjnwneSZUzfp+kMYEq1EtntIpF8qn2lYzkZFpwOTe4KJvFs64KlTKpVeRVOhrDbrTE9rRbs2w2N9DTSBQ94lH/tLb/4YBISzH5MCf/0W/6o/O6/9Z266kukD+/3ftnmD2Tvwld6VbgYxZRZv6PxA3tQbjiqNhwUm9CVE7cVAe3WKWycK/OTtvbgxxQgpVUu1m9UJUQSXsLG2akRf3oXJx9ViWSSnBw7H3RGtQ21sL2ipTDbkYbHbq3+SceRUpdNjLD6qFlyyRhNAylJH45J3ORfOyGlXjFDFKbuCb4MrgyuVrQKnTwETKFUlWNZBXJ38TUOSxyG0YI2kmnSOqXamSHoj876htVQUcdO11R/1A4FtzYLKjMwqMnpVJqDS5Gm7NTpGjtsuUakvzVmHPNJpJLT9PSfGgY/ptXTDmchniqWBFpfcOIWrHyVtUpBp+QefFJKmIkp4Oe+7t0C8Kbf+GEtCkcTlcTnfU1pg3c0jNPvaQe8jZHSUbXhqFxnwWKag0vT/MAdLpTZOiRFXmzXM3ofhIlbA6hK3A4Sh2WFnMoRUzmsYqO9rDB+81tRlmXHzfqcG+VF7hBN56ySLCGPWEiw3B21PUHkmdYhqUqo72ZCChGSOCjWYFvNKZwZwAzKkBhUYkOhCMeMCZGesY6qGFiUgZhS0b3aMZ0LNSWTLWUSUsdz7UpWQ7U1bJvGZ1ZS0g0Fz232WA3V+EUwsVtJSyhtUpjbUE+s87otzcSRLgOyPXI4xtHfvTSO86EKBOin9b5ASntFlyPCwRu8CPu2vUP0+qDj81B+Xym8rHKBf/oH/4h8zV//YxpGN6Z6Fc175q2JosXCUcXtqYZgHpZqIFPNjJ1anU5f8dR2Ng48DFGZPMSTf92XrNpya3WReglpU0qVRMdFXPEkt5WnLB3WaJgBjl3Co2rDI4tTHq1OKc0Q1OhbUd24ZjxEJdskugvnDH0fFNsStSfiwAyCGaBYK8V6JE+IhW+X6k0Si+ATYvJgbRBXFiaa8Zd+khbLJJUzeCVHhWmsxqlh7ePoTpRZXET3Ba9hcWZTDGyGgouu4qKrcoSZ3mcfdVnWeEqjcb126PCl45o6AiS7mWmamd5zGyOoygx0fsl5Xwf/pbgtJTiFOvZsx2Gx3lLiByvmUKPssHzzW//XBz9aAu4oMt6HeNkFlv/rO/7MHW/+V/y1/1BFlNJ4KAaqIpy8VfStvtUtckqWBIDLomO/6EbV8XQealIfCZPkjjoKHYfoxepUcM4gEoSMWQuV9FQwRks2ChgrR1kNVMWQIyYjyn7Z8rrFCTfKCwBWUdAHE0sVyIb8SS3pNGxo7XyyOtG4ccTlNBOVoIY34TYySefS/aiEiQtfSujUDWD6ybypUUzhUS/Z0yr4ZPd551pSvNuoYIcxkkukkJXfabdaESOQiaVMIuIku0gvpRXNglETegpRozTWt0oZVyqN1rh+NH3Dx85cgctD2gUbH760TruG1hX5fpMW6rDc8IbmOa4VF1QyxGHdkkZGZ4pvedsHXhukxBwxvWCc/toxyydP+bIbn+TjqyPOuzA06wl6nvVQcrapafsCY5S67Nmreg7rDcfVmkfqU/aLlt6Hqf7QsrbUxuXuzhSahJSDjTvS4uXOxLQppnJmjJjEeoxRynLAGh2/9cVzULY8XJ1Rm55z1+QFidNO4RBn9qZDxEY8rSvYuBIXU8rSOhTYdCW+D8cTyDEau8UunJpYT4qdN18Ivgp/1yLUl3ypaO2olj1N3aPx/m0kldctTnnT4hnOXcOHzx+JU/ca7EEiUe6a3jnCcR+ULU670OlyZXZDSDN9XR8+OqmO5EQRsVjjWdYddRGK79vR0rgkoDShEG0nqaXHRjmI0PqSjS+DbmpoOOmDUGuv7DgsN9l2OTlI1KanilbJhrDs9Niugj/8XbbbPJC4h8rvVxKvCDH9xr/7nXf9tnr7f/W96mKBPH3bqwqbocDIaM7mMKxdyVnf5AgEwEZPpan9bPC7DrUs7wy9gndhHbZMI6aEmNKJ8XkbSGE8i7LnsNpQmYEz12RNTG0GjIYJ/NbZ3LpOUdR0Fmw1VFz01STSMKy7kvVFja6KcDyDYHowk0gpkBHk8TsDGiMrVwd1vdvz2EUw2TterqntECIKE4hgr2h5qDgDYM+GGsxe0W6lTdNB1pWvovRh3Ji7cQUn3YLNUNANBe1g6boCN4SINc05pp/LatgafxkV4dFhUoa87Wa0vh1riilKajVEShdDnVP8w2rD9WrF9fKCA7th40ue7fcAuDXs0foyjqMEV4E0dvLOtz2gsoAHGK/6+qZf+Ve/964fmq/5639Mb60W3NosOIpWr6n1nArs61gMTYrmqW4GwPXhjFYX6ktqFGLkgZBHZIrSUVWOwobUY1l2HFYbjsqgem59gRdhGVvdd1hwSFBLBz2Pzcd00Vc5WvIqrPuS81UddFR9yNNMD6aXIBVwgSe1iHqkpGKwgah8Aa5RfK1QBmlAWTgOqpb9os3rog7KQEAXPpD7cbnK24unxnupE2YnJJGaCRtXcqtdctFV9C7OFjqTZ/vIzYx0nIL1d5oHT10DmkgcaYnAtJ7ko4i11YLVxJer9zab9B0XK26WZ1lwmYelSeucwmPsmRaP4V/5gr//miOlB6HW/6oT0/PhsnoVwP/u579dIYTxq6HKIsZkgOZSy1oU7S30BvGCikZRos+dOeLSR1v4OOkvW+S3V7QsTZejIReHR6dT9SEaCO1qk2xWNKzO7qP4zxrPEGUC6k2IhIqwjIFBQlG7Jw87JxF1ElSm9G2cQwwSgeRG2die42rN+VBhRdmzHUY0r6I6LDY5hfJq7hi6TUidzSQBCJGSza9pJqKI/LOEcZ50H0EUu+3jlNK4pDgPZDbOGBrxOF+OzhFxSDstEl3E55TIKJnEpXSwjoS0Z1r+91/w915zhJQxp3KvDv6b3/Hn7vqh+4af+w5to+eROkFai70ItRxfK75OZzrhxI4uB84JfVezFmVYGhZlTymea8WKo2LFM/0Ba1dy7uotIWFwXXQxWpqmc2MnMY3d9HFYuKwGFHCtRTuD9jaMnvSBnBIRAWGnRFR6D3vKcOCDmBJAJS+KrIxjYTqcDXYtRVyPnexAmtym9/idljyMaZTXafRy+RLNKST2p4WQCpv4xdA7m583MBa9U2SmOxtn4qDtbiSa1oMv4tjKuavDsdqCo2LFo8UJjenp1FKJo5Ge3/fmf/TaJSXm4veVxN/43U/f9UP5Rf/Pp3VYjPNx/WGcrHcWd1FQPlugFs6uF1hR3rh3i9dXz/F4eYsPDHt8ttvnmc0+rQuzYsf1muvVij0b2t2nQ5NdMo14Guuzvch5P3pn1+XAou5YlTXtRQUXFruB8lwxHbhGoIxSgVj8dhX0R47y2oahK4Jvkycvp0xpWu5WkkZ5DHbSmoew0dckK5DYPEidr17NZM9d2KTibFI5mrByK3bddIuQNG+6SdjyCJ8U2pOLZDrO/HcGShl3BhYSnCf2bcvSdtzql5z1DRcSZB3Xi3OO7YpGwqKBUhy/64l/8pompSiQe7WP4vPGA0dMz4d//Ce+464f2i/83qd17xPKxeuE4UhYbSr+8e2HOekblkXHR86u88z5Hpt1hbGO64crrtehELt2Jf/jZ9/Mxz92HQSWx2u+8KHP8BVHH6dXyy/degMfvXXM+qwJ4zCV48aNcxZ1R3tRYVuhOoP6JHa46lhMjue4FiFa2n/0nEcPz/jos8e0g0Gsp657jppNnD8bF0BmYaqaLGBMxeCEZAuyigsXdq1kCvEsij7/riohgIuRn0AQytogFTAmXFZGeUDqyCUk98lexwUApTjK6Elw5hue6Q+4GOq81GDfjjN5DpOtTR6rTrhenNOpxSE00s+kFDFHTA8Q9j+mlBfKrevK4sYaVeHTzx3yyU9dC8LMzoQB243gS+UzmzLP+K1dycm6QVYWDGyqio+dHbMaKm5vFnz600dUH684eEYo1sqwKHn2yQrdHzBnBcWFIEPwRNcUjsCoYYq/r9cVt8sFdTWwuNFztNjw8PKMR5vT7NsdFg64LcVziIxGWUAoeIeWevAlL7cGoKdrjlIzITmMjjWl2BW1kaRkMsoT5QpTK5OgU4papTi+YySsBDcYWl9yq9/jbAhyjNTVq03o4q3i+qy9ouVmec5DxWnWKQHYB6Gw8nLhAXgpZmKK+MW/+Icv/bZ98qf+tDKE+Tq7FopzQa3QSckniyM6Z4OI0XjMzTbUjdYFz/zmdZ7tbyC9UA5QngnFKqi5ZVCaZwxdV2K7EBm5WsKavdQtTCN8QT9KcSF0n2p4ZlVgGkdVD5SF47RrqIzjuFxTGLflVYQPrg5WPc4LvaQ0b6z1JJ+rwnhqjX7aPixPmNrKeJ3oUieF7hw9pbQuktM0WkpuClPCC5cbPIqfkGEhLvtjJdeGhH3bclSsuF6cT3YFFhg8X/fmD8/REvNIymsGv/HN/8Hn/MA/8Vf+jIpRbBGHZm8XLD4tNM+Gs7k9DjIAM4BxillD/axk25W0OUaNYHrFrhW7Hq/vKqE7FLQQfFdi12FE5KTc57lG+fCh4+Dhc153eJo3rWy6ksJ6Hj4456DccNY3DN6wKHqWRUdjh61uVymjo6WzPZ0v2ERLmsHZ4Pg5WFSJavq4BipubBHiCEqsq12r1tRm4DT6N6XUbWla8NCLzSLUYAaoWYrR+rA0oIgKdghR3lGx4rq9yDUlp+WDa13yUqE615hmBPzm7/9jn9fJ8SXf9bTmkZQBqgulPHdUt7vgynm9wpcFLVCeCMe/5inWYUdfvzSsHi456w/5rHWcXTQMzywobxs2S8U9YVjc6Hn2Ysn5RYMbTFDAE9Tuewcb3nztOV6/vM3CdiH98mGcpvPBcK8bbJjrS0LYIhS5w/Zel6UaVeEojQ+q8+Y2tQz0ep2TfhF9lwzHdkUV62C92pyCleI4smv27YaTYUnrizzoC2F85siuObBrLMpGS37/W//nmZQuwRwxzXhZ8KEfuHtR/oXgq/7AU6pGacqB584rFp+0LD6rrB821G/t+e3Xf43/RZ7gQ+vH0JOK6llLsQrdvvPHKz5RBi+s06EOkdJQcjFUnHcVbR+90aM/ekrXTByirYpATEmUmjRVj5W3ObAbzl1QblsJFr6HZsOxXWHEc9vtZZ1VbXqObZhFLMVxMixzHSpddmjW7JmWXgt+/1tmUrorZmKacRXwSz9+eX3sheBN/68f0nVX8svPPMLp2RJ3USB98E/XpaNcdmM9iXE2LpHSsgxF90XRc1hu8AgHRcuB3XDDnvN4fSvXvJa25cBsWMpAb8PyyZYSr4bGrLlhz+m14EwWrEwozCeZQyM91+05lTi+7s3/cCal58EcMc247/H4G57l2bM9Lk4W2M9UNKsgPnW10lfbjg7qw8SzqlAWDmt6ajtkIeYmzuktbMeFr9kzLQ8Vp5TiOHdNHtqtcuG9YKNFFoA+6/b5dH/MiVvg1OTxlTT3Vl2y8GHGDpTQqbjPMRPTaxz/0+/9wc8r+vjdf+s79VMnB2xWVXAkLR1veOhWmMlbBAL6ZHfMh88fYeMKvmrxGxzQ82vdI3x49SitL3m0PsGifGo44jc3N3AYrhWrvO1kz7Q4hNt++doeNXmhuP95aSamGZ8fknvpFE/+1J/Wo2rNvm1Z+Yp/cvYQv3HrBt1g+V+uv4U315/hM/0hDhN0ScUZB2bNJ/QaANeKFW+qn+EN5bPRZtlw6puZlF4g5lRuxoxLsCux+J1/89/T09MFvrX80ukbMUdBBvDG+jmuF+c8WpxwbFcsTcu1csXN4ixcZtb0avltT86K7heFWS4wY8bnxt/++ndtEcu3/dI367VyxU17xkPFKcdmhUXZMy3Xios8/wbw25749ZmUXiTmiGnGjJeAP/9VP5XJ5j/+8O9UStiTIK4M4knDbb/k656c1dyvVczENONVxR/8wr+9RT7f94/+Je3V8ie/7L+eSemlYLbWnTHj3uCfnD/8ah/CfYswK3f/M9NMTDOuFL7nS//aHCl9vpitdWfMmHHVMEdMM2bMuFqYa0wzZsy4ephtT2bMmHEFMeuYZsyYcfXwAERM5nNfZcaMGfcN4or5F/vvhUBE3iEiHxaRXxWR77rk70+LyP8W//3/ROT25G8/JCIfEpFfEZE/KyLP232dI6YZMx403IOISUQs8KPANwAfAz4oIu9T1V8eH1a/Y3L9bwe+Mv7824DfDnx5/PPfBX4n8D/c7fHmiGnGjAcN+hL+fW58DfCrqvrrqtoB7wW+8Xmu/03AfzY5ogaogBoogU8/34PNxDRjxgMGUX3R/14AHgc+Ovn9Y/GyOx9f5E3Ak8DfAlDVDwA/B3wy/vsZVf2V53uwmZhmzHjQkDalvJh/cFNEfmHy7//+eRzBO4H/UlUdgIi8BXg78HoCmX2diPyO57uDucY0Y8aDBOWljqQ8o6pf/Tx//zjwhsnvr4+XXYZ3Av/25Pd/FfifVfUcQET+O+BrgZ+/24PNEdOMGQ8QhBefxr3AVO6DwFtF5EkRqQjk8747Hl/ki4BrwAcmF38E+J0iUohISSh8z6ncjBmvKby0VO5z3KUOwLcBP0MglZ9W1Q+JyPeJyL88ueo7gfeqbt3pfwn8GvAPgb8P/H1V/WvP93hzKjdjxowXBFV9P/D+ncu+Z+f3773kdg74N1/MY83ENGPGg4YHQPk9E9OMGQ8SXnrx+0phJqYZMx4wzH5MM2bMuHqYiWnGjBlXC7Mf04wZM64alJmYZsyYcQUxF79nzJhx1TAXv2fMmHH1MBPTjBkzrhQU8DMxzZgx40ph7srNmDHjKmImphkzZlw5zMQ0Y8aMK4W5xjRjxoyrBwW9/4VMMzHNmPGg4QFI5WYHyxkzZlw5zBHTjBkPEuYa04wZM64kHoBUbiamGTMeNMzENGPGjKuFWfk9Y8aMqwYF/CwXmDFjxlXDHDHNmDHjymEmphkzZlwt6CwXmDFjxhWDgs4jKTNmzLhymCOmGTNmXDnMNaYZM2ZcKajOcoEZM2ZcQcwR04wZM64adI6YZsyYcbUwj6TMmDHjqmG2PZkxY8aVxAOgY5odLGfMmHHlMEdMM2Y8QFBA51RuxowZVwo6b0mZMWPGFcQcMc2YMePq4QGImEQfAM3DjBkzAkTkrwM3X8JNn1HVd7zcx/NSMRPTjBkzrhxmucCMGTOuHGZimjFjxpXDTEwzZsy4cpiJacaMGVcOMzHNmDHjyuH/D6+Irv8mJD63AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(eopatch_spot.data['NDVI'][1,].astype(float), vmax = 0.88)\n", + "plt.colorbar()\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "014fec5d-3a5c-444d-a689-c7299f16c3f5", + "metadata": {}, + "source": [ + "If you would like to save the EOPatch, you can \n", + "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n", + " - save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask" + ] + }, + { + "cell_type": "markdown", + "id": "4bf03692-670f-4fe3-9bfc-4e852bf2146c", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Extract AIRBUS Pleaides data" + ] + }, + { + "cell_type": "markdown", + "id": "9bae7137-7061-42d1-8298-3e16a9cd8dc8", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Airbus Pleiades have a Panchromatic band at 0.5m and VIS-NIR at 1.5m. On SH, the price is roughly 10€ for 1km2 of order, with a minimal order of 0.25km2 (2€50)." + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "id": "f9890bf5-ad4c-47e1-9a8a-b13f8b15026c", + "metadata": {}, + "outputs": [], + "source": [ + "#Define the provider as follows for Planetscope\n", + "provider_pleaides = ('AIRBUS', 'PHR')\n", + "#In case, you can use as follows to run the example instead of ordering again data to avoid to run the order and consume credits for nothing\n", + "order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "id": "67699b0c-0e4e-4989-8f3a-f3592b6f3968", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"dbf7ea0f-6f74-4e6d-ae03-1b5455a6034c\",\"exp\":1643715904,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"b49cfd00-51a0-45f9-91a3-6707bf5fe210\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n", + "e7f5c398-0d23-4f9d-a6a8-03b2b0632554\n", + "0.25\n", + "CREATED\n" + ] + } + ], + "source": [ + "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", + "order_id_pleiades, results_pleiades = download_workflow.execute_query(provider_pleaides, name_query='example pleaides')" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "id": "5a11b30b-d13e-4d8b-b553-63ae9d1768e0", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RUNNING\n" + ] + } + ], + "source": [ + "collection_id_pleaides = download_workflow.confirm_order(order_id_pleiades)" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "id": "5f119d2f-7f01-4863-b694-c37393884ae1", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"2eaec86d-af61-4b97-8b5c-dcced894e3b3\",\"exp\":1643717164,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"c86af45c-7440-47c8-b819-584ca6ef0b57\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n" + ] + }, + { + "data": { + "text/plain": [ + "'RUNNING'" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", + "download_workflow.check_status( order_id_pleiades)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "id": "adff8240-4e90-4427-ab4c-3c1b9c4d8ff4", + "metadata": {}, + "outputs": [], + "source": [ + "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + "eopatch_pleaides = download_workflow.get_data(order_id = order_id_pleiades,\n", + " collection_id = collection_id_pleaides,\n", + " provider = provider_pleaides,\n", + " resolution = 0.5,\n", + " pansharpen = True, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" + ] + }, + { + "cell_type": "code", + "execution_count": 187, + "id": "0e3c0377-4a6e-474c-b93e-15d3e4df5d95", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[datetime.datetime(2020, 6, 6, 11, 21, 32, 600000)]" + ] + }, + "execution_count": 187, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eopatch_pleaides.timestamp" + ] + }, + { + "cell_type": "code", + "execution_count": 178, + "id": "1bd9865f-37b0-4397-9a30-6bdc60338c5f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(np.clip(eopatch_pleaides['data']['BANDS'][..., [2, 1, 0]][0,], 0, 1));\n", + "plt.axis(False);\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "id": "3d18234b-b676-4a43-9ad6-35887cce5c8b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(np.clip(eopatch_pleaides['data']['BANDS-PAN'][..., [2, 1, 0]][0,], 0, 1));\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 185, + "id": "d78551f1-d299-4e9e-af30-2c15e09c887c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(eopatch_pleaides.data['NDVI'][0,].astype(float),vmin = 0.2, vmax = 0.9)\n", + "plt.colorbar()\n", + "plt.axis(False);\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "id": "999353b8-cff7-4784-9d81-9cc4f5d904b7", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "source": [ + "If you would like to save the EOPatch, you can \n", + "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n", + "- save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask" + ], + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "eo-crops", + "language": "python", + "name": "eo-crops" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/eo-crops/examples/layers/POLYGON.dbf b/eo-crops/examples/layers/POLYGON.dbf new file mode 100644 index 0000000000000000000000000000000000000000..2690181cf3246d26b9275ac5df94758d0e19ead1 GIT binary patch literal 34 Vcmd*W0FhXL6aW~c0O0@t literal 0 HcmV?d00001 diff --git a/eo-crops/examples/layers/POLYGON.prj b/eo-crops/examples/layers/POLYGON.prj new file mode 100644 index 0000000..a30c00a --- /dev/null +++ b/eo-crops/examples/layers/POLYGON.prj @@ -0,0 +1 @@ +GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]] \ No newline at end of file diff --git a/eo-crops/examples/layers/POLYGON.shp b/eo-crops/examples/layers/POLYGON.shp new file mode 100644 index 0000000000000000000000000000000000000000..4e489ec72280050f4f19c4643871088b771273f9 GIT binary patch literal 332 zcmZQzQ0HR64wk)OW?*22$W72{;yobPmLKLG=HUPon&4Q)dtlx!#+#iGK6VojqKrUh z0WoHQ6mlcnH@Juq(<=0.23.1 +setuptools>=57.0.0 +scipy>=0.19 +matplotlib>=2.2.2 +seaborn>=0.9.0 + diff --git a/eo-crops/setup.py b/eo-crops/setup.py new file mode 100644 index 0000000..56c1d2a --- /dev/null +++ b/eo-crops/setup.py @@ -0,0 +1,21 @@ +import os +from setuptools import setup, find_packages + + +def parse_requirements(file): + return sorted(set( + line.partition('#')[0].strip() + for line in open(os.path.join(os.path.dirname(__file__), file)) + ) - set('')) + + +setup( + name='eocrops', + python_requires='>=3.7', + version='1.0.0', + description='Wrapper designed for crop monitoring using Earth Observation data.', + author='Johann Desloires', + author_email='johann.desloires@gmail.com', + packages=find_packages(), + package_data={'eocrops': ['environment.yml']} +) From ad2c86b09327a3dbe3a6f19f01939d0a8dccc1fe Mon Sep 17 00:00:00 2001 From: Johann Desloires <52990046+j-desloires@users.noreply.github.com> Date: Thu, 3 Feb 2022 12:30:33 +0100 Subject: [PATCH 06/21] Update Sentinel data.ipynb --- eo-crops/examples/Sentinel data.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/eo-crops/examples/Sentinel data.ipynb b/eo-crops/examples/Sentinel data.ipynb index 53c23d3..b7b386f 100644 --- a/eo-crops/examples/Sentinel data.ipynb +++ b/eo-crops/examples/Sentinel data.ipynb @@ -13,7 +13,7 @@ "id": "7e8ef3e1-fac8-4e7d-b619-1d529d2da6d2", "metadata": {}, "source": [ - "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and predfin. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n", + "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and eo-learn. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n", "\n", "The workflow for agriculture purposes is as follows :\n", "\n", @@ -443,4 +443,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From cdb90ab40240c4b9c635b6db22d6df776d6061ba Mon Sep 17 00:00:00 2001 From: Johann Desloires <52990046+j-desloires@users.noreply.github.com> Date: Thu, 3 Feb 2022 12:30:55 +0100 Subject: [PATCH 07/21] Update VHRS data.ipynb --- eo-crops/examples/VHRS data.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb index 92e040e..9691e1c 100644 --- a/eo-crops/examples/VHRS data.ipynb +++ b/eo-crops/examples/VHRS data.ipynb @@ -13,7 +13,7 @@ "id": "7e8ef3e1-fac8-4e7d-b619-1d529d2da6d2", "metadata": {}, "source": [ - "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and predfin. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n", + "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and eo-learn. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n", "\n", "The workflow for agriculture purposes is as follows :\n", "\n", @@ -1016,4 +1016,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From 51735a113e5cd9115a40c00ad90c287148bff71e Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 3 Feb 2022 12:34:39 +0100 Subject: [PATCH 08/21] correct markdown notebook --- eo-crops/examples/Sentinel data.ipynb | 4 ++-- eo-crops/examples/VHRS data.ipynb | 10 ++++------ 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/eo-crops/examples/Sentinel data.ipynb b/eo-crops/examples/Sentinel data.ipynb index b7b386f..11deec3 100644 --- a/eo-crops/examples/Sentinel data.ipynb +++ b/eo-crops/examples/Sentinel data.ipynb @@ -21,7 +21,7 @@ "\n", "2) Extract Sentinel-2 data and compute averaged NDVI time series to get a summary of the season vegetation dynamic.\n", "\n", - "2) Extract Sentinel-1 data and apply multitemporal speckle filtering" + "3) Extract Sentinel-1 data and apply multitemporal speckle filtering" ] }, { @@ -443,4 +443,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb index 9691e1c..2951177 100644 --- a/eo-crops/examples/VHRS data.ipynb +++ b/eo-crops/examples/VHRS data.ipynb @@ -976,23 +976,21 @@ ] }, { - "cell_type": "code", + "cell_type": "markdown", "id": "999353b8-cff7-4784-9d81-9cc4f5d904b7", "metadata": { "jupyter": { "outputs_hidden": false }, "pycharm": { - "name": "#%%\n" + "name": "#%% md\n" } }, "source": [ "If you would like to save the EOPatch, you can \n", "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n", "- save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask" - ], - "execution_count": null, - "outputs": [] + ] } ], "metadata": { @@ -1016,4 +1014,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From 12b94ca85af845476ad42a934b52427c28ffc427 Mon Sep 17 00:00:00 2001 From: Johann Desloires <52990046+j-desloires@users.noreply.github.com> Date: Thu, 3 Feb 2022 12:35:17 +0100 Subject: [PATCH 09/21] Update readme.MD --- eo-crops/readme.MD | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eo-crops/readme.MD b/eo-crops/readme.MD index f6fc8a6..81ed1cb 100644 --- a/eo-crops/readme.MD +++ b/eo-crops/readme.MD @@ -1,6 +1,6 @@ Earth observations for crop monitoring. -Small python module that gathers awesome functionalities from Sentinelhub, eo-learn python package and OrfeoToolBo for basics download and data processing. +Small python module that gathers awesome functionalities from Sentinelhub, eo-learn python package and OrfeoToolBox for basics download and data processing. # Installation From 11a2897685f9e678970a62dcfde128a0f415cacf Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 3 Feb 2022 13:59:03 +0100 Subject: [PATCH 10/21] correct markdown notebook --- eo-crops/examples/VHRS data.ipynb | 347 +++++++++++++----------------- 1 file changed, 153 insertions(+), 194 deletions(-) diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb index 2951177..517287f 100644 --- a/eo-crops/examples/VHRS data.ipynb +++ b/eo-crops/examples/VHRS data.ipynb @@ -196,27 +196,6 @@ "id": "d31f67f3-7a66-417b-aad8-0f61c39bb441", "metadata": {}, "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 203, - "id": "ed4fb29a-cfcf-431f-8d53-5b93e566646e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "#NDVI\n", "plt.figure(figsize=(5, 5))\n", @@ -227,15 +206,15 @@ }, { "cell_type": "code", - "execution_count": 49, - "id": "9f9105ab-0a88-4ea8-a1c7-381729118bb7", + "execution_count": 203, + "id": "ed4fb29a-cfcf-431f-8d53-5b93e566646e", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -259,19 +238,21 @@ }, { "cell_type": "code", - "execution_count": 206, - "id": "52bd3b0c-e232-4ccf-8155-9a97ab2e9d46", + "execution_count": 49, + "id": "9f9105ab-0a88-4ea8-a1c7-381729118bb7", "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "datetime.datetime(2020, 3, 28, 0, 0)" + "
" ] }, - "execution_count": 206, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ @@ -282,18 +263,24 @@ }, { "cell_type": "markdown", - "id": "7876d697-aa75-4db2-947b-d1e6a4d13fae", - "metadata": {}, + "id": "52bd3b0c-e232-4ccf-8155-9a97ab2e9d46", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## VHRS data" ] }, { "cell_type": "code", - "execution_count": 128, - "id": "d851a64e-d689-486e-8965-37a7ca9b6926", - "metadata": {}, - "outputs": [], + "id": "7876d697-aa75-4db2-947b-d1e6a4d13fae", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "source": [ "#Define the time period\n", "time_period_vhrs = ('2020-04-15', '2020-06-15')\n", @@ -302,27 +289,48 @@ " time_stamp = time_period_vhrs,\n", " config = config,\n", " maxCloudCoverage=10)" - ] + ], + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "id": "08b85a00-3c63-4c31-b8b8-400d15777eca", - "metadata": {}, + "id": "d851a64e-d689-486e-8965-37a7ca9b6926", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Extract Planetscope data" ] }, { "cell_type": "code", - "execution_count": 133, - "id": "e5a6cfb6-dee3-4f11-aa83-3079f113d67c", - "metadata": {}, - "outputs": [], + "id": "08b85a00-3c63-4c31-b8b8-400d15777eca", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "source": [ "#Define the provider as follows for Planetscope\n", "provider_planet = ('PLANET', 'PSScene4Band')\n", "#You can retrieve order id and collection ID on your SH account (https://apps.sentinel-hub.com/dashboard/#/tpdi) instead of doing a request again\n", "order_id, collection_id = '\t2f900fad-1f5e-4a46-b6da-327012d400e1', '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 133, + "id": "e5a6cfb6-dee3-4f11-aa83-3079f113d67c", + "metadata": {}, + "outputs": [], + "source": [ + "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", + "order_id, results = download_workflow.execute_query(provider_planet, name_query='Example Planet')" ] }, { @@ -343,8 +351,8 @@ } ], "source": [ - "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", - "order_id, results = download_workflow.execute_query(provider_planet, name_query='Example Planet')" + "#You can access to all the meta data in results.\n", + "len(results['features'])" ] }, { @@ -365,8 +373,8 @@ } ], "source": [ - "#You can access to all the meta data in results.\n", - "len(results['features'])" + "#Check the status of the order. Image will not be available \n", + "collection_id = download_workflow.confirm_order(order_id)" ] }, { @@ -376,8 +384,8 @@ "metadata": {}, "outputs": [], "source": [ - "#Check the status of the order. Image will not be available \n", - "collection_id = download_workflow.confirm_order(order_id)" + "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", + "download_workflow.check_status(order_id)" ] }, { @@ -404,28 +412,17 @@ "output_type": "execute_result" } ], - "source": [ - "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", - "download_workflow.check_status(order_id)" - ] - }, - { - "cell_type": "code", - "execution_count": 134, - "id": "8abef4fe-dcf7-46f1-b0ed-2da4ea4db777", - "metadata": {}, - "outputs": [], "source": [ "eopatch_planet = download_workflow.get_data(order_id = order_id,\n", " collection_id = collection_id,\n", - " provider = provider,\n", + " provider = provider_planet,\n", " resolution = 3)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "fb721590-2df1-4d97-8603-e2cd4b3ed8eb", + "execution_count": 134, + "id": "8abef4fe-dcf7-46f1-b0ed-2da4ea4db777", "metadata": {}, "outputs": [], "source": [ @@ -435,23 +432,10 @@ }, { "cell_type": "code", - "execution_count": 148, - "id": "bfef88ed-ab7d-4c68-ac12-0e02921ad578", + "execution_count": null, + "id": "fb721590-2df1-4d97-8603-e2cd4b3ed8eb", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(np.clip(eopatch_planet['data']['BANDS'][..., [2, 1, 0]][7,], 0, 1));\n", @@ -461,15 +445,15 @@ }, { "cell_type": "code", - "execution_count": 142, - "id": "35ec81f8-30b8-4389-880f-9f1dda0e04fe", + "execution_count": 148, + "id": "bfef88ed-ab7d-4c68-ac12-0e02921ad578", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -493,15 +477,15 @@ }, { "cell_type": "code", - "execution_count": 147, - "id": "b37209c2-c43f-4ae0-b73c-b26ae34d7f36", + "execution_count": 142, + "id": "35ec81f8-30b8-4389-880f-9f1dda0e04fe", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -521,8 +505,12 @@ }, { "cell_type": "markdown", - "id": "4ab4a072-ba7b-44bf-ae99-61b5430ac322", - "metadata": {}, + "id": "b37209c2-c43f-4ae0-b73c-b26ae34d7f36", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "If you would like to save the EOPatch, you can \n", "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n", @@ -531,15 +519,28 @@ }, { "cell_type": "markdown", + "id": "4ab4a072-ba7b-44bf-ae99-61b5430ac322", + "metadata": {}, + "source": [ + "### Extract AIRBUS SPOT data" + ] + }, + { + "cell_type": "code", "id": "de10acec-05ac-456f-bc58-dc7470807db4", "metadata": { "pycharm": { - "name": "#%% md\n" + "name": "#%%\n" } }, "source": [ - "### Extract AIRBUS SPOT data" - ] + "#Define the provider as follows for Planetscope\n", + "provider_spot = ('AIRBUS', 'SPOT')\n", + "#can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", + "order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'" + ], + "execution_count": null, + "outputs": [] }, { "cell_type": "code", @@ -548,10 +549,8 @@ "metadata": {}, "outputs": [], "source": [ - "#Define the provider as follows for Planetscope\n", - "provider_spot = ('AIRBUS', 'SPOT')\n", - "#can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", - "order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'" + "#Define the workflow to get your order_id and meta data. \n", + "order_id_spot, results_spot = download_workflow.execute_query(provider_spot, name_query='example spot')" ] }, { @@ -576,8 +575,7 @@ } ], "source": [ - "#Define the workflow to get your order_id and meta data. \n", - "order_id_spot, results_spot = download_workflow.execute_query(provider_spot, name_query='example spot')" + "collection_id_spot = download_workflow.confirm_order(order_id_spot)" ] }, { @@ -595,7 +593,8 @@ } ], "source": [ - "collection_id_spot = download_workflow.confirm_order(order_id_spot)" + "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", + "download_workflow.check_status(order_id_spot)" ] }, { @@ -623,8 +622,13 @@ } ], "source": [ - "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", - "download_workflow.check_status(order_id_spot)" + "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + "eopatch_spot = download_workflow.get_data(order_id = order_id_spot,\n", + " collection_id = collection_id_spot,\n", + " provider = provider_spot,\n", + " resolution = 1.5,\n", + " pansharpen = True,\n", + " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" ] }, { @@ -634,13 +638,9 @@ "metadata": {}, "outputs": [], "source": [ - "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", - "eopatch_spot = download_workflow.get_data(order_id = order_id_spot,\n", - " collection_id = collection_id_spot,\n", - " provider = provider_spot,\n", - " resolution = 1.5,\n", - " pansharpen = True,\n", - " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" + "#Reset the download_workflow method if you would like to execute new queries. \n", + "# t is a way to prevent to download multiple times the same image and consume credits for nothing.\n", + "download_workflow.reset_workflow()" ] }, { @@ -650,9 +650,7 @@ "metadata": {}, "outputs": [], "source": [ - "#Reset the download_workflow method if you would like to execute new queries. \n", - "# t is a way to prevent to download multiple times the same image and consume credits for nothing.\n", - "download_workflow.reset_workflow()" + "eopatch_spot.timestamp " ] }, { @@ -675,7 +673,10 @@ } ], "source": [ - "eopatch_spot.timestamp " + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(np.clip(eopatch_spot['data']['BANDS'][..., [2, 1, 0]][1,], 0, 1));\n", + "plt.axis(False);\n", + "plt.show()\n" ] }, { @@ -699,40 +700,24 @@ ], "source": [ "plt.figure(figsize=(5, 5))\n", - "plt.imshow(np.clip(eopatch_spot['data']['BANDS'][..., [2, 1, 0]][1,], 0, 1));\n", + "plt.imshow(eopatch_spot.data['NDVI'][1,].astype(float), vmax = 0.88)\n", + "plt.colorbar()\n", "plt.axis(False);\n", - "plt.show()\n" + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": 197, + "cell_type": "markdown", "id": "d589e21b-71a7-4076-a70c-dfe5835e02e1", "metadata": { "pycharm": { - "name": "#%%\n" + "name": "#%% md\n" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ - "plt.figure(figsize=(5, 5))\n", - "plt.imshow(eopatch_spot.data['NDVI'][1,].astype(float), vmax = 0.88)\n", - "plt.colorbar()\n", - "plt.axis(False);\n", - "plt.show()" + "If you would like to save the EOPatch, you can \n", + "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n", + " - save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask" ] }, { @@ -740,9 +725,7 @@ "id": "014fec5d-3a5c-444d-a689-c7299f16c3f5", "metadata": {}, "source": [ - "If you would like to save the EOPatch, you can \n", - "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n", - " - save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask" + "### Extract AIRBUS Pleaides data" ] }, { @@ -754,20 +737,25 @@ } }, "source": [ - "### Extract AIRBUS Pleaides data" + "Airbus Pleiades have a Panchromatic band at 0.5m and VIS-NIR at 1.5m. On SH, the price is roughly 10€ for 1km2 of order, with a minimal order of 0.25km2 (2€50)." ] }, { - "cell_type": "markdown", + "cell_type": "code", "id": "9bae7137-7061-42d1-8298-3e16a9cd8dc8", "metadata": { "pycharm": { - "name": "#%% md\n" + "name": "#%%\n" } }, "source": [ - "Airbus Pleiades have a Panchromatic band at 0.5m and VIS-NIR at 1.5m. On SH, the price is roughly 10€ for 1km2 of order, with a minimal order of 0.25km2 (2€50)." - ] + "#Define the provider as follows for Planetscope\n", + "provider_pleaides = ('AIRBUS', 'PHR')\n", + "#In case, you can use as follows to run the example instead of ordering again data to avoid to run the order and consume credits for nothing\n", + "order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'" + ], + "execution_count": null, + "outputs": [] }, { "cell_type": "code", @@ -776,10 +764,8 @@ "metadata": {}, "outputs": [], "source": [ - "#Define the provider as follows for Planetscope\n", - "provider_pleaides = ('AIRBUS', 'PHR')\n", - "#In case, you can use as follows to run the example instead of ordering again data to avoid to run the order and consume credits for nothing\n", - "order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'" + "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", + "order_id_pleiades, results_pleiades = download_workflow.execute_query(provider_pleaides, name_query='example pleaides')" ] }, { @@ -800,8 +786,7 @@ } ], "source": [ - "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", - "order_id_pleiades, results_pleiades = download_workflow.execute_query(provider_pleaides, name_query='example pleaides')" + "collection_id_pleaides = download_workflow.confirm_order(order_id_pleiades)" ] }, { @@ -823,7 +808,8 @@ } ], "source": [ - "collection_id_pleaides = download_workflow.confirm_order(order_id_pleiades)" + "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", + "download_workflow.check_status( order_id_pleiades)\n" ] }, { @@ -855,8 +841,13 @@ } ], "source": [ - "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", - "download_workflow.check_status( order_id_pleiades)\n" + "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + "eopatch_pleaides = download_workflow.get_data(order_id = order_id_pleiades,\n", + " collection_id = collection_id_pleaides,\n", + " provider = provider_pleaides,\n", + " resolution = 0.5,\n", + " pansharpen = True, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" ] }, { @@ -866,13 +857,7 @@ "metadata": {}, "outputs": [], "source": [ - "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", - "eopatch_pleaides = download_workflow.get_data(order_id = order_id_pleiades,\n", - " collection_id = collection_id_pleaides,\n", - " provider = provider_pleaides,\n", - " resolution = 0.5,\n", - " pansharpen = True, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", - " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" + "eopatch_pleaides.timestamp" ] }, { @@ -893,7 +878,10 @@ } ], "source": [ - "eopatch_pleaides.timestamp" + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(np.clip(eopatch_pleaides['data']['BANDS'][..., [2, 1, 0]][0,], 0, 1));\n", + "plt.axis(False);\n", + "plt.show()\n" ] }, { @@ -917,9 +905,9 @@ ], "source": [ "plt.figure(figsize=(5, 5))\n", - "plt.imshow(np.clip(eopatch_pleaides['data']['BANDS'][..., [2, 1, 0]][0,], 0, 1));\n", + "plt.imshow(np.clip(eopatch_pleaides['data']['BANDS-PAN'][..., [2, 1, 0]][0,], 0, 1));\n", "plt.axis(False);\n", - "plt.show()\n" + "plt.show()" ] }, { @@ -941,32 +929,6 @@ "output_type": "display_data" } ], - "source": [ - "plt.figure(figsize=(5, 5))\n", - "plt.imshow(np.clip(eopatch_pleaides['data']['BANDS-PAN'][..., [2, 1, 0]][0,], 0, 1));\n", - "plt.axis(False);\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 185, - "id": "d78551f1-d299-4e9e-af30-2c15e09c887c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(eopatch_pleaides.data['NDVI'][0,].astype(float),vmin = 0.2, vmax = 0.9)\n", @@ -977,11 +939,8 @@ }, { "cell_type": "markdown", - "id": "999353b8-cff7-4784-9d81-9cc4f5d904b7", + "id": "d78551f1-d299-4e9e-af30-2c15e09c887c", "metadata": { - "jupyter": { - "outputs_hidden": false - }, "pycharm": { "name": "#%% md\n" } From f907901533878ce441d44668f745386d4d378f46 Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 3 Feb 2022 14:24:07 +0100 Subject: [PATCH 11/21] impove sentinel2 workflow --- eo-crops/eocrops/input/sentinel2.py | 48 ++++++++++++----------------- 1 file changed, 20 insertions(+), 28 deletions(-) diff --git a/eo-crops/eocrops/input/sentinel2.py b/eo-crops/eocrops/input/sentinel2.py index ec59ec5..4c98e82 100644 --- a/eo-crops/eocrops/input/sentinel2.py +++ b/eo-crops/eocrops/input/sentinel2.py @@ -4,19 +4,18 @@ import eolearn.features import eolearn -from sentinelhub import DataCollection +from sentinelhub import DataCollection from eolearn.core import SaveTask, FeatureType -from eolearn.io import SentinelHubDemTask, SentinelHubEvalscriptTask +from eolearn.io import SentinelHubDemTask, SentinelHubEvalscriptTask import datetime from eolearn.core import OverwritePermission import eocrops.tasks.preprocessing as preprocessing import os -from eocrops.utils import utils as utils +from eocrops.utils import utils as utils import multiprocessing - import eocrops.tasks.vegetation_indices as vegetation_indices import eocrops.input.utils_sh as utils_sh @@ -27,7 +26,7 @@ def workflow_instructions_S2L2A(config, path_out=None, polygon=None, interpolation=None, - n_threads=multiprocessing.cpu_count()-1): + n_threads=multiprocessing.cpu_count() - 1): ''' Define the request of image from sentinelhb API by defining the bbox of the field, the time period and the output desired (evalscript) Sentinel-2 L2a product, available from 2017 with 5 days revisit and 10 meters resolution Inputs : @@ -40,8 +39,8 @@ def workflow_instructions_S2L2A(config, - n_threads (int) : number of threads to download satellite images ''' - if interpolation is None : - interpolation = {'interpolate' : False, 'period_length' : None} + if interpolation is None: + interpolation = {'interpolate': False, 'period_length': None} # Request format to download Landsat8 L2A products time_difference = datetime.timedelta(hours=2) @@ -106,36 +105,32 @@ def workflow_instructions_S2L2A(config, utils_sh.ValidDataCoveragePredicate(coverage_predicate)) vis = vegetation_indices.VegetationIndicesS2('BANDS-S2-L2A', - mask_data=bool(1-interpolation['interpolate'])) + mask_data=bool(1 - interpolation['interpolate'])) norm = vegetation_indices.EuclideanNorm('ECNorm', 'BANDS-S2-L2A') if path_out is None: save = utils_sh.EmptyTask() else: - if not os.path.isdir(path_out) : + if not os.path.isdir(path_out): os.makedirs(path_out) save = SaveTask(path_out, overwrite_permission=OverwritePermission.OVERWRITE_PATCH) - if 'period_length' in interpolation.keys(): - if interpolation['period_length'] is not None: - resampled_range = (time_stamp[0], time_stamp[1], interpolation['period_length']) - else: - resampled_range = None - - copy_features = [(FeatureType.MASK, 'CLM'), - (FeatureType.DATA_TIMELESS, 'DEM'), - (FeatureType.MASK_TIMELESS, 'MASK')] + if not interpolation['interpolate']: + linear_interp = utils_sh.EmptyTask() + else: + if 'period_length' not in interpolation.keys(): + resampled_range = None + elif interpolation['period_length'] is not None: + resampled_range = (time_stamp[0], time_stamp[1], interpolation['period_length']) - if interpolation['interpolate'] : - # Interpolate pixels cloudy - linear_interp = preprocessing.InterpolateFeatures(resampled_range = resampled_range, + copy_features = [(FeatureType.MASK, 'CLM'), + (FeatureType.DATA_TIMELESS, 'DEM'), + (FeatureType.MASK_TIMELESS, 'MASK')] + linear_interp = preprocessing.InterpolateFeatures(resampled_range=resampled_range, copy_features=copy_features) - else : - linear_interp = utils_sh.EmptyTask() - workflow = eolearn.core.LinearWorkflow(input_task, cloud_mask, add_valid_mask, add_coverage, remove_cloudy_scenes, @@ -146,9 +141,6 @@ def workflow_instructions_S2L2A(config, save) result = workflow.execute({ - input_task : {'bbox' : field_bbox, 'time_interval' : time_stamp} + input_task: {'bbox': field_bbox, 'time_interval': time_stamp} }) return result.eopatch() - - - From 9c848b90ebb36ca3f9960b5661484001a3fad737 Mon Sep 17 00:00:00 2001 From: Johann Desloires <52990046+j-desloires@users.noreply.github.com> Date: Thu, 3 Feb 2022 15:03:43 +0100 Subject: [PATCH 12/21] Update readme.MD --- eo-crops/readme.MD | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eo-crops/readme.MD b/eo-crops/readme.MD index 81ed1cb..2ff46d6 100644 --- a/eo-crops/readme.MD +++ b/eo-crops/readme.MD @@ -32,4 +32,4 @@ jupyter notebook You should have OrfeoToolBox installed (https://www.orfeo-toolbox.org/CookBook/Installation.html) if you would like to do apply pansharpening and multitemporal speckle filtering. -Also, you should have a Sentinelhub account with credentials. The latter can be sponsored using Network of Sponsorship program https://www.sentinel-hub.com/Network-of-Resources/. +Also, you should have a Sentinelhub account with credentials. The latter can be sponsored using Network of Ressources program https://www.sentinel-hub.com/Network-of-Resources/. From c8d156154f16e1776609b7f460e2120b445a28a5 Mon Sep 17 00:00:00 2001 From: Johann Desloires <52990046+j-desloires@users.noreply.github.com> Date: Thu, 3 Feb 2022 15:03:52 +0100 Subject: [PATCH 13/21] Update readme.MD --- eo-crops/readme.MD | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eo-crops/readme.MD b/eo-crops/readme.MD index 2ff46d6..bdd0343 100644 --- a/eo-crops/readme.MD +++ b/eo-crops/readme.MD @@ -32,4 +32,4 @@ jupyter notebook You should have OrfeoToolBox installed (https://www.orfeo-toolbox.org/CookBook/Installation.html) if you would like to do apply pansharpening and multitemporal speckle filtering. -Also, you should have a Sentinelhub account with credentials. The latter can be sponsored using Network of Ressources program https://www.sentinel-hub.com/Network-of-Resources/. +Also, you should have a Sentinelhub account with credentials. The latter can be sponsored using Network of Resources program https://www.sentinel-hub.com/Network-of-Resources/. From 97266d5f463718acf32de098bf88c2dc75d17f83 Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 3 Feb 2022 16:12:27 +0100 Subject: [PATCH 14/21] figures --- eo-crops/examples/VHRS data.ipynb | 307 ++++++++++++++---------------- 1 file changed, 146 insertions(+), 161 deletions(-) diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb index 517287f..bf19c8f 100644 --- a/eo-crops/examples/VHRS data.ipynb +++ b/eo-crops/examples/VHRS data.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "id": "decc16fd-a7a9-4c5d-aea6-3558028049ba", "metadata": {}, "source": [ "# Third party commercial data" @@ -10,7 +9,6 @@ }, { "cell_type": "markdown", - "id": "7e8ef3e1-fac8-4e7d-b619-1d529d2da6d2", "metadata": {}, "source": [ "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and eo-learn. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n", @@ -32,7 +30,6 @@ }, { "cell_type": "markdown", - "id": "18f4338d-47d3-4680-8949-48dce4d1ec42", "metadata": {}, "source": [ "## Set your working environment" @@ -40,7 +37,6 @@ }, { "cell_type": "markdown", - "id": "5ff84548-45ed-4c18-8c26-66c38b4c2f89", "metadata": {}, "source": [ "### Import the packages" @@ -48,8 +44,7 @@ }, { "cell_type": "code", - "execution_count": 54, - "id": "9f951ed2-adb4-422a-b4c1-e0a0151cc0f9", + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -77,7 +72,6 @@ }, { "cell_type": "markdown", - "id": "7325554a-5b71-4c54-89ce-9b087ba054c0", "metadata": {}, "source": [ "### Read your vector file" @@ -85,15 +79,22 @@ }, { "cell_type": "code", - "execution_count": 33, - "id": "c525df92-c794-4867-b2f1-1021dee5c076", + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/home/s999379/git-repo/eo-crops\n" + "/home/johann/Documents/git-repo/eo-crops\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" ] } ], @@ -106,10 +107,18 @@ }, { "cell_type": "code", - "execution_count": 72, - "id": "39c2e87d-f9ef-4147-8d9f-c415519143ce", + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], "source": [ "api =''\n", "client_id =''\n", @@ -121,7 +130,6 @@ }, { "cell_type": "markdown", - "id": "4f173e0b-e236-4882-bff9-c16f25e76407", "metadata": {}, "source": [ "### Extract S2 data" @@ -129,8 +137,7 @@ }, { "cell_type": "code", - "execution_count": 39, - "id": "c0dc4fd0-86b7-474a-831d-422062663e0f", + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -140,7 +147,6 @@ { "cell_type": "code", "execution_count": 40, - "id": "1c34d76b-ab4b-4ed8-989c-7ba450df5337", "metadata": {}, "outputs": [], "source": [ @@ -153,7 +159,6 @@ { "cell_type": "code", "execution_count": 43, - "id": "7ac5fbd7-bd82-489c-847f-08012095c0aa", "metadata": {}, "outputs": [ { @@ -180,7 +185,6 @@ { "cell_type": "code", "execution_count": 202, - "id": "d2fac3a6-797f-4288-8833-0aeb33871898", "metadata": {}, "outputs": [], "source": [ @@ -193,7 +197,6 @@ { "cell_type": "code", "execution_count": null, - "id": "d31f67f3-7a66-417b-aad8-0f61c39bb441", "metadata": {}, "outputs": [], "source": [ @@ -207,7 +210,6 @@ { "cell_type": "code", "execution_count": 203, - "id": "ed4fb29a-cfcf-431f-8d53-5b93e566646e", "metadata": {}, "outputs": [ { @@ -239,7 +241,6 @@ { "cell_type": "code", "execution_count": 49, - "id": "9f9105ab-0a88-4ea8-a1c7-381729118bb7", "metadata": {}, "outputs": [ { @@ -263,7 +264,6 @@ }, { "cell_type": "markdown", - "id": "52bd3b0c-e232-4ccf-8155-9a97ab2e9d46", "metadata": { "pycharm": { "name": "#%% md\n" @@ -275,12 +275,13 @@ }, { "cell_type": "code", - "id": "7876d697-aa75-4db2-947b-d1e6a4d13fae", + "execution_count": 5, "metadata": { "pycharm": { "name": "#%%\n" } }, + "outputs": [], "source": [ "#Define the time period\n", "time_period_vhrs = ('2020-04-15', '2020-06-15')\n", @@ -289,13 +290,10 @@ " time_stamp = time_period_vhrs,\n", " config = config,\n", " maxCloudCoverage=10)" - ], - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "markdown", - "id": "d851a64e-d689-486e-8965-37a7ca9b6926", "metadata": { "pycharm": { "name": "#%% md\n" @@ -307,25 +305,23 @@ }, { "cell_type": "code", - "id": "08b85a00-3c63-4c31-b8b8-400d15777eca", + "execution_count": 6, "metadata": { "pycharm": { "name": "#%%\n" } }, + "outputs": [], "source": [ "#Define the provider as follows for Planetscope\n", "provider_planet = ('PLANET', 'PSScene4Band')\n", "#You can retrieve order id and collection ID on your SH account (https://apps.sentinel-hub.com/dashboard/#/tpdi) instead of doing a request again\n", - "order_id, collection_id = '\t2f900fad-1f5e-4a46-b6da-327012d400e1', '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'" - ], - "execution_count": null, - "outputs": [] + "order_id, collection_id = '2f900fad-1f5e-4a46-b6da-327012d400e1', '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'" + ] }, { "cell_type": "code", "execution_count": 133, - "id": "e5a6cfb6-dee3-4f11-aa83-3079f113d67c", "metadata": {}, "outputs": [], "source": [ @@ -336,7 +332,6 @@ { "cell_type": "code", "execution_count": 130, - "id": "dd38636c-58b4-4752-a25a-843c644b259b", "metadata": {}, "outputs": [ { @@ -358,7 +353,6 @@ { "cell_type": "code", "execution_count": 102, - "id": "1ebb6d8a-c7aa-4f61-8819-53bbb16eeeef", "metadata": {}, "outputs": [ { @@ -380,7 +374,6 @@ { "cell_type": "code", "execution_count": null, - "id": "4fbe6346-4277-4be4-a25a-85f13b060d73", "metadata": {}, "outputs": [], "source": [ @@ -390,28 +383,9 @@ }, { "cell_type": "code", - "execution_count": 163, - "id": "92e56cf3-07cd-417a-ad00-7161f1e0fa6f", + "execution_count": 7, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"ccfeacfe-22bd-4850-993c-36d404ceb598\",\"exp\":1643717245,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"4127fd5e-26d0-43bf-8280-cceff506c6d4\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n" - ] - }, - { - "data": { - "text/plain": [ - "'DONE'" - ] - }, - "execution_count": 163, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "eopatch_planet = download_workflow.get_data(order_id = order_id,\n", " collection_id = collection_id,\n", @@ -422,7 +396,6 @@ { "cell_type": "code", "execution_count": 134, - "id": "8abef4fe-dcf7-46f1-b0ed-2da4ea4db777", "metadata": {}, "outputs": [], "source": [ @@ -432,10 +405,30 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "fb721590-2df1-4d97-8603-e2cd4b3ed8eb", + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(np.clip(eopatch_planet['data']['BANDS'][..., [2, 1, 0]][7,], 0, 1));\n", @@ -445,15 +438,14 @@ }, { "cell_type": "code", - "execution_count": 148, - "id": "bfef88ed-ab7d-4c68-ac12-0e02921ad578", + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -477,15 +469,22 @@ }, { "cell_type": "code", - "execution_count": 142, - "id": "35ec81f8-30b8-4389-880f-9f1dda0e04fe", + "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -505,7 +504,6 @@ }, { "cell_type": "markdown", - "id": "b37209c2-c43f-4ae0-b73c-b26ae34d7f36", "metadata": { "pycharm": { "name": "#%% md\n" @@ -519,7 +517,6 @@ }, { "cell_type": "markdown", - "id": "4ab4a072-ba7b-44bf-ae99-61b5430ac322", "metadata": {}, "source": [ "### Extract AIRBUS SPOT data" @@ -527,27 +524,45 @@ }, { "cell_type": "code", - "id": "de10acec-05ac-456f-bc58-dc7470807db4", + "execution_count": 13, "metadata": { "pycharm": { "name": "#%%\n" } }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], "source": [ "#Define the provider as follows for Planetscope\n", "provider_spot = ('AIRBUS', 'SPOT')\n", "#can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", "order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'" - ], - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "code", - "execution_count": 165, - "id": "0af89767-d810-4f42-bad0-f9c9ec97de3a", + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"626aadb6-1f80-45f8-a8fe-8c4ee0edc017\",\"exp\":1643904459,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"aa411329-c789-4790-acd6-08488e40eb99\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n", + "806a1b2f-f6b8-415a-9528-bd30ac32f867\n", + "2.5\n", + "CREATED\n" + ] + } + ], "source": [ "#Define the workflow to get your order_id and meta data. \n", "order_id_spot, results_spot = download_workflow.execute_query(provider_spot, name_query='example spot')" @@ -556,7 +571,6 @@ { "cell_type": "code", "execution_count": 118, - "id": "46d557aa-1f4f-4e7b-8ac2-f131402728a2", "metadata": { "pycharm": { "name": "#%%\n" @@ -581,7 +595,6 @@ { "cell_type": "code", "execution_count": 120, - "id": "bd0f45f3-c648-4786-a207-719cd6e62f87", "metadata": {}, "outputs": [ { @@ -599,26 +612,16 @@ }, { "cell_type": "code", - "execution_count": 161, - "id": "1887644a-1dc8-4dca-95e8-8da5608ba4c7", + "execution_count": 15, "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"41f1d0ad-5272-4409-a1d7-945c4760846f\",\"exp\":1643717125,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"2209ace6-eaa2-497d-aa6c-1f2a72db3a5d\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n" + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" ] - }, - { - "data": { - "text/plain": [ - "'RUNNING'" - ] - }, - "execution_count": 161, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -634,7 +637,6 @@ { "cell_type": "code", "execution_count": 166, - "id": "f4d356f1-4e7a-48c3-8d27-f74616602719", "metadata": {}, "outputs": [], "source": [ @@ -646,30 +648,34 @@ { "cell_type": "code", "execution_count": null, - "id": "82966531-5930-410f-958e-f7ae4bdf1ad6", "metadata": {}, "outputs": [], - "source": [ - "eopatch_spot.timestamp " - ] + "source": [] }, { "cell_type": "code", - "execution_count": 168, - "id": "ca6d8434-36f3-425a-ba22-f4f664affd52", + "execution_count": 16, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + }, { "data": { + "image/png": "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\n", "text/plain": [ - "[datetime.datetime(2020, 4, 15, 10, 55, 52, 100000),\n", - " datetime.datetime(2020, 5, 18, 10, 52, 42, 100000),\n", - " datetime.datetime(2020, 6, 6, 10, 54, 50, 200000)]" + "
" ] }, - "execution_count": 168, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ @@ -681,15 +687,14 @@ }, { "cell_type": "code", - "execution_count": 188, - "id": "a00fd087-3d60-4206-9edc-456a92da30b8", + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -708,7 +713,6 @@ }, { "cell_type": "markdown", - "id": "d589e21b-71a7-4076-a70c-dfe5835e02e1", "metadata": { "pycharm": { "name": "#%% md\n" @@ -722,7 +726,6 @@ }, { "cell_type": "markdown", - "id": "014fec5d-3a5c-444d-a689-c7299f16c3f5", "metadata": {}, "source": [ "### Extract AIRBUS Pleaides data" @@ -730,7 +733,6 @@ }, { "cell_type": "markdown", - "id": "4bf03692-670f-4fe3-9bfc-4e852bf2146c", "metadata": { "pycharm": { "name": "#%% md\n" @@ -742,25 +744,23 @@ }, { "cell_type": "code", - "id": "9bae7137-7061-42d1-8298-3e16a9cd8dc8", + "execution_count": 18, "metadata": { "pycharm": { "name": "#%%\n" } }, + "outputs": [], "source": [ "#Define the provider as follows for Planetscope\n", "provider_pleaides = ('AIRBUS', 'PHR')\n", "#In case, you can use as follows to run the example instead of ordering again data to avoid to run the order and consume credits for nothing\n", "order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'" - ], - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "code", "execution_count": 174, - "id": "f9890bf5-ad4c-47e1-9a8a-b13f8b15026c", "metadata": {}, "outputs": [], "source": [ @@ -771,7 +771,6 @@ { "cell_type": "code", "execution_count": 154, - "id": "67699b0c-0e4e-4989-8f3a-f3592b6f3968", "metadata": {}, "outputs": [ { @@ -792,7 +791,6 @@ { "cell_type": "code", "execution_count": 155, - "id": "5a11b30b-d13e-4d8b-b553-63ae9d1768e0", "metadata": { "pycharm": { "name": "#%%\n" @@ -814,46 +812,26 @@ }, { "cell_type": "code", - "execution_count": 160, - "id": "5f119d2f-7f01-4863-b694-c37393884ae1", + "execution_count": 19, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"2eaec86d-af61-4b97-8b5c-dcced894e3b3\",\"exp\":1643717164,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"c86af45c-7440-47c8-b819-584ca6ef0b57\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n" - ] - }, - { - "data": { - "text/plain": [ - "'RUNNING'" - ] - }, - "execution_count": 162, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", "eopatch_pleaides = download_workflow.get_data(order_id = order_id_pleiades,\n", " collection_id = collection_id_pleaides,\n", " provider = provider_pleaides,\n", " resolution = 0.5,\n", - " pansharpen = True, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + " pansharpen = False, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" ] }, { "cell_type": "code", "execution_count": 175, - "id": "adff8240-4e90-4427-ab4c-3c1b9c4d8ff4", "metadata": {}, "outputs": [], "source": [ @@ -862,19 +840,28 @@ }, { "cell_type": "code", - "execution_count": 187, - "id": "0e3c0377-4a6e-474c-b93e-15d3e4df5d95", + "execution_count": 20, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + }, { "data": { + "image/png": "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\n", "text/plain": [ - "[datetime.datetime(2020, 6, 6, 11, 21, 32, 600000)]" + "
" ] }, - "execution_count": 187, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ @@ -886,13 +873,12 @@ }, { "cell_type": "code", - "execution_count": 178, - "id": "1bd9865f-37b0-4397-9a30-6bdc60338c5f", + "execution_count": 179, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -905,22 +891,22 @@ ], "source": [ "plt.figure(figsize=(5, 5))\n", - "plt.imshow(np.clip(eopatch_pleaides['data']['BANDS-PAN'][..., [2, 1, 0]][0,], 0, 1));\n", + "plt.imshow(eopatch_pleaides.data['BANDS-PAN'][0,].astype(float),vmin = 0.2, vmax = 0.9)\n", + "plt.colorbar()\n", "plt.axis(False);\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 179, - "id": "3d18234b-b676-4a43-9ad6-35887cce5c8b", + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -939,7 +925,6 @@ }, { "cell_type": "markdown", - "id": "d78551f1-d299-4e9e-af30-2c15e09c887c", "metadata": { "pycharm": { "name": "#%% md\n" @@ -973,4 +958,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From c07d6dac3aa662a3f36900bd4c559c4c33c752a2 Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Sat, 5 Feb 2022 15:28:08 +0100 Subject: [PATCH 15/21] typo notebook --- eo-crops/examples/Sentinel data.ipynb | 31 +++------------------------ 1 file changed, 3 insertions(+), 28 deletions(-) diff --git a/eo-crops/examples/Sentinel data.ipynb b/eo-crops/examples/Sentinel data.ipynb index 11deec3..d78f55c 100644 --- a/eo-crops/examples/Sentinel data.ipynb +++ b/eo-crops/examples/Sentinel data.ipynb @@ -2,18 +2,16 @@ "cells": [ { "cell_type": "markdown", - "id": "5ca6a8c8-2b6b-4734-8c5e-b0c2bd4b03cb", "metadata": {}, "source": [ - "# Sentinel" + "# Sentinel 1 and 2" ] }, { "cell_type": "markdown", - "id": "7e8ef3e1-fac8-4e7d-b619-1d529d2da6d2", "metadata": {}, "source": [ - "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and eo-learn. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n", + "The aim of this notebook is to guide you how to get Sentinel data using Sentinelhub and eo-learn. Price for subscription is described there https://www.sentinel-hub.com/pricing/.\n", "\n", "The workflow for agriculture purposes is as follows :\n", "\n", @@ -26,7 +24,6 @@ }, { "cell_type": "markdown", - "id": "18f4338d-47d3-4680-8949-48dce4d1ec42", "metadata": {}, "source": [ "## Set your working environment" @@ -34,7 +31,6 @@ }, { "cell_type": "markdown", - "id": "5ff84548-45ed-4c18-8c26-66c38b4c2f89", "metadata": {}, "source": [ "### Import the packages" @@ -43,7 +39,6 @@ { "cell_type": "code", "execution_count": 176, - "id": "9f951ed2-adb4-422a-b4c1-e0a0151cc0f9", "metadata": {}, "outputs": [], "source": [ @@ -67,7 +62,6 @@ }, { "cell_type": "markdown", - "id": "7325554a-5b71-4c54-89ce-9b087ba054c0", "metadata": {}, "source": [ "### Read your vector file" @@ -76,7 +70,6 @@ { "cell_type": "code", "execution_count": 162, - "id": "c525df92-c794-4867-b2f1-1021dee5c076", "metadata": {}, "outputs": [ { @@ -97,7 +90,6 @@ { "cell_type": "code", "execution_count": 163, - "id": "579eb42f-4c25-44f6-aea1-af65cc077887", "metadata": {}, "outputs": [], "source": [ @@ -112,7 +104,6 @@ { "cell_type": "code", "execution_count": 71, - "id": "0a33c406-7066-49eb-b693-45e931395bba", "metadata": {}, "outputs": [], "source": [ @@ -123,7 +114,6 @@ }, { "cell_type": "markdown", - "id": "4f173e0b-e236-4882-bff9-c16f25e76407", "metadata": {}, "source": [ "## Extract S2 data" @@ -132,7 +122,6 @@ { "cell_type": "code", "execution_count": 165, - "id": "1c34d76b-ab4b-4ed8-989c-7ba450df5337", "metadata": {}, "outputs": [], "source": [ @@ -146,7 +135,6 @@ { "cell_type": "code", "execution_count": 166, - "id": "7ac5fbd7-bd82-489c-847f-08012095c0aa", "metadata": {}, "outputs": [ { @@ -173,7 +161,6 @@ { "cell_type": "code", "execution_count": 171, - "id": "d2fac3a6-797f-4288-8833-0aeb33871898", "metadata": {}, "outputs": [], "source": [ @@ -184,7 +171,6 @@ { "cell_type": "code", "execution_count": 172, - "id": "ed4fb29a-cfcf-431f-8d53-5b93e566646e", "metadata": {}, "outputs": [ { @@ -211,7 +197,6 @@ { "cell_type": "code", "execution_count": 224, - "id": "9f9105ab-0a88-4ea8-a1c7-381729118bb7", "metadata": {}, "outputs": [ { @@ -243,7 +228,6 @@ { "cell_type": "code", "execution_count": 183, - "id": "f3d7144a-8a97-41f2-bf21-ea44681e9123", "metadata": {}, "outputs": [ { @@ -265,7 +249,6 @@ }, { "cell_type": "markdown", - "id": "08b85a00-3c63-4c31-b8b8-400d15777eca", "metadata": {}, "source": [ "## Extract Sentinel-1 data " @@ -274,7 +257,6 @@ { "cell_type": "code", "execution_count": 214, - "id": "54ba256b-c0f7-4575-88b4-f0baee1bdf6e", "metadata": {}, "outputs": [], "source": [ @@ -287,7 +269,6 @@ { "cell_type": "code", "execution_count": 215, - "id": "06fc7e92-9993-4035-aa14-f7c31c05701e", "metadata": {}, "outputs": [], "source": [ @@ -302,7 +283,6 @@ { "cell_type": "code", "execution_count": 216, - "id": "21b2ed83-6fb9-4225-a514-a30ed60217a1", "metadata": {}, "outputs": [ { @@ -329,7 +309,6 @@ }, { "cell_type": "markdown", - "id": "f83ebeec-9ae7-44f0-b83e-b968dcf63105", "metadata": {}, "source": [ "You can easily download and install OTB https://www.orfeo-toolbox.org/CookBook/Installation.html#linux, which allows you to apply Quegan multitemporal speckle filtering" @@ -338,7 +317,6 @@ { "cell_type": "code", "execution_count": 217, - "id": "946a81fc-678e-4560-b8f9-26341e93b38d", "metadata": {}, "outputs": [], "source": [ @@ -351,7 +329,6 @@ { "cell_type": "code", "execution_count": 220, - "id": "ea3b4d6b-adc8-49aa-82e7-cd3f66c74298", "metadata": {}, "outputs": [], "source": [ @@ -366,7 +343,6 @@ { "cell_type": "code", "execution_count": 222, - "id": "a4c9c8b1-be3f-4dde-b6c6-f6bd558226ae", "metadata": {}, "outputs": [ { @@ -392,7 +368,6 @@ { "cell_type": "code", "execution_count": 223, - "id": "eb425046-28fc-44a2-835c-141f70380f4f", "metadata": {}, "outputs": [ { @@ -443,4 +418,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From 25735835cb85260ae0659eee970e5b2a5fd09a3d Mon Sep 17 00:00:00 2001 From: Johann Desloires <52990046+j-desloires@users.noreply.github.com> Date: Mon, 7 Feb 2022 13:47:41 +0100 Subject: [PATCH 16/21] Update readme.MD --- eo-crops/readme.MD | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/eo-crops/readme.MD b/eo-crops/readme.MD index bdd0343..9670d83 100644 --- a/eo-crops/readme.MD +++ b/eo-crops/readme.MD @@ -1,8 +1,8 @@ -Earth observations for crop monitoring. +# Earth observations for crop monitoring. Small python module that gathers awesome functionalities from Sentinelhub, eo-learn python package and OrfeoToolBox for basics download and data processing. -# Installation +## Installation To install the package, you need first to clone the git repository into a desired folder @@ -28,7 +28,7 @@ python -m ipykernel install --user --name=eo-crops jupyter notebook ``` -# Dependencies +## Dependencies You should have OrfeoToolBox installed (https://www.orfeo-toolbox.org/CookBook/Installation.html) if you would like to do apply pansharpening and multitemporal speckle filtering. From 6b1baf04e0b1d4f5b45d066e5b35dfeb1636b7a5 Mon Sep 17 00:00:00 2001 From: Johann Desloires <52990046+j-desloires@users.noreply.github.com> Date: Mon, 7 Feb 2022 13:50:25 +0100 Subject: [PATCH 17/21] Update vhrs.py --- eo-crops/eocrops/input/vhrs.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/eo-crops/eocrops/input/vhrs.py b/eo-crops/eocrops/input/vhrs.py index 86fdc95..e231ca7 100644 --- a/eo-crops/eocrops/input/vhrs.py +++ b/eo-crops/eocrops/input/vhrs.py @@ -318,7 +318,7 @@ def confirm_order(self, order_id): if jobStatus=="RUNNING" : time.sleep(2) # pause to let query ingested - self.running = True + self.order = True return order_id, order['collectionId'] @@ -484,4 +484,4 @@ def get_evalscript(provider): } """ - return evalscript_byoc \ No newline at end of file + return evalscript_byoc From 1150baa73584dad1caa2572178c4cf63df86d55c Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 19 May 2022 11:49:03 +0200 Subject: [PATCH 18/21] small typos correction --- eo-crops/environment.yml | 13 +- eo-crops/eocrops/input/vhrs.py | 1 + eo-crops/eocrops/tasks/vegetation_indices.py | 3 +- eo-crops/examples/Sentinel data.ipynb | 176 ++++++++++-- eo-crops/examples/VHRS data.ipynb | 276 ++++++++++++++++--- eo-crops/examples/vhrs.py | 4 + eo-crops/readme.MD | 5 +- 7 files changed, 401 insertions(+), 77 deletions(-) create mode 100644 eo-crops/examples/vhrs.py diff --git a/eo-crops/environment.yml b/eo-crops/environment.yml index 7f21f1b..9917b15 100644 --- a/eo-crops/environment.yml +++ b/eo-crops/environment.yml @@ -6,9 +6,16 @@ dependencies: - pip - gdal - pip : - - eo-learn>=0.10.1 - - sentinelhub>=3.4.2 - - -r requirements.txt + - eo-learn-coregistration==0.10.1 + - eo-learn-features==0.10.1 + - eo-learn-mask==0.10.1 + - eo-learn-visualization==0.10.1 + - eo-learn-ml-tools==0.10.1 + - eo-learn-core==0.10.1 + - eo-learn-io==0.10.1 + - eo-learn-geometry==0.10.1 + - sentinelhub==3.4.2 + - -r requirements.txt diff --git a/eo-crops/eocrops/input/vhrs.py b/eo-crops/eocrops/input/vhrs.py index 86fdc95..ed0ae4e 100644 --- a/eo-crops/eocrops/input/vhrs.py +++ b/eo-crops/eocrops/input/vhrs.py @@ -13,6 +13,7 @@ ) import eocrops.tasks.vegetation_indices as vegetation_indices + from eolearn.io import SentinelHubEvalscriptTask import datetime as dt diff --git a/eo-crops/eocrops/tasks/vegetation_indices.py b/eo-crops/eocrops/tasks/vegetation_indices.py index cf6bb60..fc98ad3 100644 --- a/eo-crops/eocrops/tasks/vegetation_indices.py +++ b/eo-crops/eocrops/tasks/vegetation_indices.py @@ -309,7 +309,8 @@ def execute(self, eopatch) : eopatch.add_feature(FeatureType.DATA, "LAI", self.LAI[..., np.newaxis]) eopatch.add_feature(FeatureType.DATA, "Cab", self.Cab[..., np.newaxis]) eopatch.add_feature(FeatureType.DATA, "NDVI", self.NDVI[..., np.newaxis]) - eopatch.add_feature(FeatureType.DATA, "NDWI", self.EVI2[..., np.newaxis]) + eopatch.add_feature(FeatureType.DATA, "NDWI", self.NDWI[..., np.newaxis]) + eopatch.add_feature(FeatureType.DATA, "GNDVI", self.GNDVI[..., np.newaxis]) eopatch.remove_feature(FeatureType.DATA, "ILLUMINATION") return eopatch diff --git a/eo-crops/examples/Sentinel data.ipynb b/eo-crops/examples/Sentinel data.ipynb index d78f55c..52c9319 100644 --- a/eo-crops/examples/Sentinel data.ipynb +++ b/eo-crops/examples/Sentinel data.ipynb @@ -2,14 +2,22 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Sentinel 1 and 2" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The aim of this notebook is to guide you how to get Sentinel data using Sentinelhub and eo-learn. Price for subscription is described there https://www.sentinel-hub.com/pricing/.\n", "\n", @@ -24,14 +32,22 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Set your working environment" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Import the packages" ] @@ -39,7 +55,11 @@ { "cell_type": "code", "execution_count": 176, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import warnings\n", @@ -62,7 +82,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Read your vector file" ] @@ -70,7 +94,11 @@ { "cell_type": "code", "execution_count": 162, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -90,7 +118,11 @@ { "cell_type": "code", "execution_count": 163, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "api =''\n", @@ -104,9 +136,14 @@ { "cell_type": "code", "execution_count": 71, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ + "time_period = ('2020-04-15', '2020-06-15')\n", "kwargs = dict(polygon=shapefile_input,\n", " time_stamp=time_period,\n", " config=config)" @@ -114,7 +151,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Extract S2 data" ] @@ -122,7 +163,11 @@ { "cell_type": "code", "execution_count": 165, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "patch = sentinel2.workflow_instructions_S2L2A(**kwargs,\n", @@ -135,7 +180,11 @@ { "cell_type": "code", "execution_count": 166, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -161,7 +210,11 @@ { "cell_type": "code", "execution_count": 171, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "masking = preprocessing.MaskPixels([\"NDVI\"])\n", @@ -171,7 +224,11 @@ { "cell_type": "code", "execution_count": 172, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -197,7 +254,11 @@ { "cell_type": "code", "execution_count": 224, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -228,7 +289,11 @@ { "cell_type": "code", "execution_count": 183, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -247,9 +312,36 @@ "patch.timestamp[time_argmax]" ] }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "#If oyu would like to save the data in .tif format (e.g. NDVI on the first date)\n", + "from eolearn.io.local_io import ExportToTiffTask\n", + "index_time = 0\n", + "date = str(patch.timestamp[index_time]).split(' ')[0]\n", + "\n", + "export = ExportToTiffTask(feature='NDVI',\n", + " folder=os.path.join('your_path_'+ date),\n", + " band_indices=[0],\n", + " date_indices=[index_time])\n", + "export.execute(patch)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Extract Sentinel-1 data " ] @@ -257,7 +349,11 @@ { "cell_type": "code", "execution_count": 214, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "s1_eopatch = sentinel1.workflow_instructions_S1IW(**kwargs,\n", @@ -269,7 +365,11 @@ { "cell_type": "code", "execution_count": 215, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "VV = s1_eopatch.data['BANDS-S1-IW'][...,0]\n", @@ -283,7 +383,11 @@ { "cell_type": "code", "execution_count": 216, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -309,7 +413,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "You can easily download and install OTB https://www.orfeo-toolbox.org/CookBook/Installation.html#linux, which allows you to apply Quegan multitemporal speckle filtering" ] @@ -317,7 +425,11 @@ { "cell_type": "code", "execution_count": 217, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "#Can take around 30 seconds\n", @@ -329,7 +441,11 @@ { "cell_type": "code", "execution_count": 220, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "VH = s1_eopatch.data['VH_filtered']\n", @@ -343,7 +459,11 @@ { "cell_type": "code", "execution_count": 222, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -368,7 +488,11 @@ { "cell_type": "code", "execution_count": 223, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -418,4 +542,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb index bf19c8f..ef05671 100644 --- a/eo-crops/examples/VHRS data.ipynb +++ b/eo-crops/examples/VHRS data.ipynb @@ -2,14 +2,22 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Third party commercial data" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and eo-learn. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n", "\n", @@ -30,14 +38,22 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Set your working environment" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Import the packages" ] @@ -45,7 +61,11 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import warnings\n", @@ -72,7 +92,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Read your vector file" ] @@ -80,7 +104,11 @@ { "cell_type": "code", "execution_count": 2, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -108,7 +136,11 @@ { "cell_type": "code", "execution_count": 3, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stderr", @@ -130,7 +162,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Extract S2 data" ] @@ -138,16 +174,27 @@ { "cell_type": "code", "execution_count": 4, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "time_period = ('2020-02-01', '2020-10-30')" + "time_period = ('2020-02-01', '2020-10-30')\n", + "kwargs = dict(polygon=shapefile_input,\n", + " time_stamp=time_period,\n", + " config=config)" ] }, { "cell_type": "code", "execution_count": 40, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "patch = sentinel2.workflow_instructions_S2L2A(**kwargs,\n", @@ -159,7 +206,11 @@ { "cell_type": "code", "execution_count": 43, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -185,7 +236,11 @@ { "cell_type": "code", "execution_count": 202, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "preprocessing = reload(preprocessing)\n", @@ -197,7 +252,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "#NDVI\n", @@ -210,7 +269,11 @@ { "cell_type": "code", "execution_count": 203, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -241,7 +304,11 @@ { "cell_type": "code", "execution_count": 49, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -262,6 +329,29 @@ "patch.timestamp[np.nanargmax(stats_df[variable])]" ] }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "#If oyu would like to save the data in .tif format (e.g. NDVI on the first date)\n", + "from eolearn.io.local_io import ExportToTiffTask\n", + "index_time = 0\n", + "date = str(patch.timestamp[index_time]).split(' ')[0]\n", + "\n", + "export = ExportToTiffTask(feature='NDVI',\n", + " folder=os.path.join('your_path_'+ date),\n", + " band_indices=[0],\n", + " date_indices=[index_time])\n", + "export.execute(patch)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, { "cell_type": "markdown", "metadata": { @@ -316,13 +406,17 @@ "#Define the provider as follows for Planetscope\n", "provider_planet = ('PLANET', 'PSScene4Band')\n", "#You can retrieve order id and collection ID on your SH account (https://apps.sentinel-hub.com/dashboard/#/tpdi) instead of doing a request again\n", - "order_id, collection_id = '2f900fad-1f5e-4a46-b6da-327012d400e1', '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'" + "#order_id, collection_id = '2f900fad-1f5e-4a46-b6da-327012d400e1', '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'" ] }, { "cell_type": "code", "execution_count": 133, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", @@ -332,7 +426,11 @@ { "cell_type": "code", "execution_count": 130, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -353,7 +451,11 @@ { "cell_type": "code", "execution_count": 102, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -374,7 +476,11 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", @@ -384,7 +490,11 @@ { "cell_type": "code", "execution_count": 7, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "eopatch_planet = download_workflow.get_data(order_id = order_id,\n", @@ -396,7 +506,11 @@ { "cell_type": "code", "execution_count": 134, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "#Reset the download_workflow if you would like to launch new orders. It is a way to prevent to download multiple times the same image and consume credits.\n", @@ -406,7 +520,11 @@ { "cell_type": "code", "execution_count": 8, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stderr", @@ -439,7 +557,11 @@ { "cell_type": "code", "execution_count": 9, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -470,7 +592,11 @@ { "cell_type": "code", "execution_count": 10, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stderr", @@ -517,7 +643,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Extract AIRBUS SPOT data" ] @@ -544,13 +674,17 @@ "#Define the provider as follows for Planetscope\n", "provider_spot = ('AIRBUS', 'SPOT')\n", "#can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", - "order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'" + "#order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'" ] }, { "cell_type": "code", "execution_count": 12, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -595,7 +729,11 @@ { "cell_type": "code", "execution_count": 120, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -613,7 +751,11 @@ { "cell_type": "code", "execution_count": 15, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stderr", @@ -637,7 +779,11 @@ { "cell_type": "code", "execution_count": 166, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "#Reset the download_workflow method if you would like to execute new queries. \n", @@ -648,14 +794,22 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 16, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stderr", @@ -688,7 +842,11 @@ { "cell_type": "code", "execution_count": 17, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -726,7 +884,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Extract AIRBUS Pleaides data" ] @@ -755,13 +917,17 @@ "#Define the provider as follows for Planetscope\n", "provider_pleaides = ('AIRBUS', 'PHR')\n", "#In case, you can use as follows to run the example instead of ordering again data to avoid to run the order and consume credits for nothing\n", - "order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'" + "#order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'" ] }, { "cell_type": "code", "execution_count": 174, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", @@ -771,7 +937,11 @@ { "cell_type": "code", "execution_count": 154, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -832,7 +1002,11 @@ { "cell_type": "code", "execution_count": 175, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "eopatch_pleaides.timestamp" @@ -841,7 +1015,11 @@ { "cell_type": "code", "execution_count": 20, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stderr", @@ -874,7 +1052,11 @@ { "cell_type": "code", "execution_count": 179, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -900,7 +1082,11 @@ { "cell_type": "code", "execution_count": 22, - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -958,4 +1144,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/eo-crops/examples/vhrs.py b/eo-crops/examples/vhrs.py new file mode 100644 index 0000000..c60b9f3 --- /dev/null +++ b/eo-crops/examples/vhrs.py @@ -0,0 +1,4 @@ +import geopandas as gpd +import os +os.getcwd() +df = gpd.read_file('/home/johann/Documents/Syngenta/polygonized_file.shp') \ No newline at end of file diff --git a/eo-crops/readme.MD b/eo-crops/readme.MD index bdd0343..bb8918b 100644 --- a/eo-crops/readme.MD +++ b/eo-crops/readme.MD @@ -1,10 +1,11 @@ Earth observations for crop monitoring. -Small python module that gathers awesome functionalities from Sentinelhub, eo-learn python package and OrfeoToolBox for basics download and data processing. + +Small python module that brings together awesome functionality from Sentinelhub, eo-learn python package and OrfeoToolBox for basic downloading and data processing. # Installation -To install the package, you need first to clone the git repository into a desired folder +To install the package, you must first clone the git repository to the desired folder ```bash git clone git@github.com:j-desloires/eo-crops.git From 613f43480949b94a5e15e4fb2cc809da9426f179 Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Mon, 4 Jul 2022 16:11:08 +0200 Subject: [PATCH 19/21] adjustments --- eo-crops/eocrops/input/meteoblue.py | 352 +++++++++++ eo-crops/eocrops/input/sentinel2.py | 1 + eo-crops/eocrops/input/vhrs.py | 4 +- eo-crops/eocrops/tasks/cmd_otb.py | 7 +- eo-crops/eocrops/tasks/preprocessing.py | 31 +- eo-crops/eocrops/utils/data_loader.py | 185 ++++++ eo-crops/eocrops/utils/utils.py | 25 + eo-crops/examples/Sentinel data.ipynb | 173 +++-- eo-crops/examples/VHRS data.ipynb | 590 +++++++++--------- eo-crops/examples/data_loading.py | 46 ++ .../examples/layers/burkina_dataframe.csv | 193 ++++++ eo-crops/examples/vhrs.py | 4 - eo-crops/examples/weather_data.py | 81 +++ eo-crops/readme.MD | 8 +- eo-crops/requirements.txt | 4 +- 15 files changed, 1310 insertions(+), 394 deletions(-) create mode 100644 eo-crops/eocrops/input/meteoblue.py create mode 100644 eo-crops/eocrops/utils/data_loader.py create mode 100644 eo-crops/examples/data_loading.py create mode 100644 eo-crops/examples/layers/burkina_dataframe.csv delete mode 100644 eo-crops/examples/vhrs.py create mode 100644 eo-crops/examples/weather_data.py diff --git a/eo-crops/eocrops/input/meteoblue.py b/eo-crops/eocrops/input/meteoblue.py new file mode 100644 index 0000000..8cca295 --- /dev/null +++ b/eo-crops/eocrops/input/meteoblue.py @@ -0,0 +1,352 @@ +import aiohttp +import asyncio +from io import StringIO + +import pandas as pd +import dateutil +import datetime as dt + +import numpy as np +import datetime + + +class CEHUBExtraction: + def __init__(self, api_key, queryBackbone, ids, coordinates, years, loop = asyncio.new_event_loop()): + ''' + + Parameters + ---------- + api_key (str) : API key from meteoblue + queryBackbone (dict) : query backbone from meteoblue + ids (list) : list of ids from each location request + coordinates (list of tuples) : list of each location coordinate + years (list) : years of extraction w.r.t the ids + ''' + self.api_key = api_key + self.queryBackbone = queryBackbone + self.loop = loop + self.ids = ids + self.coordinates = coordinates + self.years = years + self.url_query = "http://my.meteoblue.com/dataset/query" + self.url_queue = "http://queueresults.meteoblue.com/" + + async def _get_jobIDs_from_query(self, query, time_interval = ('01-01', '12-31')): + + async def _make_ids(ids, coordinates, dates): + for i, (id, coord, date) in enumerate(zip(ids, coordinates, dates)): + yield i, id, coord, date + + jobIDs = [] + + async for i, id, coord, date in _make_ids(self.ids, self.coordinates, self.years): + await asyncio.sleep(0.5) #query spaced by 05 seconds => 2 queries max per queueTime (limit = 5) + start_time, end_time = (str(date) + "-" + time_interval[0], str(date) + "-" + time_interval[1]) + + self.queryBackbone["geometry"]["geometries"] = \ + [dict(type='MultiPoint', coordinates=[coord], locationNames=[id])] + self.queryBackbone["timeIntervals"] = [start_time + 'T+00:00' + '/' + end_time + 'T+00:00'] + self.queryBackbone["queries"] = query + + async with aiohttp.ClientSession() as session: + # prepare the coroutines that post + async with session.post(self.url_query, + headers={"Content-Type": "application/json", "Accept": "application/json"}, + params={"apikey": self.api_key}, + json=self.queryBackbone + ) as response: + data = await response.json() + print(data) + await session.close() + jobIDs.append(data['id']) + # now execute them all at once + return jobIDs + + + async def _get_request_from_jobID(self, jobID, sleep = 1, limit = 5): + + await asyncio.sleep(sleep) + #limit amount of simultaneously opened connections you can pass limit parameter to connector + conn = aiohttp.TCPConnector(limit=limit, ttl_dns_cache=300) + session = aiohttp.ClientSession(connector=conn) #ClientSession is the heart and the main entry point for all client API operations. + #session contains a cookie storage and connection pool, thus cookies and connections are shared between HTTP requests sent by the same session. + + async with session.get(self.url_queue + jobID) as response: + print("Status:", response.status) + print("Content-type:", response.headers['content-type']) + urlData = await response.text() + print(response) + await session.close() + df = pd.read_csv(StringIO(urlData), sep=",", header=None) + df['jobID'] = jobID + return df + + @staticmethod + async def _gather_with_concurrency(n, *tasks): + semaphore = asyncio.Semaphore(n) + async def sem_task(task): + async with semaphore: + return await task + + return await asyncio.gather(*(sem_task(task) for task in tasks)) + + def execute(self, query, time_interval = ('01-01', '12-31'), conc_req = 5): + try : + jobIDs = self.loop.run_until_complete(self._get_jobIDs_from_query(query, time_interval)) + + dfs = self.loop.run_until_complete(self._gather_with_concurrency(conc_req, + *[self._get_request_from_jobID(jobID, + i/100) + for i, jobID in enumerate(jobIDs)])) + finally: + print('close') + self.loop.close() + + return pd.concat(dfs, axis=0) + +############################################################################################# + +class CEHubFormatting: + def __init__(self, + input_file, + id_column, + year_column, resample_range=('-01-01', '-12-31', 1), + planting_date_column = None, havest_date_column = None): + ''' + :param input_file (pd.DataFrame) : input file with fields in-situ data + :param id_column (str): Name of the column that contains ids of the fields to merge with CEHub data + :param planting_date_column (str): Name of the column with planting date in doy format + :param havest_date_column (str): Name of the column with harvest date in doy format + :param year_column (str) : Name of the column with the yearly season associated to each field + :param resample_range (tuple): Interval of date to resample time series given a fixed period length (e.g. 8 days) + ''' + + self.resample_range = resample_range + self.id_column = id_column + self.planting_date_column = planting_date_column + self.havest_date_column = havest_date_column + self.year_column = year_column + self.resample_range = resample_range + self.input_file = input_file[[self.id_column, self.year_column]].drop_duplicates() + + if self.planting_date_column is not None and self.havest_date_column is not None: + self.input_file = self.input_file.rename( + columns={self.planting_date_column: 'planting_date'}) + self._apply_convert_doy('planting_date') + + + def _get_descriptive_period(self, df, stat='mean'): + ''' + Compute descriptive statistics given period + ''' + dict_stats = dict(mean=np.nanmean, max=np.nanmax, min=np.nanmin) + + df['value'] = df['value'].astype('float32') + df_agg = df[['variable', 'period', 'location', 'value', self.year_column]]. \ + groupby(['variable', 'period', 'location', self.year_column]).agg(dict_stats[stat]) + df_agg.reset_index(inplace=True) + df_agg = df_agg.rename(columns={'value': stat + '_value', + 'location': self.id_column}) + return df_agg + + def _get_cumulated_period(self, df): + ''' + Compute the cumulative sum given period. + ''' + + df_cum = pd.DataFrame() + for var in df.variable.unique(): + df_subset = df[df.variable == var] + df_agg = df_subset[['location', 'period', 'variable', 'value', self.year_column]]. \ + groupby(['location', self.year_column, 'variable', 'period']).sum() + df_agg = df_agg.groupby(level=0).cumsum().reset_index() + df_agg = df_agg.rename(columns={'value': 'sum_value'}) + df_cum = df_cum.append(df_agg) + + return df_cum + + def _get_resampled_periods(self, year = '2021'): + ''' + Get the resampled periods from the resample range + ''' + resample_range_ = (str(year) + self.resample_range[0], + str(year) + self.resample_range[1], + self.resample_range[2]) + + start_date = dateutil.parser.parse(resample_range_[0]) + end_date = dateutil.parser.parse(resample_range_[1]) + step = dt.timedelta(days=resample_range_[2]) + + days = [start_date] + while days[-1] + step < end_date: + days.append(days[-1] + step) + return days + + + def _format_periods(self, periods): + df_resampled = pd.melt(periods, id_vars='period'). \ + rename(columns={'value': 'timestamp', 'variable': self.year_column}) + + # Left join periods to the original dataframe + df_resampled['timestamp'] = [str(k) for k in df_resampled['timestamp'].values] + df_resampled['timestamp'] = [np.datetime64(str(year) + '-' + '-'.join(k.split('-')[1:])) + for year, k in zip(df_resampled[self.year_column], df_resampled['timestamp'])] + return df_resampled + + def _get_periods(self, df_cehub_): + ''' + Assign the periods to the file obtained through CEHub + ''' + + def _get_year(x): return x[:4] + def _convert_date(x): return dateutil.parser.parse(x[:-5]) + + df_cehub = df_cehub_.copy() + + # Assign period ids w.r.t the date from the dataframe + df_cehub['timestamp'] = [str(k) for k in df_cehub['timestamp']] + + #Assign dates to a single year to retrieve periods + df_cehub[self.year_column] = df_cehub['timestamp'].apply(lambda x: _get_year(x)) + df_cehub['timestamp'] = df_cehub['timestamp'].apply(lambda x: _convert_date(x)) + + dict_year = {} + for year in df_cehub[self.year_column].drop_duplicates().values: + dict_year[year] = self._get_resampled_periods() + + periods = pd.DataFrame(dict_year) + + periods = periods.reset_index().rename(columns={'index': 'period'}) + df_resampled = self._format_periods(periods) + + df = pd.merge(df_resampled, df_cehub, + on=['timestamp', self.year_column], + how='right') + + fill_nas = df[['period', 'location']].groupby('location').apply( + lambda group: group.interpolate(method='pad', limit=self.resample_range[-1])) + + df['period'] = fill_nas['period'] + + return df, df[['period', 'timestamp']].drop_duplicates() + + + def _apply_convert_doy(self, feature): + ''' + Convert dates from CEhub format into day of the year + ''' + def _convert_doy_to_date(doy, year): + date = datetime.datetime(int(year), 1, 1) + datetime.timedelta(doy - 1) + return np.datetime64(date) + + self.input_file[feature] = [_convert_doy_to_date(doy, year) + for doy, year in zip(self.input_file[feature], + self.input_file[self.year_column])] + + def _add_growing_stage(self, periods_df, feature='planting_date'): + ''' + Retrive the date from weather data associated with a given growing stage (doy format) from the input file + The objective is to not take into account observations before sowing date of after harvest date in the statistics + ''' + + return pd.merge(periods_df, + self.input_file[[feature, self.id_column]].copy(), + left_on='timestamp', + right_on=feature, + how='right'). \ + rename(columns={'period': 'period_' + feature}).drop(['timestamp'], axis=1) + + def _init_df(self, df): + ''' + Initialize weather dataframe into periods to do the period calculations + ''' + df = df[~df.variable.isin(['variable'])] + df = df.drop_duplicates(subset=['location', 'timestamp', 'variable']) + + df = df[df.location.isin(self.input_file[self.id_column].unique())] + df, periods_df = self._get_periods(df_cehub_=df) + df['value'] = df['value'].astype('float32') + + if self.planting_date_column is not None: + periods_sowing = self._add_growing_stage(periods_df, feature='planting_date') + df = pd.merge(df[['period', 'timestamp', 'location', 'variable', 'value']], + periods_sowing, + left_on='location', + right_on= self.id_column, + how='left') + + # Observations before planting date are assigned to np.nan + df.loc[df.timestamp < df.planting_date, ['value']] = np.nan + + return df + + def _prepare_output_file(self, df_stats, stat='mean'): + ''' + Prepare output dataframe with associated statistics over the periods. + The output will have the name of the feature and its corresponding period (tuple) + ''' + df_pivot = pd.pivot_table(df_stats, + values=[stat + '_value'], + index=[self.id_column, self.year_column], + columns=['variable', 'period'], dropna=False) + + df_pivot.reset_index(inplace=True) + df_pivot.columns = ['-'.join([str(x) for x in col]).strip() for col in df_pivot.columns.values] + df_pivot = df_pivot.rename( + columns={ + self.id_column + '--': self.id_column, + self.year_column + '--': self.year_column} + ) + df_pivot = df_pivot.sort_values(by=[self.id_column, self.year_column]).reset_index(drop=True) + return df_pivot + + + def _get_temperature_difference(self, min_weather, max_weather): + ''' + Compute difference between minimum and maximum temperature observed for each period + ''' + diff_weather = min_weather.copy() + + tempMax = max_weather.loc[ + max_weather.variable.isin(['Temperature']), + ['period', 'timestamp', self.id_column, 'value']].rename( + columns={'value': 'value_max'}) + + diff_weather = pd.merge(diff_weather, + tempMax, + on=['period', 'timestamp', self.id_column], + how='left') + + diff_weather['value'] = diff_weather['value_max'] - diff_weather['value'] + diff_weather['variable'] = 'Temperature difference' + + return diff_weather + + + def execute(self, df_weather, stat='mean', return_pivot = False): + ''' + Execute the workflow to get the dataframe aggregated into periods from CEHub data + :param df_weather (pd.DataFrame) : cehub dataframe with stat as daily descriptive statistics + :return: + pd.DataFrame with mean, min, max, sum aggregated into periods defined w.r.t the resample_range + ''' + + if stat not in ['mean', 'min', 'max', 'sum', 'cumsum']: + raise ValueError("Descriptive statistic must be 'mean', 'min', 'max', 'sum' or 'cumsum'") + + init_weather = self._init_df(df=df_weather.copy()) + + if stat != 'cumsum': + df_stats = self._get_descriptive_period(df = init_weather, stat = stat) + else: + df_stats = self._get_cumulated_period(df = init_weather) + + df_stats = df_stats.sort_values(by=[self.id_column, self.year_column, "variable"]) + + if return_pivot: + output = self._prepare_output_file(df_stats=df_stats, stat=stat) + output.columns = [''.join(k.split('value-')) for k in output.columns] + output.columns = [tuple(k.split('-')) if k != self.id_column else k for k in output.columns] + output.columns = [(k[0], float(k[1])) if k != self.id_column else k for k in output.columns] + + return output diff --git a/eo-crops/eocrops/input/sentinel2.py b/eo-crops/eocrops/input/sentinel2.py index 4c98e82..c20712c 100644 --- a/eo-crops/eocrops/input/sentinel2.py +++ b/eo-crops/eocrops/input/sentinel2.py @@ -129,6 +129,7 @@ def workflow_instructions_S2L2A(config, (FeatureType.DATA_TIMELESS, 'DEM'), (FeatureType.MASK_TIMELESS, 'MASK')] linear_interp = preprocessing.InterpolateFeatures(resampled_range=resampled_range, + features=['Cab', 'fapar', 'LAI', 'NDVI', 'NDWI', 'BANDS-S2-L2A'], copy_features=copy_features) workflow = eolearn.core.LinearWorkflow(input_task, diff --git a/eo-crops/eocrops/input/vhrs.py b/eo-crops/eocrops/input/vhrs.py index 8ff04e5..ed0ae4e 100644 --- a/eo-crops/eocrops/input/vhrs.py +++ b/eo-crops/eocrops/input/vhrs.py @@ -319,7 +319,7 @@ def confirm_order(self, order_id): if jobStatus=="RUNNING" : time.sleep(2) # pause to let query ingested - self.order = True + self.running = True return order_id, order['collectionId'] @@ -485,4 +485,4 @@ def get_evalscript(provider): } """ - return evalscript_byoc + return evalscript_byoc \ No newline at end of file diff --git a/eo-crops/eocrops/tasks/cmd_otb.py b/eo-crops/eocrops/tasks/cmd_otb.py index 0011fc6..9b192eb 100644 --- a/eo-crops/eocrops/tasks/cmd_otb.py +++ b/eo-crops/eocrops/tasks/cmd_otb.py @@ -110,14 +110,15 @@ def execute(self, eopatch, ram = 8): meta['dtype'] = 'float32' meta['count'] = len(times) - path_tif = outfiles[0].split('_2017')[0] + '.tif' + year = str(eopatch.timestamp[0].year) + path_tif = outfiles[0].split('_' + year)[0] + '.tif' if 'outcore_filtered.tif' in os.listdir(outdir): outfiles.remove(os.path.join(outdir, 'outcore_filtered.tif')) outfiles.sort() - with rasterio.open(path_tif, 'w', **meta) as dst: + with rasterio.open(os.path.join(os.getcwd(), path_tif), 'w', **meta) as dst: for i in range(1, len(times) + 1): - img = gdal.Open(outfiles[i - 1]).ReadAsArray() + img = gdal.Open(os.path.join(os.getcwd(), outfiles[i - 1])).ReadAsArray() dst.write_band(i, img) import_tif = ImportFromTiffTask((FeatureType.DATA, pol + '_filtered'), path_tif) diff --git a/eo-crops/eocrops/tasks/preprocessing.py b/eo-crops/eocrops/tasks/preprocessing.py index b7260f7..8e4a0cd 100644 --- a/eo-crops/eocrops/tasks/preprocessing.py +++ b/eo-crops/eocrops/tasks/preprocessing.py @@ -117,15 +117,12 @@ def execute(self, patch, erosion = 0): class InterpolateFeatures(EOTask): - def __init__(self, resampled_range, algorithm = 'linear', copy_features = None, - features = None): + def __init__(self, resampled_range, features, + algorithm = 'linear', copy_features = None): self.resampled_range = resampled_range - self.algorithm = algorithm self.features = features + self.algorithm = algorithm self.copy_features = copy_features - if self.features is None : - self.features = ['BANDS-S2-L2A', 'fapar', 'LAI', 'Cab', 'NDVI', 'EVI2', 'CVI', 'NDWI', 'GNDVI', 'GVMI', - 'SLAVI', 'NDDI', 'VSDI', 'ECNorm'] def _interpolate_feature(self, eopatch, feature, mask_feature): @@ -148,7 +145,7 @@ def _interpolate_feature(self, eopatch, feature, mask_feature): return eopatch - def execute(self, eopatch): + def execute(self, eopatch, mask_feature = None): '''Gap filling after data extraction, very useful if did not include it in the data extraction workflow''' @@ -173,23 +170,21 @@ def execute(self, eopatch): return eopatch -def get_time_series_profile(patch, variable, mask_name, function = np.mean): - crop_mask = patch['mask_timeless'][mask_name].squeeze() - var = patch['data'][variable] - shape = var.shape[-1] - times = len(patch.timestamp) + +def get_time_series_profile(feature_array, + crop_mask, + function=np.nanmedian): + # Transform mask from 3D to 4D - mask = crop_mask.reshape(1, crop_mask.shape[0], crop_mask.shape[1], 1) + times, h, w, shape = feature_array.shape + mask = crop_mask.reshape(1, h, w, 1) mask = [mask for k in range(times)] mask = np.concatenate(mask, axis=0) ####################### mask = [mask for k in range(shape)] mask = np.concatenate(mask, axis=-1) ######################## - a = np.ma.array(var, mask=(1-(mask==1)).astype(bool)) + a = np.ma.array(feature_array, mask=np.invert(mask)) #np.invert(mask) ts_mean = np.ma.apply_over_axes(function, a, [1, 2]) ts_mean = ts_mean.reshape(ts_mean.shape[0], ts_mean.shape[-1]) - ts_mean = ts_mean.data - return {variable: ts_mean[:, n].flatten() for n in range(shape)} - - + return ts_mean diff --git a/eo-crops/eocrops/utils/data_loader.py b/eo-crops/eocrops/utils/data_loader.py new file mode 100644 index 0000000..644d9e1 --- /dev/null +++ b/eo-crops/eocrops/utils/data_loader.py @@ -0,0 +1,185 @@ +from eolearn.core import EOPatch, FeatureType, EOTask + +import glob +import numpy as np + +import os + +from eolearn.geometry import ErosionTask +import eocrops.utils.utils as utils +import eocrops.tasks.preprocessing as preprocessing +import copy +########################################################################################################### + +class EOPatchDataset: + def __init__(self, + root_dir_or_list, features_data, + suffix='S2_L2A', resampling = None, + function=np.nanmedian): + ''' + + ''' + + import tensorflow as tf + import tensorflow_datasets as tfds + global tf + global tfds + + self.root_dir_or_list = root_dir_or_list + self.features_data = features_data + self.suffix = suffix + self.mask = (FeatureType.MASK_TIMELESS, 'MASK') + + if resampling is None: + resampling = dict(start = '-01-01', end = '-12-31', day_periods = 8) + self.resampling = resampling + self.function = function + + try: + self.AUTOTUNE = tf.data.AUTOTUNE + except: + self.AUTOTUNE = tf.data.experimental.AUTOTUNE + + def _instance_tf_ds(self): + file_pattern = os.path.join(self.root_dir_or_list, '*_' + self.suffix) + files = glob.glob(file_pattern) + if len(files) == 0: + raise ValueError('No file in the root directory ' + self.root_dir_or_list + " ending with " + self.suffix) + files.sort() + self.dataset = tf.data.Dataset.from_tensor_slices(files) + self.vector_dataset = tf.data.Dataset.from_tensor_slices(files) + + @staticmethod + def _interpolate_feature(eopatch, feature, mask_feature, **kwargs): + kwargs['features'] = [feature] + interp = preprocessing.InterpolateFeatures( **kwargs) + eopatch = interp.execute(eopatch, mask_feature) + return eopatch + + def _execute_gap_filling(self, eopatch, + resampled_range, + copy_features, + algorithm = 'linear', + mask_feature=None): + + '''Gap filling after data extraction, very useful if did not include it in the data extraction workflow''' + kwargs = dict(copy_features=copy_features, + resampled_range=resampled_range, + algorithm = algorithm) + + dico = {} + for ftype, fname, _, _, _ in self.features_data: + new_eopatch = copy.deepcopy(eopatch) + new_eopatch = self._interpolate_feature(new_eopatch, fname, mask_feature, **kwargs) + dico[fname] = new_eopatch[ftype][fname] + + eopatch['data'] = dico + + return eopatch + + def _prepare_eopatch(self, patch, resampled_range, algorithm = 'linear'): + + polygon_mask = (patch.data_timeless['FIELD_ID']>0).astype(np.int32) + patch.add_feature(self.mask[0], self.mask[1], polygon_mask.astype(bool)) + + erode = ErosionTask(mask_feature=self.mask, disk_radius=1) + erode.execute(patch) + + patch = self._execute_gap_filling(eopatch=patch, + resampled_range=resampled_range, + algorithm=algorithm, + copy_features=[self.mask]) + return patch + + + def _read_patch(self, path, algorithm = 'linear'): + """ TF op for reading an eopatch at a given path. """ + def _func(path): + path = path.numpy().decode('utf-8') + # Load only relevant features + ################################################################ + patch = EOPatch.load(path) + year = str(patch.timestamp[0].year) + start, end = year + self.resampling['start'], year + self.resampling['end'] + resampled_range = (start, end, self.resampling['day_periods']) + patch = self._prepare_eopatch(patch, resampled_range, algorithm) + ################################################################# + data = [] + for feat_type, feat_name, _, dtype, _ in self.features_data: + arr = preprocessing.get_time_series_profile(feature_array = patch[feat_type][feat_name].astype(dtype), + crop_mask=patch[self.mask[0]][self.mask[1]], + function = self.function) + data.append(arr) + return data + + ################################################################# + out_types = [tf.as_dtype(data[3]) for data in self.features_data] + data = tf.py_function(_func, [path], out_types) + + out_data = {} + for f_data, feature in zip(self.features_data, data): + feat_type, feat_name, out_name, dtype, _ = f_data + feature.set_shape(feature.get_shape()) + out_data[out_name] = feature + + return out_data + + def _read_vector_data(self, path, column_path, vector_data, features_list): + """ + TF op for reading an eopatch at a given path. + It must have a column with the corresponding path + """ + def _func(path) : + path = path.numpy().decode('utf-8') + vector_data_ = vector_data.copy() + vector_data_ = vector_data_[vector_data_[column_path] == path] + + data = [] + for feat, dtype_ in features_list: + data.append(np.array(vector_data_[feat].astype(dtype_))) + return data + + data = tf.py_function(_func, [path], [feat[1] for feat in features_list]) + out_data = {} + for fname, feature in zip(features_list, data): + feature.set_shape(feature.get_shape()) + out_data[fname] = feature + + return out_data + + @staticmethod + def _format_feature(out_feature): + out_df = [np.concatenate([np.expand_dims(value, axis=1) + if len(value.shape) == 1 else value + for key, value in dicto.items()], axis=-1) + for dicto in out_feature] + + out_df = [np.expand_dims(k, axis=0) for k in out_df] + return np.concatenate(out_df, axis=0) + + + def get_eopatch_tfds(self, algorithm = 'linear'): + + self._instance_tf_ds() + ds_numpy = self.dataset.map(lambda x : self._read_patch(path = x, algorithm=algorithm), + num_parallel_calls=self.AUTOTUNE) + out_feature = list(ds_numpy) + return self._format_feature(out_feature) + + def get_vector_tfds(self, vector_data, features_list, column_path): + + self._instance_tf_ds() + out_labels = list(self.vector_dataset.map( + lambda path : self._read_vector_data( + path, column_path, vector_data, features_list), + num_parallel_calls=self.AUTOTUNE)) + + npy_labels = self._format_feature(out_labels) + npy_labels = npy_labels.reshape(npy_labels.shape[0], npy_labels.shape[-1]) + + return npy_labels + + + + + diff --git a/eo-crops/eocrops/utils/utils.py b/eo-crops/eocrops/utils/utils.py index ddb954c..d25490a 100644 --- a/eo-crops/eocrops/utils/utils.py +++ b/eo-crops/eocrops/utils/utils.py @@ -10,6 +10,11 @@ +def save_numpy(path, array, name_array): + with open(os.path.join(path, name_array + '.npy'), 'wb') as f: + np.save(f, array) + + def MetaInfos(saving_path, N) : with rasterio.open(saving_path) as src0 : meta = src0.meta @@ -77,5 +82,25 @@ def create_polygon_bbox(longitude, latitude, distance) : +def get_resampled_periods(start, end, year, days_range=1): + ''' + Get the resampled periods from the resample range + ''' + import dateutil + import datetime as dt + resample_range_ = (str(year) + start, + str(year) + end, + days_range) + + start_date = dateutil.parser.parse(resample_range_[0]) + end_date = dateutil.parser.parse(resample_range_[1]) + step = dt.timedelta(days=resample_range_[2]) + + days = [start_date] + while days[-1] + step < end_date: + days.append(days[-1] + step) + days = [str(day).split(' ')[0] for day in days] + return days + diff --git a/eo-crops/examples/Sentinel data.ipynb b/eo-crops/examples/Sentinel data.ipynb index 52c9319..17cbaff 100644 --- a/eo-crops/examples/Sentinel data.ipynb +++ b/eo-crops/examples/Sentinel data.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "5a9eebce", "metadata": { "pycharm": { "name": "#%% md\n" @@ -13,6 +14,7 @@ }, { "cell_type": "markdown", + "id": "46193fec", "metadata": { "pycharm": { "name": "#%% md\n" @@ -32,6 +34,7 @@ }, { "cell_type": "markdown", + "id": "4b394e51", "metadata": { "pycharm": { "name": "#%% md\n" @@ -43,6 +46,7 @@ }, { "cell_type": "markdown", + "id": "9c49c15e", "metadata": { "pycharm": { "name": "#%% md\n" @@ -54,7 +58,8 @@ }, { "cell_type": "code", - "execution_count": 176, + "execution_count": 1, + "id": "2714c2f2", "metadata": { "pycharm": { "name": "#%%\n" @@ -82,6 +87,7 @@ }, { "cell_type": "markdown", + "id": "59c8b191", "metadata": { "pycharm": { "name": "#%% md\n" @@ -93,7 +99,8 @@ }, { "cell_type": "code", - "execution_count": 162, + "execution_count": 2, + "id": "7f7e1a00", "metadata": { "pycharm": { "name": "#%%\n" @@ -104,7 +111,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "/home/s999379/git-repo/eo-crops\n" + "/home/johann/Documents/git-repo/eo-crops\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" ] } ], @@ -117,13 +132,23 @@ }, { "cell_type": "code", - "execution_count": 163, + "execution_count": 3, + "id": "e325fa21", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], "source": [ "api =''\n", "client_id =''\n", @@ -135,7 +160,8 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 18, + "id": "6bad372b", "metadata": { "pycharm": { "name": "#%%\n" @@ -143,7 +169,7 @@ }, "outputs": [], "source": [ - "time_period = ('2020-04-15', '2020-06-15')\n", + "time_period = ('2020-02-15', '2020-08-15')\n", "kwargs = dict(polygon=shapefile_input,\n", " time_stamp=time_period,\n", " config=config)" @@ -151,6 +177,7 @@ }, { "cell_type": "markdown", + "id": "32f5f8c1", "metadata": { "pycharm": { "name": "#%% md\n" @@ -162,7 +189,8 @@ }, { "cell_type": "code", - "execution_count": 165, + "execution_count": 19, + "id": "9f923e73", "metadata": { "pycharm": { "name": "#%%\n" @@ -170,6 +198,7 @@ }, "outputs": [], "source": [ + "warnings.filterwarnings(\"ignore\")\n", "patch = sentinel2.workflow_instructions_S2L2A(**kwargs,\n", " path_out = None, #you can specify here a path to save the EOPatch object\n", " coverage_predicate=0.5,\n", @@ -179,7 +208,8 @@ }, { "cell_type": "code", - "execution_count": 166, + "execution_count": 20, + "id": "ef3b89b7", "metadata": { "pycharm": { "name": "#%%\n" @@ -188,7 +218,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -202,14 +232,15 @@ "source": [ "#RGB\n", "plt.figure(figsize=(5, 5))\n", - "plt.imshow(np.clip(patch.data['BANDS-S2-L2A'][25][..., [2, 1, 0]]*2.5, 0, 1), vmin=0, vmax=1);\n", + "plt.imshow(np.clip(patch.data['BANDS-S2-L2A'][4][..., [2, 1, 0]]*2.5, 0, 1), vmin=0, vmax=1);\n", "plt.axis(False);\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 171, + "execution_count": 21, + "id": "4babe8e5", "metadata": { "pycharm": { "name": "#%%\n" @@ -217,13 +248,14 @@ }, "outputs": [], "source": [ - "masking = preprocessing.MaskPixels([\"NDVI\"])\n", + "masking = preprocessing.MaskPixels([\"NDVI\", \"LAI\"])\n", "patch = masking.execute(patch, erosion = 1)" ] }, { "cell_type": "code", - "execution_count": 172, + "execution_count": 23, + "id": "f0320999", "metadata": { "pycharm": { "name": "#%%\n" @@ -232,7 +264,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -246,14 +278,15 @@ "source": [ "#NDVI\n", "plt.figure(figsize=(5, 5))\n", - "plt.imshow(patch.data['NDVI'][15].squeeze());\n", + "plt.imshow(patch.data['NDVI'][15,].squeeze());\n", "plt.axis(False);\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 224, + "execution_count": 24, + "id": "93f2b9ae", "metadata": { "pycharm": { "name": "#%%\n" @@ -262,7 +295,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -275,20 +308,21 @@ ], "source": [ "#LAI Time Series from masked field\n", - "variable = 'NDVI'\n", - "stats_df = preprocessing.get_time_series_profile(patch = patch, \n", - " variable = variable, \n", - " mask_name = 'MASK', \n", - " function = np.nanmean)\n", + "variable = 'LAI'\n", "\n", - "plt.plot(patch.timestamp, stats_df[variable])\n", + "stats_df = preprocessing.get_time_series_profile(feature_array = patch.data[variable],\n", + " crop_mask = patch.mask_timeless['MASK'],\n", + " function=np.nanmedian)\n", + "\n", + "plt.plot(patch.timestamp, stats_df)\n", "plt.xticks(rotation=90)\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 183, + "execution_count": 25, + "id": "0699a68d", "metadata": { "pycharm": { "name": "#%%\n" @@ -298,26 +332,32 @@ { "data": { "text/plain": [ - "datetime.datetime(2020, 5, 31, 0, 0)" + "datetime.datetime(2020, 5, 29, 0, 0)" ] }, - "execution_count": 183, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Peak of the season is at 31/05 \n", - "time_argmax = np.nanargmax(stats_df[variable])\n", + "time_argmax = np.nanargmax(stats_df)\n", "patch.timestamp[time_argmax]" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, + "id": "8dce547e", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ - "#If oyu would like to save the data in .tif format (e.g. NDVI on the first date)\n", + "#If you would like to save the data in .tif format (e.g. NDVI on the first date)\n", "from eolearn.io.local_io import ExportToTiffTask\n", "index_time = 0\n", "date = str(patch.timestamp[index_time]).split(' ')[0]\n", @@ -326,17 +366,12 @@ " folder=os.path.join('your_path_'+ date),\n", " band_indices=[0],\n", " date_indices=[index_time])\n", - "export.execute(patch)" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + "patch = export.execute(patch)" + ] }, { "cell_type": "markdown", + "id": "8137402a", "metadata": { "pycharm": { "name": "#%% md\n" @@ -348,7 +383,8 @@ }, { "cell_type": "code", - "execution_count": 214, + "execution_count": 28, + "id": "f94d58fc", "metadata": { "pycharm": { "name": "#%%\n" @@ -359,12 +395,13 @@ "s1_eopatch = sentinel1.workflow_instructions_S1IW(**kwargs,\n", " speckle_lee_window = 3,\n", " orbit_direction = 'ASC',\n", - " backCoeff = 'SIGMA0_ELLIPSOID' ) # you can add period_length in the dictionary to resample" + " backCoeff = 'SIGMA0_ELLIPSOID' ) " ] }, { "cell_type": "code", - "execution_count": 215, + "execution_count": 29, + "id": "8ef78417", "metadata": { "pycharm": { "name": "#%%\n" @@ -372,9 +409,11 @@ }, "outputs": [], "source": [ + "#Compute Radar Vegetation Index\n", "VV = s1_eopatch.data['BANDS-S1-IW'][...,0]\n", "VH = s1_eopatch.data['BANDS-S1-IW'][...,1]\n", "RVI = (4*VH)/(VH+VV)\n", + "#Add the feature to the EOPatch\n", "s1_eopatch.add_feature(FeatureType.DATA, \"RVI\", RVI[..., np.newaxis])\n", "masking = preprocessing.MaskPixels([ \"RVI\"])\n", "s1_eopatch = masking.execute(s1_eopatch)" @@ -382,7 +421,8 @@ }, { "cell_type": "code", - "execution_count": 216, + "execution_count": 31, + "id": "3e549f7f", "metadata": { "pycharm": { "name": "#%%\n" @@ -391,7 +431,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -406,13 +446,14 @@ "#Display RVI from SIGMA0 without any speckle filtering\n", "s1_eopatch = masking.execute(s1_eopatch)\n", "plt.figure(figsize=(5, 5))\n", - "plt.imshow(s1_eopatch.data['RVI'][25,].squeeze());\n", + "plt.imshow(s1_eopatch.data['RVI'][15,].squeeze());\n", "plt.axis(False);\n", "plt.show()" ] }, { "cell_type": "markdown", + "id": "844ed4e9", "metadata": { "pycharm": { "name": "#%% md\n" @@ -424,7 +465,8 @@ }, { "cell_type": "code", - "execution_count": 217, + "execution_count": 33, + "id": "543160b3", "metadata": { "pycharm": { "name": "#%%\n" @@ -433,14 +475,15 @@ "outputs": [], "source": [ "#Can take around 30 seconds\n", - "mutlitemp = cmd_otb.MultitempSpeckleFiltering(otb_path = '/home/s999379/git-repo/OTB-7.4.0-Linux64/bin',\n", + "mutlitemp = cmd_otb.MultitempSpeckleFiltering(otb_path = '/home/johann/Documents/OTB/OTB-8.0.1-Linux64/bin',\n", " window = 3)\n", "s1_eopatch = mutlitemp.execute(s1_eopatch)" ] }, { "cell_type": "code", - "execution_count": 220, + "execution_count": 35, + "id": "f6844f37", "metadata": { "pycharm": { "name": "#%%\n" @@ -448,9 +491,11 @@ }, "outputs": [], "source": [ + "#Compare backscatter values after multitemporal smoothing\n", "VH = s1_eopatch.data['VH_filtered']\n", "VV = s1_eopatch.data['VV_filtered']\n", "RVI_smoothed = (4*VH)/(VH+VV)\n", + "#Add the value smoothed to the EOPatch\n", "s1_eopatch.add_feature(FeatureType.DATA, \"RVI_smoothed\", RVI_smoothed)\n", "masking = preprocessing.MaskPixels([\"RVI_smoothed\"])\n", "s1_eopatch = masking.execute(s1_eopatch)" @@ -458,7 +503,8 @@ }, { "cell_type": "code", - "execution_count": 222, + "execution_count": 37, + "id": "d10c479b", "metadata": { "pycharm": { "name": "#%%\n" @@ -467,7 +513,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -480,14 +526,15 @@ ], "source": [ "plt.figure(figsize=(5, 5))\n", - "plt.imshow(s1_eopatch.data['RVI_smoothed'][25,].squeeze().squeeze());\n", + "plt.imshow(s1_eopatch.data['RVI_smoothed'][15,].squeeze().squeeze());\n", "plt.axis(False);\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 223, + "execution_count": 41, + "id": "226114f1", "metadata": { "pycharm": { "name": "#%%\n" @@ -496,7 +543,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -510,15 +557,23 @@ "source": [ "#LAI Time Series from masked field\n", "variable = 'RVI_smoothed'\n", - "stats_df = preprocessing.get_time_series_profile(patch = s1_eopatch, \n", - " variable = variable, \n", - " mask_name = 'MASK', \n", - " function = np.nanmean)\n", - "smoothed_rvi = savgol_filter(stats_df[variable], 5 , 2)\n", - "plt.plot(s1_eopatch.timestamp, smoothed_rvi)\n", + "\n", + "stats_df = preprocessing.get_time_series_profile(feature_array = s1_eopatch.data[variable],\n", + " crop_mask = s1_eopatch.mask_timeless['MASK'],\n", + " function=np.nanmedian)\n", + "\n", + "plt.plot(s1_eopatch.timestamp, stats_df)\n", "plt.xticks(rotation=90)\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d62d985d", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -542,4 +597,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb index ef05671..f768947 100644 --- a/eo-crops/examples/VHRS data.ipynb +++ b/eo-crops/examples/VHRS data.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "f564c861", "metadata": { "pycharm": { "name": "#%% md\n" @@ -13,6 +14,7 @@ }, { "cell_type": "markdown", + "id": "5a894133", "metadata": { "pycharm": { "name": "#%% md\n" @@ -38,6 +40,7 @@ }, { "cell_type": "markdown", + "id": "f4e10161", "metadata": { "pycharm": { "name": "#%% md\n" @@ -49,6 +52,7 @@ }, { "cell_type": "markdown", + "id": "2f988e1d", "metadata": { "pycharm": { "name": "#%% md\n" @@ -60,7 +64,8 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, + "id": "0b155914", "metadata": { "pycharm": { "name": "#%%\n" @@ -72,16 +77,12 @@ "warnings.filterwarnings(\"ignore\")\n", "\n", "import glob\n", - "\n", + "import os\n", "\n", "import geopandas as gpd\n", - "\n", - "import os\n", "import numpy as np\n", - "\n", "import matplotlib.pyplot as plt\n", "\n", - "\n", "from importlib import reload\n", "\n", "from eocrops.input import utils_sh as utils_sh\n", @@ -92,6 +93,7 @@ }, { "cell_type": "markdown", + "id": "dca58e15", "metadata": { "pycharm": { "name": "#%% md\n" @@ -103,29 +105,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, + "id": "1a695f40", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/johann/Documents/git-repo/eo-crops\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - } - ], + "outputs": [], "source": [ "dir_path = os.path.dirname(os.getcwd())\n", "print(dir_path)\n", @@ -135,22 +122,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, + "id": "e17bf6ed", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - } - ], + "outputs": [], "source": [ "api =''\n", "client_id =''\n", @@ -162,6 +141,7 @@ }, { "cell_type": "markdown", + "id": "82604180", "metadata": { "pycharm": { "name": "#%% md\n" @@ -173,7 +153,8 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, + "id": "294361fe", "metadata": { "pycharm": { "name": "#%%\n" @@ -189,7 +170,8 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, + "id": "1f12b506", "metadata": { "pycharm": { "name": "#%%\n" @@ -205,26 +187,14 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, + "id": "5034136f", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#RGB\n", "plt.figure(figsize=(5, 5))\n", @@ -235,7 +205,8 @@ }, { "cell_type": "code", - "execution_count": 202, + "execution_count": null, + "id": "b0584e33", "metadata": { "pycharm": { "name": "#%%\n" @@ -252,6 +223,7 @@ { "cell_type": "code", "execution_count": null, + "id": "6c812721", "metadata": { "pycharm": { "name": "#%%\n" @@ -268,70 +240,52 @@ }, { "cell_type": "code", - "execution_count": 203, + "execution_count": null, + "id": "b869cbb1", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#LAI Time Series from masked field\n", "variable = 'NDVI'\n", - "stats_df = preprocessing.get_time_series_profile(patch = patch, \n", - " variable = variable, \n", - " mask_name = 'MASK', \n", - " function = np.nanmean)\n", "\n", - "plt.plot(patch.timestamp, stats_df[variable])\n", + "stats_df = preprocessing.get_time_series_profile(feature_array = patch.data[variable],\n", + " crop_mask = patch.mask_timeless['MASK'],\n", + " function=np.nanmedian)\n", + "\n", + "plt.plot(patch.timestamp, stats_df)\n", "plt.xticks(rotation=90)\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, + "id": "926583fd", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#Peak of the season is at 15/05 \n", - "time_max_index = np.nanargmax(stats_df[variable])\n", - "patch.timestamp[np.nanargmax(stats_df[variable])]" + "time_max_index = np.nanargmax(stats_df)\n", + "patch.timestamp[np.nanargmax(stats_df)]" ] }, { "cell_type": "code", "execution_count": null, + "id": "8f80db4e", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "#If oyu would like to save the data in .tif format (e.g. NDVI on the first date)\n", @@ -343,17 +297,12 @@ " folder=os.path.join('your_path_'+ date),\n", " band_indices=[0],\n", " date_indices=[index_time])\n", - "export.execute(patch)" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + "patch = export.execute(patch)" + ] }, { "cell_type": "markdown", + "id": "20388146", "metadata": { "pycharm": { "name": "#%% md\n" @@ -365,7 +314,8 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, + "id": "04ac76a8", "metadata": { "pycharm": { "name": "#%%\n" @@ -384,6 +334,7 @@ }, { "cell_type": "markdown", + "id": "ff83a5e4", "metadata": { "pycharm": { "name": "#%% md\n" @@ -393,9 +344,28 @@ "### Extract Planetscope data" ] }, + { + "cell_type": "markdown", + "id": "974b486e", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "You can retrieve order id and collection ID on your SH account (https://apps.sentinel-hub.com/dashboard/#/tpdi) \n", + "\n", + "Instead of doing a request again, you can go directly on *download_workflow.get_data* using the following ids :\n", + "\n", + "**order_id** = '2f900fad-1f5e-4a46-b6da-327012d400e1'\n", + "\n", + "**collection_id** = '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'" + ] + }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, + "id": "4cb2e048", "metadata": { "pycharm": { "name": "#%%\n" @@ -404,14 +374,13 @@ "outputs": [], "source": [ "#Define the provider as follows for Planetscope\n", - "provider_planet = ('PLANET', 'PSScene4Band')\n", - "#You can retrieve order id and collection ID on your SH account (https://apps.sentinel-hub.com/dashboard/#/tpdi) instead of doing a request again\n", - "#order_id, collection_id = '2f900fad-1f5e-4a46-b6da-327012d400e1', '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'" + "provider_planet = ('PLANET', 'PSScene4Band')" ] }, { "cell_type": "code", - "execution_count": 133, + "execution_count": null, + "id": "f8246811", "metadata": { "pycharm": { "name": "#%%\n" @@ -425,24 +394,14 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": null, + "id": "8c19d2aa", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"3bd9ec08-a159-4e7d-9e5f-a9ef2f5bb0b8\",\"exp\":1643712934,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"e79e4f71-3649-4c29-af01-83fe1122789d\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n", - "7802e29a-cf4e-49bb-8c31-1977db377682\n", - "1.4870982763449545\n", - "CREATED\n" - ] - } - ], + "outputs": [], "source": [ "#You can access to all the meta data in results.\n", "len(results['features'])" @@ -450,24 +409,14 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": null, + "id": "f435d2ad", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "24" - ] - }, - "execution_count": 102, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#Check the status of the order. Image will not be available \n", "collection_id = download_workflow.confirm_order(order_id)" @@ -476,6 +425,7 @@ { "cell_type": "code", "execution_count": null, + "id": "0bac7cab", "metadata": { "pycharm": { "name": "#%%\n" @@ -489,7 +439,8 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, + "id": "52ab8a3f", "metadata": { "pycharm": { "name": "#%%\n" @@ -497,6 +448,9 @@ }, "outputs": [], "source": [ + "#order_id = '2f900fad-1f5e-4a46-b6da-327012d400e1'\n", + "#collection_id = '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'\n", + "\n", "eopatch_planet = download_workflow.get_data(order_id = order_id,\n", " collection_id = collection_id,\n", " provider = provider_planet,\n", @@ -505,7 +459,8 @@ }, { "cell_type": "code", - "execution_count": 134, + "execution_count": null, + "id": "b31542be", "metadata": { "pycharm": { "name": "#%%\n" @@ -519,34 +474,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, + "id": "6d9f1d04", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(np.clip(eopatch_planet['data']['BANDS'][..., [2, 1, 0]][7,], 0, 1));\n", @@ -556,71 +491,39 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, + "id": "f8b3d85d", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#LAI Time Series from masked field\n", "variable = 'NDVI'\n", - "stats_df = preprocessing.get_time_series_profile(patch = eopatch_planet, \n", - " variable = variable, \n", - " mask_name = 'MASK', \n", - " function = np.nanmean)\n", "\n", - "plt.plot(eopatch_planet.timestamp, stats_df[variable])\n", + "stats_df = preprocessing.get_time_series_profile(feature_array = eopatch_planet.data[variable],\n", + " crop_mask = eopatch_planet.mask_timeless['MASK'],\n", + " function=np.nanmedian)\n", + "\n", + "plt.plot(eopatch_planet.timestamp, stats_df)\n", "plt.xticks(rotation=90)\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, + "id": "7e381fb0", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "time_peak = np.nanargmax(stats_df[variable])\n", + "time_peak = np.nanargmax(stats_df)\n", "plt.figure(figsize=(5, 5))\n", "plt.imshow(eopatch_planet.data['NDVI'][time_peak,].astype(float))\n", "plt.colorbar()\n", @@ -630,6 +533,7 @@ }, { "cell_type": "markdown", + "id": "b22ce6af", "metadata": { "pycharm": { "name": "#%% md\n" @@ -641,8 +545,32 @@ "- save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "43120ed1", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "#If you would like to save the data in .tif format (e.g. NDVI on the first date)\n", + "from eolearn.io.local_io import ExportToTiffTask\n", + "index_time = 0\n", + "date = str(eopatch_planet.timestamp[index_time]).split(' ')[0]\n", + "\n", + "export = ExportToTiffTask(feature='NDVI',\n", + " folder=os.path.join('your_path_'+ date),\n", + " band_indices=[0],\n", + " date_indices=[index_time])\n", + "export.execute(eopatch_planet)" + ] + }, { "cell_type": "markdown", + "id": "916f5473", "metadata": { "pycharm": { "name": "#%% md\n" @@ -654,49 +582,46 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, + "id": "434d6383", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - } - ], + "outputs": [], "source": [ "#Define the provider as follows for Planetscope\n", "provider_spot = ('AIRBUS', 'SPOT')\n", - "#can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", - "#order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'" + "#can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi" + ] + }, + { + "cell_type": "markdown", + "id": "c1092c0c", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Instead of doing a request again, you can go directly on *download_workflow.get_data* using the following ids :\n", + "\n", + "**order_id_spot** = '222331e9-d8d3-4e2f-959c-e292a665b214'\n", + "\n", + "**collection_id_spot** = '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, + "id": "4a020238", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"626aadb6-1f80-45f8-a8fe-8c4ee0edc017\",\"exp\":1643904459,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"aa411329-c789-4790-acd6-08488e40eb99\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n", - "806a1b2f-f6b8-415a-9528-bd30ac32f867\n", - "2.5\n", - "CREATED\n" - ] - } - ], + "outputs": [], "source": [ "#Define the workflow to get your order_id and meta data. \n", "order_id_spot, results_spot = download_workflow.execute_query(provider_spot, name_query='example spot')" @@ -704,45 +629,28 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": null, + "id": "9e6c1824", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"6bb838ab-4015-4091-8522-193491e5823f\",\"exp\":1643712725,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"40ae4dbc-b655-454e-bdf3-13202b360bf6\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n", - "cbd4ae1e-e9a4-4838-add5-7ac99a1f2bd6\n", - "2.5\n", - "CREATED\n" - ] - } - ], + "outputs": [], "source": [ "collection_id_spot = download_workflow.confirm_order(order_id_spot)" ] }, { "cell_type": "code", - "execution_count": 120, + "execution_count": null, + "id": "34ed65b0", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "RUNNING\n" - ] - } - ], + "outputs": [], "source": [ "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", "download_workflow.check_status(order_id_spot)" @@ -750,24 +658,17 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, + "id": "1dfea2e7", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - } - ], + "outputs": [], "source": [ "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + "#order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'\n", "eopatch_spot = download_workflow.get_data(order_id = order_id_spot,\n", " collection_id = collection_id_spot,\n", " provider = provider_spot,\n", @@ -778,7 +679,8 @@ }, { "cell_type": "code", - "execution_count": 166, + "execution_count": null, + "id": "9e45f60b", "metadata": { "pycharm": { "name": "#%%\n" @@ -794,6 +696,7 @@ { "cell_type": "code", "execution_count": null, + "id": "7aa3df4d", "metadata": { "pycharm": { "name": "#%%\n" @@ -804,34 +707,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, + "id": "8cc20fe3", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(np.clip(eopatch_spot['data']['BANDS'][..., [2, 1, 0]][1,], 0, 1));\n", @@ -841,26 +724,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, + "id": "b81bdd5e", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(eopatch_spot.data['NDVI'][1,].astype(float), vmax = 0.88)\n", @@ -871,6 +742,7 @@ }, { "cell_type": "markdown", + "id": "bf7b7c24", "metadata": { "pycharm": { "name": "#%% md\n" @@ -884,6 +756,7 @@ }, { "cell_type": "markdown", + "id": "ed05b200", "metadata": { "pycharm": { "name": "#%% md\n" @@ -895,6 +768,7 @@ }, { "cell_type": "markdown", + "id": "9d0af543", "metadata": { "pycharm": { "name": "#%% md\n" @@ -906,7 +780,8 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, + "id": "3404967b", "metadata": { "pycharm": { "name": "#%%\n" @@ -915,14 +790,114 @@ "outputs": [], "source": [ "#Define the provider as follows for Planetscope\n", - "provider_pleaides = ('AIRBUS', 'PHR')\n", - "#In case, you can use as follows to run the example instead of ordering again data to avoid to run the order and consume credits for nothing\n", - "#order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'" + "provider_pleaides = ('AIRBUS', 'PHR')" + ] + }, + { + "cell_type": "markdown", + "id": "6e16f39f", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Instead of doing a request again, you can go directly on *download_workflow.get_data* using the following ids :\n", + "\n", + "**order_id_pleiades** = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554'\n", + "\n", + "**collection_id_pleaides** = '9eb3a890-7984-46bb-970d-db30ad5a4209'" + ] + }, + { + "cell_type": "markdown", + "id": "0620dc8e", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "collection_id_spot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e9894ec", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", + "order_id_pleiades, results_pleiades = download_workflow.execute_query(provider_pleaides, name_query='example pleaides')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83fbaecb", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "collection_id_pleaides = download_workflow.confirm_order(order_id_pleiades)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "704771b7", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", + "download_workflow.check_status( order_id_pleiades)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2669eff", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + "#order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'\n", + "eopatch_pleaides = download_workflow.get_data(order_id = order_id_pleiades,\n", + " collection_id = collection_id_pleaides,\n", + " provider = provider_pleaides,\n", + " resolution = 0.5,\n", + " pansharpen = False, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" + ] + }, + { + "cell_type": "markdown", + "id": "fb00803e", + "metadata": {}, + "source": [ + "collection_id_spot" ] }, { "cell_type": "code", "execution_count": 174, + "id": "5d0cd2ed", "metadata": { "pycharm": { "name": "#%%\n" @@ -937,6 +912,7 @@ { "cell_type": "code", "execution_count": 154, + "id": "21ac816e", "metadata": { "pycharm": { "name": "#%%\n" @@ -961,6 +937,7 @@ { "cell_type": "code", "execution_count": 155, + "id": "a6495500", "metadata": { "pycharm": { "name": "#%%\n" @@ -983,6 +960,7 @@ { "cell_type": "code", "execution_count": 19, + "id": "5faa08bc", "metadata": { "pycharm": { "name": "#%%\n" @@ -991,6 +969,7 @@ "outputs": [], "source": [ "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + "#order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'\n", "eopatch_pleaides = download_workflow.get_data(order_id = order_id_pleiades,\n", " collection_id = collection_id_pleaides,\n", " provider = provider_pleaides,\n", @@ -1002,6 +981,7 @@ { "cell_type": "code", "execution_count": 175, + "id": "321b7737", "metadata": { "pycharm": { "name": "#%%\n" @@ -1015,6 +995,7 @@ { "cell_type": "code", "execution_count": 20, + "id": "b7f8592e", "metadata": { "pycharm": { "name": "#%%\n" @@ -1052,6 +1033,7 @@ { "cell_type": "code", "execution_count": 179, + "id": "c1bd9e6e", "metadata": { "pycharm": { "name": "#%%\n" @@ -1082,6 +1064,7 @@ { "cell_type": "code", "execution_count": 22, + "id": "56e6faf1", "metadata": { "pycharm": { "name": "#%%\n" @@ -1111,6 +1094,7 @@ }, { "cell_type": "markdown", + "id": "ac81a1f7", "metadata": { "pycharm": { "name": "#%% md\n" @@ -1144,4 +1128,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/eo-crops/examples/data_loading.py b/eo-crops/examples/data_loading.py new file mode 100644 index 0000000..da552be --- /dev/null +++ b/eo-crops/examples/data_loading.py @@ -0,0 +1,46 @@ +import pandas as pd +from eolearn.core import EOPatch, FeatureType, EOTask +import numpy as np +import os +from eocrops.utils import data_loader +################################################################################# + +root_dir_or_list = '/home/johann/Documents/EOPatch samples' + +dict_df = pd.DataFrame( + dict( + labels = [0], + path = [os.path.join(root_dir_or_list, '726B-JC7987WJFX6011GR-2021_S2_L2A')] + ) +) + +features_data = [(FeatureType.DATA, 'BANDS-S2-L2A', 'BANDS-S2-L2A', 'float32', 10), + (FeatureType.DATA, 'NDVI', 'NDVI', 'float32', 1), + (FeatureType.DATA, 'NDWI', 'NDWI', 'float32', 1), + (FeatureType.DATA, 'GNDVI', 'GNDVI', 'float32', 1), + (FeatureType.DATA, 'LAI', 'LAI', 'float32', 1), + (FeatureType.DATA, 'fapar', 'fapar', 'float32', 1), + (FeatureType.DATA, 'Cab', 'Cab', 'float32', 1)] + +feature_vector = [ + ('labels', 'float32'), + ('path', 'string') +] + +kwargs_S2 = dict(name_file='X_S2', + suffix='S2', + features_data=features_data) + +pipeline_eopatch_tfds = data_loader.EOPatchDataset( + root_dir_or_list, features_data, + suffix='S2_L2A', + resampling = None, + function=np.nanmedian +) + + +npy_eopatch = pipeline_eopatch_tfds.get_eopatch_tfds(algorithm='linear') + +npy_labels = pipeline_eopatch_tfds.get_vector_tfds(vector_data=dict_df, + features_list=feature_vector, + column_path='path') diff --git a/eo-crops/examples/layers/burkina_dataframe.csv b/eo-crops/examples/layers/burkina_dataframe.csv new file mode 100644 index 0000000..71e7154 --- /dev/null +++ b/eo-crops/examples/layers/burkina_dataframe.csv @@ -0,0 +1,193 @@ +Aggregation,Annee,Variable,Id_location,Latitude,Longitude +cumul,2010,RG,200026,14.0333,-0.0333 +mean,2010,Wind,200026,14.0333,-0.0333 +cumul,2010,Precipitation,200026,14.0333,-0.0333 +min,2010,Min Temperature,200026,14.0333,-0.0333 +mean,2010,Mean Temperature,200026,14.0333,-0.0333 +max,2010,Max Temperature,200026,14.0333,-0.0333 +cumul,2010,RG,200107,11.7333,-2.9167 +mean,2010,Wind,200107,11.7333,-2.9167 +cumul,2010,Precipitation,200107,11.7333,-2.9167 +min,2010,Min Temperature,200107,11.7333,-2.9167 +mean,2010,Mean Temperature,200107,11.7333,-2.9167 +max,2010,Max Temperature,200107,11.7333,-2.9167 +cumul,2010,RG,200140,10.3333,-3.1833 +mean,2010,Wind,200140,10.3333,-3.1833 +cumul,2010,Precipitation,200140,10.3333,-3.1833 +min,2010,Min Temperature,200140,10.3333,-3.1833 +mean,2010,Mean Temperature,200140,10.3333,-3.1833 +max,2010,Max Temperature,200140,10.3333,-3.1833 +cumul,2010,RG,200099,11.1667,-4.3 +mean,2010,Wind,200099,11.1667,-4.3 +cumul,2010,Precipitation,200099,11.1667,-4.3 +min,2010,Min Temperature,200099,11.1667,-4.3 +mean,2010,Mean Temperature,200099,11.1667,-4.3 +max,2010,Max Temperature,200099,11.1667,-4.3 +cumul,2010,RG,200089,12.0667,0.35 +mean,2010,Wind,200089,12.0667,0.35 +cumul,2010,Precipitation,200089,12.0667,0.35 +min,2010,Min Temperature,200089,12.0667,0.35 +mean,2010,Mean Temperature,200089,12.0667,0.35 +max,2010,Max Temperature,200089,12.0667,0.35 +cumul,2010,RG,200133,11.25,0.7 +mean,2010,Wind,200133,11.25,0.7 +cumul,2010,Precipitation,200133,11.25,0.7 +min,2010,Min Temperature,200133,11.25,0.7 +mean,2010,Mean Temperature,200133,11.25,0.7 +max,2010,Max Temperature,200133,11.25,0.7 +cumul,2010,RG,200125,11.4833,-3.5167 +mean,2010,Wind,200125,11.4833,-3.5167 +cumul,2010,Precipitation,200125,11.4833,-3.5167 +min,2010,Min Temperature,200125,11.4833,-3.5167 +mean,2010,Mean Temperature,200125,11.4833,-3.5167 +max,2010,Max Temperature,200125,11.4833,-3.5167 +cumul,2010,RG,200001,12.35,-2.1833 +mean,2010,Wind,200001,12.35,-2.1833 +cumul,2010,Precipitation,200001,12.35,-2.1833 +min,2010,Min Temperature,200001,12.35,-2.1833 +mean,2010,Mean Temperature,200001,12.35,-2.1833 +max,2010,Max Temperature,200001,12.35,-2.1833 +cumul,2011,RG,200026,14.0333,-0.0333 +mean,2011,Wind,200026,14.0333,-0.0333 +cumul,2011,Precipitation,200026,14.0333,-0.0333 +min,2011,Min Temperature,200026,14.0333,-0.0333 +mean,2011,Mean Temperature,200026,14.0333,-0.0333 +max,2011,Max Temperature,200026,14.0333,-0.0333 +cumul,2011,RG,200107,11.7333,-2.9167 +mean,2011,Wind,200107,11.7333,-2.9167 +cumul,2011,Precipitation,200107,11.7333,-2.9167 +min,2011,Min Temperature,200107,11.7333,-2.9167 +mean,2011,Mean Temperature,200107,11.7333,-2.9167 +max,2011,Max Temperature,200107,11.7333,-2.9167 +cumul,2011,RG,200140,10.3333,-3.1833 +mean,2011,Wind,200140,10.3333,-3.1833 +cumul,2011,Precipitation,200140,10.3333,-3.1833 +min,2011,Min Temperature,200140,10.3333,-3.1833 +mean,2011,Mean Temperature,200140,10.3333,-3.1833 +max,2011,Max Temperature,200140,10.3333,-3.1833 +cumul,2011,RG,200099,11.1667,-4.3 +mean,2011,Wind,200099,11.1667,-4.3 +cumul,2011,Precipitation,200099,11.1667,-4.3 +min,2011,Min Temperature,200099,11.1667,-4.3 +mean,2011,Mean Temperature,200099,11.1667,-4.3 +max,2011,Max Temperature,200099,11.1667,-4.3 +cumul,2011,RG,200089,12.0667,0.35 +mean,2011,Wind,200089,12.0667,0.35 +cumul,2011,Precipitation,200089,12.0667,0.35 +min,2011,Min Temperature,200089,12.0667,0.35 +mean,2011,Mean Temperature,200089,12.0667,0.35 +max,2011,Max Temperature,200089,12.0667,0.35 +cumul,2011,RG,200133,11.25,0.7 +mean,2011,Wind,200133,11.25,0.7 +cumul,2011,Precipitation,200133,11.25,0.7 +min,2011,Min Temperature,200133,11.25,0.7 +mean,2011,Mean Temperature,200133,11.25,0.7 +max,2011,Max Temperature,200133,11.25,0.7 +cumul,2011,RG,200125,11.4833,-3.5167 +mean,2011,Wind,200125,11.4833,-3.5167 +cumul,2011,Precipitation,200125,11.4833,-3.5167 +min,2011,Min Temperature,200125,11.4833,-3.5167 +mean,2011,Mean Temperature,200125,11.4833,-3.5167 +max,2011,Max Temperature,200125,11.4833,-3.5167 +cumul,2011,RG,200001,12.35,-2.1833 +mean,2011,Wind,200001,12.35,-2.1833 +cumul,2011,Precipitation,200001,12.35,-2.1833 +min,2011,Min Temperature,200001,12.35,-2.1833 +mean,2011,Mean Temperature,200001,12.35,-2.1833 +max,2011,Max Temperature,200001,12.35,-2.1833 +cumul,2012,RG,200026,14.0333,-0.0333 +mean,2012,Wind,200026,14.0333,-0.0333 +cumul,2012,Precipitation,200026,14.0333,-0.0333 +min,2012,Min Temperature,200026,14.0333,-0.0333 +mean,2012,Mean Temperature,200026,14.0333,-0.0333 +max,2012,Max Temperature,200026,14.0333,-0.0333 +cumul,2012,RG,200107,11.7333,-2.9167 +mean,2012,Wind,200107,11.7333,-2.9167 +cumul,2012,Precipitation,200107,11.7333,-2.9167 +min,2012,Min Temperature,200107,11.7333,-2.9167 +mean,2012,Mean Temperature,200107,11.7333,-2.9167 +max,2012,Max Temperature,200107,11.7333,-2.9167 +cumul,2012,RG,200140,10.3333,-3.1833 +mean,2012,Wind,200140,10.3333,-3.1833 +cumul,2012,Precipitation,200140,10.3333,-3.1833 +min,2012,Min Temperature,200140,10.3333,-3.1833 +mean,2012,Mean Temperature,200140,10.3333,-3.1833 +max,2012,Max Temperature,200140,10.3333,-3.1833 +cumul,2012,RG,200099,11.1667,-4.3 +mean,2012,Wind,200099,11.1667,-4.3 +cumul,2012,Precipitation,200099,11.1667,-4.3 +min,2012,Min Temperature,200099,11.1667,-4.3 +mean,2012,Mean Temperature,200099,11.1667,-4.3 +max,2012,Max Temperature,200099,11.1667,-4.3 +cumul,2012,RG,200089,12.0667,0.35 +mean,2012,Wind,200089,12.0667,0.35 +cumul,2012,Precipitation,200089,12.0667,0.35 +min,2012,Min Temperature,200089,12.0667,0.35 +mean,2012,Mean Temperature,200089,12.0667,0.35 +max,2012,Max Temperature,200089,12.0667,0.35 +cumul,2012,RG,200133,11.25,0.7 +mean,2012,Wind,200133,11.25,0.7 +cumul,2012,Precipitation,200133,11.25,0.7 +min,2012,Min Temperature,200133,11.25,0.7 +mean,2012,Mean Temperature,200133,11.25,0.7 +max,2012,Max Temperature,200133,11.25,0.7 +cumul,2012,RG,200125,11.4833,-3.5167 +mean,2012,Wind,200125,11.4833,-3.5167 +cumul,2012,Precipitation,200125,11.4833,-3.5167 +min,2012,Min Temperature,200125,11.4833,-3.5167 +mean,2012,Mean Temperature,200125,11.4833,-3.5167 +max,2012,Max Temperature,200125,11.4833,-3.5167 +cumul,2012,RG,200001,12.35,-2.1833 +mean,2012,Wind,200001,12.35,-2.1833 +cumul,2012,Precipitation,200001,12.35,-2.1833 +min,2012,Min Temperature,200001,12.35,-2.1833 +mean,2012,Mean Temperature,200001,12.35,-2.1833 +max,2012,Max Temperature,200001,12.35,-2.1833 +cumul,2013,RG,200026,14.0333,-0.0333 +mean,2013,Wind,200026,14.0333,-0.0333 +cumul,2013,Precipitation,200026,14.0333,-0.0333 +min,2013,Min Temperature,200026,14.0333,-0.0333 +mean,2013,Mean Temperature,200026,14.0333,-0.0333 +max,2013,Max Temperature,200026,14.0333,-0.0333 +cumul,2013,RG,200107,11.7333,-2.9167 +mean,2013,Wind,200107,11.7333,-2.9167 +cumul,2013,Precipitation,200107,11.7333,-2.9167 +min,2013,Min Temperature,200107,11.7333,-2.9167 +mean,2013,Mean Temperature,200107,11.7333,-2.9167 +max,2013,Max Temperature,200107,11.7333,-2.9167 +cumul,2013,RG,200140,10.3333,-3.1833 +mean,2013,Wind,200140,10.3333,-3.1833 +cumul,2013,Precipitation,200140,10.3333,-3.1833 +min,2013,Min Temperature,200140,10.3333,-3.1833 +mean,2013,Mean Temperature,200140,10.3333,-3.1833 +max,2013,Max Temperature,200140,10.3333,-3.1833 +cumul,2013,RG,200099,11.1667,-4.3 +mean,2013,Wind,200099,11.1667,-4.3 +cumul,2013,Precipitation,200099,11.1667,-4.3 +min,2013,Min Temperature,200099,11.1667,-4.3 +mean,2013,Mean Temperature,200099,11.1667,-4.3 +max,2013,Max Temperature,200099,11.1667,-4.3 +cumul,2013,RG,200089,12.0667,0.35 +mean,2013,Wind,200089,12.0667,0.35 +cumul,2013,Precipitation,200089,12.0667,0.35 +min,2013,Min Temperature,200089,12.0667,0.35 +mean,2013,Mean Temperature,200089,12.0667,0.35 +max,2013,Max Temperature,200089,12.0667,0.35 +cumul,2013,RG,200133,11.25,0.7 +mean,2013,Wind,200133,11.25,0.7 +cumul,2013,Precipitation,200133,11.25,0.7 +min,2013,Min Temperature,200133,11.25,0.7 +mean,2013,Mean Temperature,200133,11.25,0.7 +max,2013,Max Temperature,200133,11.25,0.7 +cumul,2013,RG,200125,11.4833,-3.5167 +mean,2013,Wind,200125,11.4833,-3.5167 +cumul,2013,Precipitation,200125,11.4833,-3.5167 +min,2013,Min Temperature,200125,11.4833,-3.5167 +mean,2013,Mean Temperature,200125,11.4833,-3.5167 +max,2013,Max Temperature,200125,11.4833,-3.5167 +cumul,2013,RG,200001,12.35,-2.1833 +mean,2013,Wind,200001,12.35,-2.1833 +cumul,2013,Precipitation,200001,12.35,-2.1833 +min,2013,Min Temperature,200001,12.35,-2.1833 +mean,2013,Mean Temperature,200001,12.35,-2.1833 +max,2013,Max Temperature,200001,12.35,-2.1833 diff --git a/eo-crops/examples/vhrs.py b/eo-crops/examples/vhrs.py deleted file mode 100644 index c60b9f3..0000000 --- a/eo-crops/examples/vhrs.py +++ /dev/null @@ -1,4 +0,0 @@ -import geopandas as gpd -import os -os.getcwd() -df = gpd.read_file('/home/johann/Documents/Syngenta/polygonized_file.shp') \ No newline at end of file diff --git a/eo-crops/examples/weather_data.py b/eo-crops/examples/weather_data.py new file mode 100644 index 0000000..3966489 --- /dev/null +++ b/eo-crops/examples/weather_data.py @@ -0,0 +1,81 @@ + +import pandas as pd +from eocrops.input.meteoblue import CEHUBExtraction, CEHubFormatting + +############################################################################################################### +#Read the file +input_file = pd.read_csv('./examples/layers/burkina_dataframe.csv') +input_file['coordinates'] = list( + zip(input_file['Longitude'], input_file['Latitude']) +) + +input_file['Id_location'] = input_file['Id_location'].astype(str) +input_file = input_file[input_file['Aggregation'].isin(['mean'])] +input_file[['Id_location', 'Annee']].drop_duplicates().shape + +############################################################################################################### +#Step 1 : Define the query with a backbone (=units, jobs parameters) and your input file features (locations,..) +############################################################################################################### + +queryBackbone = { + "units": { + "temperature": "C", + "velocity": "km/h", + "length": "metric", + "energy": "watts" + }, + "timeIntervalsAlignment": None, + "runOnJobQueue": True, + "oneTimeIntervalPerGeometry": True, + "checkOnly": False, + "requiresJobQueue": False, + "geometry": { + "type": "GeometryCollection", + "geometries": None + }, + "format": "csvIrregular", # best format + "timeIntervals": None +} + + +pipeline_cehub = CEHUBExtraction(api_key = '', + queryBackbone = queryBackbone, + ids = input_file['Id_location'].values, + coordinates= input_file['coordinates'].values, + years = input_file['Annee'].values) + +stat = 'mean' + +query = [{"domain": "ERA5", "gapFillDomain": "NEMS4", + "timeResolution": "daily", + "codes": [ + {"code": 52, "level": "2 m above gnd", "aggregation": stat}, # Relative Humidity + {"code": 11, "level": "2 m above gnd", "aggregation": stat}, # air temperature (°C) + {"code": 32, "level": "2 m above gnd", "aggregation": stat}, # Wind Speed + {"code": 180, "level": "sfc", "aggregation": stat}, #wind gust + {"code": 256, "level": "sfc","aggregation": stat}, # Diffuse Shortwave Radiation + {"code": 56, "level": "2 m above gnd","aggregation": stat}, # Vapor Pressure Deficit + {"code": 260, "level": "2 m above gnd","aggregation": stat}, # FAO Reference Evapotranspiration, + {"code": 261, "level": "sfc", "aggregation": stat}, # Evapotranspiration + {"code": 52, "level": "2 m above gnd","aggregation": stat}, # Relative humidity + ], +}] + +df_output = pipeline_cehub.execute(query = query, time_interval = ('01-01', '12-31')) +df_output.to_csv('./examples/layers/mean_meteoblue.csv', index = False) + +############################################################################################################### +#Step 2 : reformat file given a resampling range (e.g. every 8 days from the 1st of January into 31 of December +############################################################################################################### + +df_output = pd.read_csv('./examples/layers/mean_meteoblue.csv', skiprows=1) + + +pipeline_refactor = CEHubFormatting( + input_file = input_file, + id_column = 'Id_location', + year_column = 'Annee', + resample_range=('-01-01', '-12-31', 1) +) + +df_mean = pipeline_refactor.execute(df_weather=df_output, stat='mean', return_pivot=False) diff --git a/eo-crops/readme.MD b/eo-crops/readme.MD index 1e8b809..36c4229 100644 --- a/eo-crops/readme.MD +++ b/eo-crops/readme.MD @@ -1,9 +1,9 @@ -# Earth observations for crop monitoring. +Earth observations for crop monitoring. Small python module that brings together awesome functionality from Sentinelhub, eo-learn python package and OrfeoToolBox for basic downloading and data processing. -## Installation +# Installation To install the package, you must first clone the git repository to the desired folder @@ -29,8 +29,8 @@ python -m ipykernel install --user --name=eo-crops jupyter notebook ``` -## Dependencies +# Dependencies -You should have OrfeoToolBox installed (https://www.orfeo-toolbox.org/CookBook/Installation.html) if you would like to do apply pansharpening and multitemporal speckle filtering. +You should have OrfeoToolBox installed (https://www.orfeo-toolbox.org/CookBook/Installation.html) if you would like to apply pansharpening and multitemporal speckle filtering (Quegan). Also, you should have a Sentinelhub account with credentials. The latter can be sponsored using Network of Resources program https://www.sentinel-hub.com/Network-of-Resources/. diff --git a/eo-crops/requirements.txt b/eo-crops/requirements.txt index 37732d3..c536efa 100644 --- a/eo-crops/requirements.txt +++ b/eo-crops/requirements.txt @@ -1,8 +1,10 @@ pathlib datetime +notebook +aoihttp pandas>=0.23.1 setuptools>=57.0.0 scipy>=0.19 matplotlib>=2.2.2 seaborn>=0.9.0 - +protobuf==3.20.0 From 2a40345f35abe176a9273c44bbb3b40c1e1cfda9 Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Tue, 5 Jul 2022 11:34:59 +0200 Subject: [PATCH 20/21] reload figures --- eo-crops/examples/VHRS data.ipynb | 257 +++++++++++++++++++++++------- 1 file changed, 199 insertions(+), 58 deletions(-) diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb index f768947..14613e7 100644 --- a/eo-crops/examples/VHRS data.ipynb +++ b/eo-crops/examples/VHRS data.ipynb @@ -64,14 +64,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "0b155914", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], "source": [ "import warnings\n", "warnings.filterwarnings(\"ignore\")\n", @@ -105,24 +114,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "1a695f40", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/johann/Documents/git-repo/eo-crops\n" + ] + } + ], "source": [ "dir_path = os.path.dirname(os.getcwd())\n", "print(dir_path)\n", "#read microplot data\n", - "shapefile_input = gpd.read_file(os.path.join(dir_path, './examples/layers/POLYGON.shp'))\n" + "shapefile_input = gpd.read_file(os.path.join(dir_path, './examples/layers/POLYGON.shp'))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "e17bf6ed", "metadata": { "pycharm": { @@ -153,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "294361fe", "metadata": { "pycharm": { @@ -170,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "1f12b506", "metadata": { "pycharm": { @@ -187,14 +204,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "5034136f", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAADrCAYAAAAv8oAHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAM8ElEQVR4nO3dyY7cyBWF4ctgMmvUbKgNw34Av/+j+BEMA91wQ6q5KjlEeNG24I0Zv6BC+y7+b6tAkBnMOsXFqauhtRaSlEX5f9+AJP03Q0lSKoaSpFQMJUmpGEqSUjGUJKVy2PvHP//1j6gvMAxDd00bYPWgvd5ewzSyda2CRWiruCy7R/rN58vr7prbdUF71VP//t+8v0R7bRtaFo8Pj901FR7aX376hNYtL/3n+cvtP9Bet8/9s50rPH/43QjwcxKwojMWdtGx9N87CrmviBjA86RH8fe//fw/l/qmJCkVQ0lSKoaSpFQMJUmpGEqSUjGUJKViKElKxVCSlMpu028FpbyIiMMIso31GKNE/5rjkRUUD+dsXdnA5xzZXkNb0bpf55f+osqajO+mj9011+es1jZdnKN1AbqY2wP7/pyewVlExJeb/rplYdc8j6m7hpZ0a2XrWoB1oDwcETHA8uQGypj0/gfwM1zgfe3u8cM7SNIrMpQkpWIoSUrFUJKUiqEkKRVDSVIqhpKkVAwlSansNgIrnIJXQcmPDp4cSr+hVeB8u21hRcYXcHMNToFcZ1beq23urrk+st8Zd+1Ld83phrVXz75eoHX1ov8MPhzZtMuf7+/Quqenp+6aDZb3BvDdPu7/eHyzksmlAYdKwteEgV0yKigjw62igc+50h/0Hb4pSUrFUJKUiqEkKRVDSVIqhpKkVAwlSakYSpJSMZQkpWIoSUplt7LaYKO7of9jnOUfaZcucEzsTNvVqIUKz4LdGqq43y/smi/gOZH/Uz4i4s3IWvAXxw/dNV8eb9Fed09sHC55BtvKnvk49L+zcDJtLHScLLj/xv5wIA6sbB7j2G/yDxu8f/AVqvB7tsc3JUmpGEqSUjGUJKViKElKxVCSlIqhJCkVQ0lSKoaSpFQMJUmpdHqhdN4uaHTD+KsruCZss7bj6zXS8SDjEV4TLCuwUb+BFvb5dIX2enfO1j0+9q/58PCA9qqVVafr1n8IBTaKyTMns+cjIiY4F5xst8EW+RBs5nqAhnut7Mt9Bs62NXhfO3xTkpSKoSQpFUNJUiqGkqRUDCVJqRhKklIxlCSlYihJSmW3hljAyNCICLKsoJGzESu8JjHQ+wfNyEbvC85Qfc3fBheHY3fNp+ka7fU0s3ms949P3TUrLH+usLxXwKk1Ora49sufw0CLgPBpglnJ9GeuwRG8FZwHOdeIiAWMZy4TnQe9s8cP7yBJr8hQkpSKoSQpFUNJUiqGkqRUDCVJqRhKklIxlCSlYihJSmW30Y0b0aDFPFSYf2AZbYc3eMkDaQrDs9jg3NwKxrG+Hdjc33cXH/vXe57RXvfPz2gdGVsMJrFGxHf8ZgTPHZbIYyz9tvZGW9Nbvx0eEUGm5tJGeoV/OTCO/dMlY4Yj2L1N4Fx7fFOSlIqhJCkVQ0lSKoaSpFQMJUmpGEqSUjGUJKViKElKxVCSlMpuZfgA2qAREQWUUGHRNhqo5MKiLRseHhENVG0bbCe3E7u5qYC52m/YXO31pX/Nm/t7tNcJjljean8hHrcOa9jkuU+kNh0RFTxQWHSOEX5Ost0Af1IO8HWigucUsIQ9gZnl5RVec3xTkpSKoSQpFUNJUiqGkqRUDCVJqRhKklIxlCSlYihJSmW3PHlxnNAmbQOjUWn7cOmvW2ZYUGTTZGOazrprXh5e2GbQH66vumvWjbXy7u5uumteKjv/FTzLiIhh6O/X6AhkMBo4IqKAZh4tPJJPWXjlF60in5KOk13p3F+wbgSlyH+v7K5YG2zf7vBNSVIqhpKkVAwlSakYSpJSMZQkpWIoSUrFUJKUiqEkKRVDSVIqu53n9bCiTUbQQj00ln8bqOTOZMRnRFxV1kivC7l/VhV+8/YntG6q/bP9evOI9lq3pbuGNp3pCNsB/D4jo40jIkY42xX9VQBsro/gg27wMAbaSAfNafrdHgY4Nnfony0o50dERA2QB7QEv8M3JUmpGEqSUjGUJKViKElKxVCSlIqhJCkVQ0lSKoaSpFQMJUmp7Da6Z9hiHlu/0Uob3Yepv9dUWFO7HFjT9vTQb9F+/Pge7RVwrvbN01N3zQzmlUdEbGSudoGtY/AsIyJq6V+TzNSOiGiV1YA30BCf4LxpshcoQ0cE/5zbBtra8CzKCJ8T2I6O6EbnAe9rj29KklIxlCSlYihJSsVQkpSKoSQpFUNJUiqGkqRUDCVJqeyWJzc6whaM5lwCjvkERa4Njjx9XlkR7d3b6+6aQ9k9qm9ub+/QuhnMpyWjgSMCFSPpmFtaZCxgQzoOl35M0strcB7rAM6MjMyNiFhJeTUiBnC2tLBZ4dmSx3mEe4Gp1wF7zft7/PgWkvR6DCVJqRhKklIxlCSlYihJSsVQkpSKoSQpFUNJUiqGkqRUdmvKtJGLeq+g9R0RsYGcvDyy+Z0fLt+iddPa/wS/3D+gveq6oHUbOLUGx5QewF4rbWqDMbcREWRSMm0dk3b1bxcFZ8a+jTGCa6Ixw9+hgEr0BhvpFT7PAeyH/3IA/IUHOdce35QkpWIoSUrFUJKUiqEkKRVDSVIqhpKkVAwlSakYSpJS2Z/xWl6vVMWG4UZMY79g9vnqCu3V1iNa9/XhS3fNOtPxo7A8BpaN8HdGA+OB6WjXSrtvoFhIi3TwWxbk0PA1QfmwDezOBvicNvBJB/icCiwjk5IrHSGMZyr/IN+UJKViKElKxVCSlIqhJCkVQ0lSKoaSpFQMJUmpGEqSUjGUJKWy2+imY0oHUAM+wvj7eLzsrqmNNbVv727Rupe1X3vdQGs6Ao4GjoiCmt9w5OkI9oLjUxtcN5Jr0tOAZ3ss/S/RAsvJG/icI7heRETgsb9gDZ0MzJahaxbcvO9fFf9Fww7flCSlYihJSsVQkpSKoSQpFUNJUiqGkqRUDCVJqRhKklIxlCSlstvoLq0/Lzsi4lj6Tc/ryw9orwswzPufd49or3k5oXUrqMcOsLVLY57shudqk+vB+y/wAwy4u943HfZHxf8HmatN29VklvcAe9P0OZGyM/3LgRGeP/mrDDqje1nX7howur3LNyVJqRhKklIxlCSlYihJSsVQkpSKoSQpFUNJUiqGkqRU9sfhwsx6d3beXTPFGdrr5uFLd81pZgUz2EMLNLYVjgyNBsfmovIeU0FjbSysCIuBkiIbmRtRYeGxggeKRgP/dtHukkILimTmbERsW798SF8TxpEtJMVgipQs312yUdV7fFOSlIqhJCkVQ0lSKoaSpFQMJUmpGEqSUjGUJKViKElKxVCSlMpuo/v92SXa5GzsN7pv7m/RXk9zv/VKGszfg5S1KxwZStu9A5iNutERtuQD0Ho4vCb5mLDczub5BmvBo5G5EWgecYW/stcGmtoQHUe8bfDQyF8OFHbNCez1pw+f0F57fFOSlIqhJCkVQ0lSKoaSpFQMJUmpGEqSUjGUJKViKElKxVCSlMpuo/vt1G9qR0T8+vDcXbOdTmgv0pyuvAKMlo2g7nw2sEo0Ldqu4DOUkbWTx9afv03mK0ew1nQEa05vbUN7HWCjuKLiOrt/0oJvsB1OW9ioBY92iqAV/QNYVwd21Q2c2bwtaK89vilJSsVQkpSKoSQpFUNJUiqGkqRUDCVJqRhKklIxlCSlsluenOcXtMnz81N3zQjHsZIaV4FFRlpFOzv0s3mEBb/l9HqjUYfolyIjIgoov01nu4/6m3VmZ7bU/ueko4HpdGOyG/1urKAYSSfrHmHhdCGjhmGRkX4fSZd3gSXXFTzzu7sHtNce35QkpWIoSUrFUJKUiqEkKRVDSVIqhpKkVAwlSakYSpJSMZQkpbJb8z2OLLPeXvXH5q4zazoPS79dSsfhbrAdW8F2FbZeG7y3Am6twapzAY102k5eKvucpC1P73+E37Pp2G+lbws7f3JnB1aojw0ebgWNbvozB8vysYLvbSU/ABFBbu2WzoPe4ZuSpFQMJUmpGEqSUjGUJKViKElKxVCSlIqhJCkVQ0lSKoaSpFT2G91XZ2iTz2/66ypsvb4s/eb3doLtatgoBqOHo8HW6wyb3/PQX0dGOkdEHLb+75ZhpYOw2SxvdP+wHd7gr8YFtIUrbqT31Vf+nX0E88PLgc373hr7Pi6g4b6t7MzOh/534wzODt/jm5KkVAwlSakYSpJSMZQkpWIoSUrFUJKUiqEkKRVDSVIqu22oazgOtJG+V2GbnU/9gtZ4BUuRZOZswFGxC8tvWthEA1kLK9LV0i/IrbBUuC5oWTQydhaUOiMiVlhMPW39m3teZrTXy9xfN8MzG+FzKhMYW3yAo55hGXkADdwRjo0+n6bumjfDEe21xzclSakYSpJSMZQkpWIoSUrFUJKUiqEkKRVDSVIqhpKkVAwlSakMjc5claTfgW9KklIxlCSlYihJSsVQkpSKoSQpFUNJUir/Ar8Ghm+/tKHmAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "#RGB\n", "plt.figure(figsize=(5, 5))\n", @@ -205,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "b0584e33", "metadata": { "pycharm": { @@ -214,7 +244,6 @@ }, "outputs": [], "source": [ - "preprocessing = reload(preprocessing)\n", "#Mask out pixels that are oustide the polygon for visualisation and apply a binary erosion with radius = 1 to keep only pure pixels\n", "masking = preprocessing.MaskPixels([\"NDVI\"])\n", "patch = masking.execute(patch, erosion = 1)" @@ -222,14 +251,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "6c812721", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "#NDVI\n", "plt.figure(figsize=(5, 5))\n", @@ -240,14 +282,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "b869cbb1", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "#LAI Time Series from masked field\n", "variable = 'NDVI'\n", @@ -263,14 +318,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "926583fd", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "datetime.datetime(2020, 5, 15, 0, 0)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "#Peak of the season is at 15/05 \n", "time_max_index = np.nanargmax(stats_df)\n", @@ -279,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "8f80db4e", "metadata": { "pycharm": { @@ -314,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "04ac76a8", "metadata": { "pycharm": { @@ -364,7 +430,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "4cb2e048", "metadata": { "pycharm": { @@ -439,7 +505,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "52ab8a3f", "metadata": { "pycharm": { @@ -459,7 +525,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "b31542be", "metadata": { "pycharm": { @@ -474,14 +540,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "6d9f1d04", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(np.clip(eopatch_planet['data']['BANDS'][..., [2, 1, 0]][7,], 0, 1));\n", @@ -491,14 +570,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "f8b3d85d", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "#LAI Time Series from masked field\n", "variable = 'NDVI'\n", @@ -514,14 +606,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "7e381fb0", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "time_peak = np.nanargmax(stats_df)\n", "plt.figure(figsize=(5, 5))\n", @@ -582,7 +687,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "434d6383", "metadata": { "pycharm": { @@ -658,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "1dfea2e7", "metadata": { "pycharm": { @@ -674,12 +779,12 @@ " provider = provider_spot,\n", " resolution = 1.5,\n", " pansharpen = True,\n", - " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" + " otb_path='/home/johann/Documents/OTB/OTB-8.0.1-Linux64/bin')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "9e45f60b", "metadata": { "pycharm": { @@ -707,14 +812,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "8cc20fe3", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(np.clip(eopatch_spot['data']['BANDS'][..., [2, 1, 0]][1,], 0, 1));\n", @@ -724,14 +842,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "b81bdd5e", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(eopatch_spot.data['NDVI'][1,].astype(float), vmax = 0.88)\n", @@ -780,7 +911,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "3404967b", "metadata": { "pycharm": { @@ -867,7 +998,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "e2669eff", "metadata": { "pycharm": { @@ -959,7 +1090,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 33, "id": "5faa08bc", "metadata": { "pycharm": { @@ -974,27 +1105,38 @@ " collection_id = collection_id_pleaides,\n", " provider = provider_pleaides,\n", " resolution = 0.5,\n", - " pansharpen = False, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", - " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" + " pansharpen = True, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + " otb_path = '/home/johann/Documents/OTB/OTB-8.0.1-Linux64/bin')" ] }, { "cell_type": "code", - "execution_count": 175, + "execution_count": 34, "id": "321b7737", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[datetime.datetime(2020, 6, 6, 11, 21, 32, 600000)]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "eopatch_pleaides.timestamp" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 35, "id": "b7f8592e", "metadata": { "pycharm": { @@ -1002,14 +1144,6 @@ } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - }, { "data": { "image/png": "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\n", @@ -1032,7 +1166,7 @@ }, { "cell_type": "code", - "execution_count": 179, + "execution_count": 36, "id": "c1bd9e6e", "metadata": { "pycharm": { @@ -1040,11 +1174,18 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -1063,7 +1204,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 37, "id": "56e6faf1", "metadata": { "pycharm": { @@ -1073,7 +1214,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 3e7f623e0fb016d449ba2728542fb328c919f960 Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Mon, 8 Aug 2022 15:39:35 +0200 Subject: [PATCH 21/21] adapt to eolearn >=1.0 --- eo-crops/environment.yml | 18 +- eo-crops/eocrops/input/meteoblue.py | 14 +- eo-crops/eocrops/input/sentinel1.py | 34 +- eo-crops/eocrops/input/sentinel2.py | 96 ++-- eo-crops/eocrops/input/utils_sh.py | 69 ++- eo-crops/eocrops/input/vhrs.py | 59 ++- eo-crops/eocrops/tasks/cmd_otb.py | 27 +- eo-crops/eocrops/tasks/preprocessing.py | 173 +++++-- eo-crops/eocrops/tasks/vegetation_indices.py | 49 +- eo-crops/eocrops/utils/data_loader.py | 123 +++-- eo-crops/examples/Sentinel data.ipynb | 503 ++++++++++++++++--- eo-crops/examples/VHRS data.ipynb | 461 +++++++++-------- eo-crops/examples/data_loading.py | 65 +-- eo-crops/examples/dev_test/curve_fitting.py | 44 ++ eo-crops/examples/dev_test/data_download.py | 87 ++++ eo-crops/examples/weather_data.py | 7 +- eo-crops/requirements.txt | 1 + 17 files changed, 1274 insertions(+), 556 deletions(-) create mode 100644 eo-crops/examples/dev_test/curve_fitting.py create mode 100644 eo-crops/examples/dev_test/data_download.py diff --git a/eo-crops/environment.yml b/eo-crops/environment.yml index 9917b15..147d290 100644 --- a/eo-crops/environment.yml +++ b/eo-crops/environment.yml @@ -6,15 +6,15 @@ dependencies: - pip - gdal - pip : - - eo-learn-coregistration==0.10.1 - - eo-learn-features==0.10.1 - - eo-learn-mask==0.10.1 - - eo-learn-visualization==0.10.1 - - eo-learn-ml-tools==0.10.1 - - eo-learn-core==0.10.1 - - eo-learn-io==0.10.1 - - eo-learn-geometry==0.10.1 - - sentinelhub==3.4.2 + - eo-learn-coregistration + - eo-learn-features + - eo-learn-mask + - eo-learn-visualization + - eo-learn-ml-tools + - eo-learn-core + - eo-learn-io + - eo-learn-geometry + - sentinelhub - -r requirements.txt diff --git a/eo-crops/eocrops/input/meteoblue.py b/eo-crops/eocrops/input/meteoblue.py index 8cca295..ad4eda7 100644 --- a/eo-crops/eocrops/input/meteoblue.py +++ b/eo-crops/eocrops/input/meteoblue.py @@ -10,7 +10,7 @@ import datetime -class CEHUBExtraction: +class WeatherDownload: def __init__(self, api_key, queryBackbone, ids, coordinates, years, loop = asyncio.new_event_loop()): ''' @@ -106,22 +106,24 @@ def execute(self, query, time_interval = ('01-01', '12-31'), conc_req = 5): ############################################################################################# -class CEHubFormatting: +class WeatherPostprocess: def __init__(self, input_file, id_column, - year_column, resample_range=('-01-01', '-12-31', 1), + year_column, + resample_range=('-01-01', '-12-31', 1), planting_date_column = None, havest_date_column = None): ''' + Format output file from meteoblue API into a pd.DataFrame + :param input_file (pd.DataFrame) : input file with fields in-situ data :param id_column (str): Name of the column that contains ids of the fields to merge with CEHub data :param planting_date_column (str): Name of the column with planting date in doy format :param havest_date_column (str): Name of the column with harvest date in doy format :param year_column (str) : Name of the column with the yearly season associated to each field - :param resample_range (tuple): Interval of date to resample time series given a fixed period length (e.g. 8 days) + :param resample_range (tuple): Query period (interval of date) and number of days to aggregate over period (e.g. 8 days) instead of having daily data ''' - self.resample_range = resample_range self.id_column = id_column self.planting_date_column = planting_date_column self.havest_date_column = havest_date_column @@ -222,7 +224,7 @@ def _convert_date(x): return dateutil.parser.parse(x[:-5]) df = pd.merge(df_resampled, df_cehub, on=['timestamp', self.year_column], how='right') - + #Interpolate over new periods fill_nas = df[['period', 'location']].groupby('location').apply( lambda group: group.interpolate(method='pad', limit=self.resample_range[-1])) diff --git a/eo-crops/eocrops/input/sentinel1.py b/eo-crops/eocrops/input/sentinel1.py index 867b0d6..f1896a1 100644 --- a/eo-crops/eocrops/input/sentinel1.py +++ b/eo-crops/eocrops/input/sentinel1.py @@ -1,6 +1,5 @@ import eolearn from sentinelhub import DataCollection -from eolearn.core import SaveTask, FeatureType from eolearn.io import SentinelHubInputTask, SentinelHubDemTask import datetime from eolearn.core import OverwritePermission @@ -12,6 +11,9 @@ import eocrops.input.utils_sh as utils_sh +from eolearn.core import linearly_connect_tasks, SaveTask, EOWorkflow, FeatureType, OutputTask + + def workflow_instructions_S1IW(config, time_stamp, @@ -77,24 +79,32 @@ def workflow_instructions_S1IW(config, time_stamp, add_polygon_mask = preprocessing.PolygonMask(polygon) - field_bbox = utils.get_bounding_box(polygon) add_dem = SentinelHubDemTask('DEM', resolution=10, config=config) if path_out is None: save = utils_sh.EmptyTask() else: - if not os.path.isdir(path_out) : - os.makedirs(path_out) + os.makedirs(path_out, exist_ok=True) save = SaveTask(path_out, overwrite_permission=OverwritePermission.OVERWRITE_PATCH) - workflow = eolearn.core.LinearWorkflow(input_task, - add_dem, - add_polygon_mask, - save) + output_task = OutputTask("eopatch") + + workflow_nodes = linearly_connect_tasks(input_task, + add_dem, + add_polygon_mask, + save, output_task) + workflow = EOWorkflow(workflow_nodes) + + field_bbox = utils.get_bounding_box(polygon) + result = workflow.execute( + { + workflow_nodes[0]: { + "bbox": field_bbox, + "time_interval": time_stamp + } + } + ) - result = workflow.execute({ - input_task : {'bbox' : field_bbox, 'time_interval' : time_stamp} - }) - return result.eopatch() + return result.outputs["eopatch"] diff --git a/eo-crops/eocrops/input/sentinel2.py b/eo-crops/eocrops/input/sentinel2.py index c20712c..e62a269 100644 --- a/eo-crops/eocrops/input/sentinel2.py +++ b/eo-crops/eocrops/input/sentinel2.py @@ -5,7 +5,6 @@ import eolearn from sentinelhub import DataCollection -from eolearn.core import SaveTask, FeatureType from eolearn.io import SentinelHubDemTask, SentinelHubEvalscriptTask import datetime @@ -19,6 +18,8 @@ import eocrops.tasks.vegetation_indices as vegetation_indices import eocrops.input.utils_sh as utils_sh +from eolearn.core import SaveTask, linearly_connect_tasks, EOWorkflow, FeatureType, OutputTask + def workflow_instructions_S2L2A(config, time_stamp, @@ -75,46 +76,39 @@ def workflow_instructions_S2L2A(config, } """ - input_task = SentinelHubEvalscriptTask( - features=[(FeatureType.DATA, 'BANDS', 'BANDS-S2-L2A'), - (FeatureType.DATA, 'ILLUMINATION', 'ILLUMINATION'), - (FeatureType.MASK, 'IS_DATA'), - (FeatureType.MASK, 'CLM')], - data_collection=DataCollection.SENTINEL2_L2A, - evalscript=evalscript, - resolution=10, - maxcc=coverage_predicate, - time_difference=time_difference, - config=config, - max_threads=n_threads - ) + input_task =\ + SentinelHubEvalscriptTask( + features=[(FeatureType.DATA, 'BANDS', 'BANDS-S2-L2A'), + (FeatureType.DATA, 'ILLUMINATION', 'ILLUMINATION'), + (FeatureType.MASK, 'IS_DATA'), + (FeatureType.MASK, 'CLM')], + data_collection=DataCollection.SENTINEL2_L2A, + evalscript=evalscript, + resolution=10, + maxcc=coverage_predicate, + time_difference=time_difference, + config=config, + max_threads=n_threads + ) - add_dem = SentinelHubDemTask('DEM', resolution=10, config=config) + add_dem = SentinelHubDemTask('DEM', resolution=10, config=config) add_polygon_mask = preprocessing.PolygonMask(polygon) - field_bbox = utils.get_bounding_box(polygon) - - cloud_mask = utils_sh.CloudMaskS2L2A() + cloud_mask = utils_sh.ValidDataS2() add_coverage = utils_sh.AddValidDataCoverage() - add_valid_mask = eolearn.mask.AddValidDataMaskTask(predicate=utils_sh.calculate_valid_data_mask) + add_valid_mask = utils_sh.AddValidDataMaskTask(predicate=utils_sh.calculate_valid_data_mask) + + + remove_cloudy_scenes = eolearn.features.SimpleFilterTask((eolearn.core.FeatureType.MASK, 'VALID_DATA'), utils_sh.ValidDataCoveragePredicate(coverage_predicate)) - remove_cloudy_scenes = eolearn.features.SimpleFilterTask((eolearn.core.FeatureType.MASK, 'VALID_DATA'), - # name of output mask - utils_sh.ValidDataCoveragePredicate(coverage_predicate)) vis = vegetation_indices.VegetationIndicesS2('BANDS-S2-L2A', mask_data=bool(1 - interpolation['interpolate'])) - norm = vegetation_indices.EuclideanNorm('ECNorm', 'BANDS-S2-L2A') - if path_out is None: - save = utils_sh.EmptyTask() - else: - if not os.path.isdir(path_out): - os.makedirs(path_out) - save = SaveTask(path_out, overwrite_permission=OverwritePermission.OVERWRITE_PATCH) + norm = vegetation_indices.EuclideanNorm('ECNorm', 'BANDS-S2-L2A') if not interpolation['interpolate']: linear_interp = utils_sh.EmptyTask() @@ -128,20 +122,36 @@ def workflow_instructions_S2L2A(config, copy_features = [(FeatureType.MASK, 'CLM'), (FeatureType.DATA_TIMELESS, 'DEM'), (FeatureType.MASK_TIMELESS, 'MASK')] + linear_interp = preprocessing.InterpolateFeatures(resampled_range=resampled_range, - features=['Cab', 'fapar', 'LAI', 'NDVI', 'NDWI', 'BANDS-S2-L2A'], copy_features=copy_features) - workflow = eolearn.core.LinearWorkflow(input_task, - cloud_mask, add_valid_mask, - add_coverage, remove_cloudy_scenes, - add_dem, - add_polygon_mask, - vis, norm, - linear_interp, - save) - - result = workflow.execute({ - input_task: {'bbox': field_bbox, 'time_interval': time_stamp} - }) - return result.eopatch() + + if path_out is None: + save = utils_sh.EmptyTask() + + else: + os.makedirs(path_out, exist_ok=True) + save = SaveTask(path_out, + overwrite_permission=OverwritePermission.OVERWRITE_PATCH) + + output_task = OutputTask("eopatch") + workflow_nodes = linearly_connect_tasks(input_task, + cloud_mask, add_valid_mask, + add_coverage, remove_cloudy_scenes, + add_dem, add_polygon_mask, + vis, norm, linear_interp, + save, output_task) + workflow = EOWorkflow(workflow_nodes) + + field_bbox = utils.get_bounding_box(polygon) + result = workflow.execute( + { + workflow_nodes[0]: { + "bbox": field_bbox, + "time_interval": time_stamp + } + } + ) + + return result.outputs["eopatch"] diff --git a/eo-crops/eocrops/input/utils_sh.py b/eo-crops/eocrops/input/utils_sh.py index 7b8a100..87e7c0c 100644 --- a/eo-crops/eocrops/input/utils_sh.py +++ b/eo-crops/eocrops/input/utils_sh.py @@ -2,7 +2,7 @@ from eolearn.core import EOTask, FeatureType from sentinelhub import SHConfig import numpy as np - +from eolearn.core import AddFeatureTask, RemoveFeatureTask def config_sentinelhub_cred(api, client_id, client_secret): """ @@ -45,61 +45,48 @@ class AddValidDataCoverage(EOTask) : ''' def execute(self, eopatch) : - valid_data = eopatch.get_feature(eolearn.core.FeatureType.MASK, 'VALID_DATA') + valid_data = eopatch[eolearn.core.FeatureType.MASK]['VALID_DATA'] time, height, width, channels = valid_data.shape coverage = np.apply_along_axis(calculate_coverage, 1, valid_data.reshape((time, height*width*channels))) + add_coverage = AddFeatureTask((eolearn.core.FeatureType.SCALAR, 'COVERAGE')) + return add_coverage.execute(eopatch=eopatch, data=coverage[:, np.newaxis]) - eopatch.add_feature(eolearn.core.FeatureType.SCALAR, 'COVERAGE', coverage[:, np.newaxis]) +class AddValidDataMaskTask(EOTask): + def execute(self, eopatch): + eopatch.mask["VALID_DATA"] = eopatch.mask["IS_DATA"].astype(bool) & ~(eopatch.mask["CLM"].astype(bool)) return eopatch -class SentinelHubValidData : - """ - Combine Sen2Cor's classification map with `IS_DATA` to define a `VALID_DATA_SH` mask - The sentinel_hub's cloud mask is asumed to be found in eopatch.mask['CLM'] - """ - - def __call__(self, eopatch) : - return np.logical_and(eopatch.mask['IS_DATA'].astype(np.bool), - np.logical_not(eopatch.mask['CLM'].astype(np.bool))) - -class CloudMaskS2L2A(EOTask) : +class ValidDataS2(EOTask) : """ The tasks recognize clouds from Sentinel Scene Layers (SCL) obtained from Sen2Corr """ def execute(self, eopatch) : - eopatch.add_feature(FeatureType.MASK, "VALID_DATA", (eopatch.mask['IS_DATA']).astype(bool)) - return eopatch - - + add_cloud = AddFeatureTask((eolearn.core.FeatureType.MASK, 'VALID_DATA')) + return add_cloud.execute(eopatch=eopatch, data=(eopatch.mask['IS_DATA']).astype(bool)) -class CloudMaskFromCLM(EOTask) : +class ValidDataVHRS(EOTask) : """ The tasks recognize clouds from Sentinel Scene Layers (SCL) obtained from Sen2Corr - NDI = (A-B)/(A+B). """ def execute(self, eopatch) : - - CLM = eopatch.get_feature(FeatureType.MASK, 'CLM') - cloudy_f = list(CLM.flatten()) - - def return_na(x) : - if x in [1] : # [3, 4] : - return True - else : - return False - - g = np.array(list(map(lambda x : return_na(x), cloudy_f))) - g = g.reshape(CLM.shape[0], CLM.shape[1], CLM.shape[2]) - eopatch.add_feature(FeatureType.MASK, "IS_DATA", (1-g[..., np.newaxis]).astype(bool)) - eopatch.add_feature(FeatureType.MASK, "CLM", g[..., np.newaxis]) - eopatch.add_feature(FeatureType.MASK, "VALID_DATA", (1-g[..., np.newaxis]).astype(bool)) - + cloud_mask_ = np.invert(eopatch[FeatureType.MASK]['CLM'].astype(bool)) + + add_bool = AddFeatureTask((eolearn.core.FeatureType.MASK, 'IS_DATA')) + add_bool.execute(eopatch=eopatch, data=np.invert(cloud_mask_)) + add_cloud = AddFeatureTask((eolearn.core.FeatureType.MASK, 'CLM')) + add_cloud.execute(eopatch=eopatch, data=cloud_mask_) + add_valid = AddFeatureTask((eolearn.core.FeatureType.MASK, 'VALID_DATA')) + add_valid.execute(eopatch=eopatch, data=np.invert(cloud_mask_)) return eopatch +class ValidPixel : + def __call__(self, eopatch) : + return np.logical_and(eopatch.mask['IS_DATA'].astype(np.bool), + np.logical_not(eopatch.mask['CLM'].astype(np.bool))) class CountValid(EOTask) : """ @@ -111,13 +98,14 @@ def __init__(self, count_what, feature_name) : self.name = feature_name def execute(self, eopatch) : - eopatch.add_feature(FeatureType.MASK_TIMELESS, self.name, np.count_nonzero(eopatch.mask[self.what], axis=0)) - + add_count = AddFeatureTask((eolearn.core.FeatureType.MASK_TIMELESS, self.name)) + add_count.execute(eopatch=eopatch, data=np.count_nonzero(eopatch.mask[self.what], axis=0)) return eopatch class ValidDataCoveragePredicate : - ''' Keep an image only if below % of non contaminated pixels + ''' + Keep an image only if below % of non contaminated pixels Inputs : - threshold (float) : upper bound of percentage of pixel predicted as cloudy ''' @@ -130,7 +118,8 @@ def __call__(self, array) : class EmptyTask(EOTask) : - '''This task does not make any change. It is just to avoid to duplicate the LinearWorflow with if/else + ''' + This task does not make any change. It is just to avoid to duplicate the LinearWorflow with if/else For example, saving a EOPatch in the workflow would depend if the user specify a path in the parameters of the function workflow ''' diff --git a/eo-crops/eocrops/input/vhrs.py b/eo-crops/eocrops/input/vhrs.py index ed0ae4e..df4a35c 100644 --- a/eo-crops/eocrops/input/vhrs.py +++ b/eo-crops/eocrops/input/vhrs.py @@ -25,11 +25,10 @@ import eocrops.tasks.preprocessing as preprocessing import eocrops.tasks.cmd_otb as cmd_otb import eocrops.input.utils_sh as utils_sh -from eolearn.core import SaveTask, FeatureType, OverwritePermission,SaveTask +from eolearn.core import SaveTask, FeatureType, OverwritePermission, linearly_connect_tasks, EOWorkflow, OutputTask - -class DownloadVHRSSentinelHub : +class DownloadVHRSSentinelHub: ''' Initialize query parameters and ingest data into SH Parameters @@ -356,7 +355,7 @@ def _workflow_vhrs(self, byoc, provider, resolution, bands_name='BANDS', panshar evalscript=evalscript_byoc, ) - cloud_mask = utils_sh.CloudMaskFromCLM() + cloud_mask = utils_sh.ValidDataVHRS() add_polygon_mask = preprocessing.PolygonMask(self.shapefile) pixels_masking = preprocessing.MaskPixels([bands_name]) @@ -375,19 +374,31 @@ def _workflow_vhrs(self, byoc, provider, resolution, bands_name='BANDS', panshar if saving_path is None : save = utils_sh.EmptyTask() else : - if not os.path.isdir(saving_path) : - os.makedirs(saving_path) + os.makedirs(saving_path, exist_ok=True) save = SaveTask(saving_path, overwrite_permission=OverwritePermission.OVERWRITE_PATCH) - workflow = eolearn.core.LinearWorkflow(input_task, - cloud_mask, - add_polygon_mask, - pixels_masking, - pansharpen, - vis, - save) + output_task = OutputTask("eopatch") - return input_task, workflow, save + workflow_nodes = linearly_connect_tasks(input_task, + cloud_mask, + add_polygon_mask, + pixels_masking, + pansharpen, + vis, save, output_task) + workflow = EOWorkflow(workflow_nodes) + + field_bbox = utils.get_bounding_box(self.shapefile) + + result = workflow.execute( + { + workflow_nodes[0]: { + "bbox": field_bbox, + "time_interval": self.time_stamp + } + } + ) + + return result.outputs["eopatch"] def get_data(self, order_id, collection_id, provider, resolution, pansharpen = False, otb_path = None) : @@ -403,25 +414,19 @@ def get_data(self, order_id, collection_id, provider, resolution, pansharpen = F ------- ''' - field_bbox = utils.get_bounding_box(self.shapefile) ########################################## # Define the byoc byoc = DataCollection.define_byoc( collection_id=collection_id, name=str(order_id), ) - input_task, workflow, save = self._workflow_vhrs(byoc, - provider, - resolution, - bands_name='BANDS', - pansharpen=pansharpen, - otb_path = otb_path) - - result = workflow.execute({ - input_task : {'bbox' : field_bbox, 'time_interval': self.time_stamp} - }) - - return result.eopatch() + eopatch = self._workflow_vhrs(byoc, + provider, + resolution, + bands_name='BANDS', + pansharpen=pansharpen, + otb_path = otb_path) + return eopatch diff --git a/eo-crops/eocrops/tasks/cmd_otb.py b/eo-crops/eocrops/tasks/cmd_otb.py index 9b192eb..425c105 100644 --- a/eo-crops/eocrops/tasks/cmd_otb.py +++ b/eo-crops/eocrops/tasks/cmd_otb.py @@ -1,8 +1,6 @@ import numpy as np -import eolearn - -from eolearn.core import FeatureType, EOTask +from eolearn.core import FeatureType, EOTask, AddFeatureTask from pathlib import Path from osgeo import gdal import os @@ -11,7 +9,7 @@ import subprocess import rasterio -from eolearn.io.local_io import ExportToTiffTask, ImportFromTiffTask +from eolearn.io import ExportToTiffTask, ImportFromTiffTask @@ -71,13 +69,13 @@ def _apply_OTB_cmd(self, pol, ram = 8): def _save_temporary_geotiff(self, i, date, eopatch): ## TODO : Find a way to write temporary file without writing on disk using ExportToTiffTask to make the process faster - export = ExportToTiffTask(feature=self.feature_name, + export = ExportToTiffTask(feature= (FeatureType.DATA, self.feature_name), folder=os.path.join(self.path_in, 'S1_VV/S1_VV_' + date), band_indices=[0], date_indices=[i]) export.execute(eopatch) - export = ExportToTiffTask(feature=self.feature_name, + export = ExportToTiffTask(feature= (FeatureType.DATA, self.feature_name), folder=os.path.join(self.path_in, 'S1_VH/S1_VH_' + date), band_indices=[1], date_indices=[i]) @@ -96,7 +94,7 @@ def execute(self, eopatch, ram = 8): times = list(eopatch.timestamp) for i, t in enumerate(times): date = self._refactor_dates(t) - self._save_temporary_geotiff(i,date,eopatch) + self._save_temporary_geotiff(i, date, eopatch) ######################################################################################################## for pol in ['VV', 'VH']: @@ -112,19 +110,18 @@ def execute(self, eopatch, ram = 8): meta['count'] = len(times) year = str(eopatch.timestamp[0].year) path_tif = outfiles[0].split('_' + year)[0] + '.tif' - if 'outcore_filtered.tif' in os.listdir(outdir): + if 'outcore_filtered.tif' in os.listdir(str(outdir)): outfiles.remove(os.path.join(outdir, 'outcore_filtered.tif')) outfiles.sort() - with rasterio.open(os.path.join(os.getcwd(), path_tif), 'w', **meta) as dst: + with rasterio.open(os.path.join(self.path_in, path_tif), 'w', **meta) as dst: for i in range(1, len(times) + 1): - img = gdal.Open(os.path.join(os.getcwd(), outfiles[i - 1])).ReadAsArray() + img = gdal.Open(os.path.join(self.path_in, outfiles[i - 1])).ReadAsArray() dst.write_band(i, img) import_tif = ImportFromTiffTask((FeatureType.DATA, pol + '_filtered'), path_tif) eopatch = import_tif.execute(eopatch) - shutil.rmtree(os.path.join(self.path_in, 'S1_VV_filtered')) shutil.rmtree(os.path.join(self.path_in, 'S1_VH_filtered')) shutil.rmtree(os.path.join(self.path_in, 'S1_VV')) @@ -165,13 +162,13 @@ def _extracted_from__save_temporary_geotiff(self, date, i, eopatch, band_indices if band_indices is None : band_indices = list(range(4)) - export = ExportToTiffTask(feature=self.fname, + export = ExportToTiffTask(feature=(FeatureType.DATA, self.fname), folder=os.path.join(self.path_temporary_files, 'PAN_' + date), band_indices=[-1], date_indices=[i]) export.execute(eopatch) - export = ExportToTiffTask(feature=self.fname, + export = ExportToTiffTask(feature=(FeatureType.DATA, self.fname), folder=os.path.join(self.path_temporary_files, 'BANDS_' + date), band_indices=band_indices, date_indices=[i]) @@ -209,6 +206,6 @@ def execute(self, eopatch, band_indices=None): pan_bands = np.stack(pan_bands, axis =0) self._clean_temporary_files() - eopatch.add_feature(eolearn.core.FeatureType.DATA, 'BANDS-PAN', pan_bands) + add_pan = AddFeatureTask((FeatureType.DATA, 'BANDS-PAN')) - return eopatch \ No newline at end of file + return add_pan.execute(eopatch=eopatch, data=pan_bands) \ No newline at end of file diff --git a/eo-crops/eocrops/tasks/preprocessing.py b/eo-crops/eocrops/tasks/preprocessing.py index 8e4a0cd..99f23fa 100644 --- a/eo-crops/eocrops/tasks/preprocessing.py +++ b/eo-crops/eocrops/tasks/preprocessing.py @@ -1,4 +1,3 @@ -import numpy as np from eolearn.geometry import VectorToRasterTask from eolearn.core import FeatureType, EOTask import sentinelhub @@ -8,6 +7,9 @@ import eocrops.utils.utils as utils from eolearn.geometry.morphology import ErosionTask +from scipy.optimize import curve_fit +import numpy as np +from eolearn.core import RemoveFeatureTask class PolygonMask(EOTask) : """ @@ -117,21 +119,25 @@ def execute(self, patch, erosion = 0): class InterpolateFeatures(EOTask): - def __init__(self, resampled_range, features, - algorithm = 'linear', copy_features = None): + def __init__(self, resampled_range, + features = None, + algorithm = 'linear', + copy_features = None): self.resampled_range = resampled_range self.features = features self.algorithm = algorithm self.copy_features = copy_features - def _interpolate_feature(self, eopatch, feature, mask_feature): + def _interpolate_feature(self, eopatch, features, mask_feature): kwargs = dict(mask_feature=mask_feature, - copy_features=self.copy_features, resample_range=self.resampled_range, - feature = [(FeatureType.DATA, feature)], + feature = features, bounds_error=False) + if self.resampled_range is not None: + kwargs['copy_features'] = self.copy_features + if self.algorithm=='linear' : interp = LinearInterpolationTask( parallel=True, @@ -145,46 +151,151 @@ def _interpolate_feature(self, eopatch, feature, mask_feature): return eopatch - def execute(self, eopatch, mask_feature = None): + def execute(self, eopatch): '''Gap filling after data extraction, very useful if did not include it in the data extraction workflow''' - dico = {} + mask_feature = None if 'VALID_DATA' in list(eopatch.mask.keys()): mask_feature = (FeatureType.MASK, 'VALID_DATA') - for feature in self.features : + if self.features is None: + self.features = [(FeatureType.DATA, fname) for fname in eopatch.get_features()[FeatureType.DATA]] + + dico = {} + for ftype, fname in self.features : new_eopatch = copy.deepcopy(eopatch) - new_eopatch = self._interpolate_feature(new_eopatch, feature, mask_feature) - dico[feature] = new_eopatch.data[feature] + new_eopatch = self._interpolate_feature(new_eopatch, (ftype, fname), mask_feature) + dico[fname] = new_eopatch[ftype][fname] eopatch['data'] = dico - t, h, w, _ = eopatch.data[feature].shape + t, h, w, _ = dico[fname].shape eopatch.timestamp = new_eopatch.timestamp - eopatch['mask']['IS_DATA'] = np.zeros((t, h, w, 1))+1 + eopatch['mask']['IS_DATA'] = (np.zeros((t, h, w, 1))+1).astype(int) eopatch['mask']['VALID_DATA'] = (np.zeros((t, h, w, 1))+1).astype(bool) if "CLM" in eopatch.mask.keys(): - eopatch.remove_feature(FeatureType.MASK, "CLM") + remove_feature = RemoveFeatureTask([(FeatureType.MASK, "CLM")]) + remove_feature.execute(eopatch) return eopatch +class CurveFitting(EOTask): + def __init__(self, range_doy = None): + self.range_doy = range_doy + self.params = None + + def get_time_series_profile(self, + eopatch, + feature, + feature_mask = 'polygon_mask', + function=np.nanmedian): + + feature_array = eopatch[FeatureType.DATA][feature] + if feature_mask not in eopatch[FeatureType.MASK_TIMELESS].keys(): + raise ValueError('The feature ' + feature_mask + " is missing in MASK_TIMELESS") + crop_mask = eopatch[FeatureType.MASK_TIMELESS][feature_mask] + # Transform mask from 3D to 4D + times, h, w, shape = feature_array.shape + mask = crop_mask.reshape(1, h, w, 1) + mask = [mask for k in range(times)] + mask = np.concatenate(mask, axis=0) + ####################### + mask = [mask for k in range(shape)] + mask = np.concatenate(mask, axis=-1) + ######################## + a = np.ma.array(feature_array, mask=np.invert(mask)) + ts_mean = np.ma.apply_over_axes(function, a, [1, 2]) + ts_mean = ts_mean.reshape(ts_mean.shape[0], ts_mean.shape[-1]) + if self.range_doy is not None: + _, ids_filter = self.get_doy_period(eopatch) + ts_mean = ts_mean[ids_filter] + return ts_mean + + def get_doy_period(self, eopatch): + + first_of_year = eopatch.timestamp[0].timetuple().tm_yday + last_of_year = eopatch.timestamp[-1].timetuple().tm_yday + + times = np.asarray([time.toordinal() for time in eopatch.timestamp]) + times_ = (times - times[0]) / (times[-1] - times[0]) + times_doy = times_ * (last_of_year - first_of_year) + first_of_year + + if self.range_doy is not None: + ids_filter = np.where((times_doy > self.range_doy[0]) & + (times_doy < self.range_doy[1]))[0] + return times_doy[ids_filter], ids_filter + else: + return times_doy + + + @staticmethod + def _doubly_logistic(middle, initial_value, scale, a1, a2, a3, a4, a5): + ''' + α1 is seasonal minimum greenness + α2 is the seasonal amplitude + α3 controls the green-up rate + α4 is the green-up inflection point + α5 controls the mid-growing season greenness trajectory. + :return: + ''' + return initial_value + scale * np.piecewise( + middle, + [middle < a1, middle >= a1], + [lambda y: np.exp(-(((a1 - y) / a4) ** a5)), lambda y: np.exp(-(((y - a1) / a2) ** a3))], + ) + + def _fit_optimize_doubly(self, x_axis, y_axis, initial_parameters=None): + bounds_lower = [ + np.min(y_axis), + -np.inf, + x_axis[0], + 0.15, + 1, + 0.15, + 1, + ] + bounds_upper = [ + np.max(y_axis), + np.inf, + x_axis[-1], + np.inf, + np.inf, + np.inf, + np.inf, + ] + if initial_parameters is None: + initial_parameters = [np.mean(y_axis), 0.2, (x_axis[-1] - x_axis[0]) / 2, 0.15, 10, 0.15, 10] + + popt, pcov = curve_fit( + self._doubly_logistic, + x_axis, + y_axis, + initial_parameters, + bounds=(bounds_lower, bounds_upper), + maxfev=1000000, + absolute_sigma=True, + ) + self.params = popt + + return popt + + def execute(self, eopatch, feature, feature_mask = 'polygon_mask', function=np.nanmedian): + + avg_ts = self.get_time_series_profile(eopatch, feature, feature_mask, function) + if self.range_doy is not None: + times_doy, _ = self.get_doy_period(eopatch) + else: + times_doy = self.get_doy_period(eopatch) + + y = avg_ts.flatten() + x = (times_doy - times_doy[0]) / (times_doy[-1] - times_doy[0]) + + initial_value, scale, a1, a2, a3, a4, a5 = self._fit_optimize_doubly(x, y.flatten()) + fitted = self._doubly_logistic(x, initial_value, scale, a1, a2, a3, a4, a5) + + return fitted + + -def get_time_series_profile(feature_array, - crop_mask, - function=np.nanmedian): - - # Transform mask from 3D to 4D - times, h, w, shape = feature_array.shape - mask = crop_mask.reshape(1, h, w, 1) - mask = [mask for k in range(times)] - mask = np.concatenate(mask, axis=0) - ####################### - mask = [mask for k in range(shape)] - mask = np.concatenate(mask, axis=-1) - ######################## - a = np.ma.array(feature_array, mask=np.invert(mask)) #np.invert(mask) - ts_mean = np.ma.apply_over_axes(function, a, [1, 2]) - ts_mean = ts_mean.reshape(ts_mean.shape[0], ts_mean.shape[-1]) - return ts_mean diff --git a/eo-crops/eocrops/tasks/vegetation_indices.py b/eo-crops/eocrops/tasks/vegetation_indices.py index fc98ad3..fe14434 100644 --- a/eo-crops/eocrops/tasks/vegetation_indices.py +++ b/eo-crops/eocrops/tasks/vegetation_indices.py @@ -1,7 +1,7 @@ import math from eolearn.core import FeatureType, EOTask import numpy as np - +from eolearn.core import AddFeatureTask, RemoveFeatureTask class VegetationIndicesVHRS(EOTask): @@ -11,7 +11,6 @@ def __init__(self, feature_name) : def calcul_ratio_vegetation_indices(self): self.NDVI = (self.B4 - self.B3)/(self.B4 + self.B3) self.NDWI = (self.B2 - self.B4)/(self.B2 + self.B4) - #self.MSAVI2 = (2*self.B4 + 1 - ((2*self.B4 +1)^2)**0.5 - 8*(self.B4 - self.B3))/2 self.VARI = (self.B2 - self.B3)/(self.B2 + self.B3 - self.B1) def execute(self, eopatch, **kwargs): @@ -22,11 +21,17 @@ def execute(self, eopatch, **kwargs): self.B2 = arr0[..., 1] self.B3 = arr0[..., 2] self.B4 = arr0[..., 3] - #VIS + # VIS self.calcul_ratio_vegetation_indices() - eopatch.add_feature(FeatureType.DATA, "NDVI", self.NDVI[..., np.newaxis]) - eopatch.add_feature(FeatureType.DATA, "NDWI", self.NDWI[..., np.newaxis]) - eopatch.add_feature(FeatureType.DATA, "VARI", self.VARI[..., np.newaxis]) + + add_NDVI = AddFeatureTask((FeatureType.DATA, 'NDVI')) + add_NDVI.execute(eopatch=eopatch, data=self.NDVI[..., np.newaxis]) + + add_NDWI = AddFeatureTask((FeatureType.DATA, 'NDWI')) + add_NDWI.execute(eopatch=eopatch, data=self.NDWI[..., np.newaxis]) + + add_VARI = AddFeatureTask((FeatureType.DATA, 'VARI')) + add_VARI.execute(eopatch=eopatch, data=self.VARI[..., np.newaxis]) return eopatch @@ -305,13 +310,26 @@ def execute(self, eopatch) : self.sunAzimuthAngles = illumination_array[..., 3] self.get_vegetation_indices() - eopatch.add_feature(FeatureType.DATA, "fapar", self.fapar[..., np.newaxis]) - eopatch.add_feature(FeatureType.DATA, "LAI", self.LAI[..., np.newaxis]) - eopatch.add_feature(FeatureType.DATA, "Cab", self.Cab[..., np.newaxis]) - eopatch.add_feature(FeatureType.DATA, "NDVI", self.NDVI[..., np.newaxis]) - eopatch.add_feature(FeatureType.DATA, "NDWI", self.NDWI[..., np.newaxis]) - eopatch.add_feature(FeatureType.DATA, "GNDVI", self.GNDVI[..., np.newaxis]) - eopatch.remove_feature(FeatureType.DATA, "ILLUMINATION") + add_fapar = AddFeatureTask((FeatureType.DATA, 'fapar')) + add_fapar.execute(eopatch=eopatch, data=self.fapar[..., np.newaxis]) + + add_Cab = AddFeatureTask((FeatureType.DATA, 'Cab')) + add_Cab.execute(eopatch=eopatch, data=self.Cab[..., np.newaxis]) + + add_LAI = AddFeatureTask((FeatureType.DATA, 'LAI')) + add_LAI.execute(eopatch=eopatch, data=self.LAI[..., np.newaxis]) + + add_NDVI = AddFeatureTask((FeatureType.DATA, 'NDVI')) + add_NDVI.execute(eopatch=eopatch, data=self.NDVI[..., np.newaxis]) + + add_NDWI = AddFeatureTask((FeatureType.DATA, 'NDWI')) + add_NDWI.execute(eopatch=eopatch, data=self.NDWI[..., np.newaxis]) + + add_GNDVI = AddFeatureTask((FeatureType.DATA, 'GNDVI')) + add_GNDVI.execute(eopatch=eopatch, data=self.GNDVI[..., np.newaxis]) + + remove_illumination = RemoveFeatureTask([FeatureType.DATA, "ILLUMINATION"]) + remove_illumination.execute(eopatch) return eopatch @@ -332,9 +350,8 @@ def __init__(self, feature_name, in_feature_name) : def execute(self, eopatch) : arr = eopatch.data[self.in_feature_name] norm = np.sqrt(np.sum(arr**2, axis=-1)) - - eopatch.add_feature(FeatureType.DATA, self.feature_name, norm[..., np.newaxis]) - return eopatch + add_ecnorm = AddFeatureTask((FeatureType.DATA, self.feature_name)) + return add_ecnorm.execute(eopatch=eopatch, data = norm[..., np.newaxis]) diff --git a/eo-crops/eocrops/utils/data_loader.py b/eo-crops/eocrops/utils/data_loader.py index 644d9e1..4aac948 100644 --- a/eo-crops/eocrops/utils/data_loader.py +++ b/eo-crops/eocrops/utils/data_loader.py @@ -1,4 +1,4 @@ -from eolearn.core import EOPatch, FeatureType, EOTask +from eolearn.core import EOPatch, FeatureType, AddFeatureTask import glob import numpy as np @@ -6,29 +6,37 @@ import os from eolearn.geometry import ErosionTask -import eocrops.utils.utils as utils import eocrops.tasks.preprocessing as preprocessing import copy +from scipy import interpolate as interpolate ########################################################################################################### class EOPatchDataset: def __init__(self, - root_dir_or_list, features_data, - suffix='S2_L2A', resampling = None, + root_dir, features_data, + suffix='', resampling = None, + range_doy = (1, 365), function=np.nanmedian): - ''' - - ''' + """ + root_dir (str) : root path where EOPatch are saved + features_data (list of tuples) : features to aggregate in the dataset + suffix (str) : suffix of the EOPatch file names to read only a subset of EOPatch (e.g. '_S2'). This is very useful if you have several data sources in the same root_dir. + resampling (dict) : resampling period to make EOPatch at the same time scale and timely comparables (e.g. 8-days period) + range_doy (tuple) : suset of the time series w.r.t a range of day of the year (e.g. between the 1st day and the 365th day) + function (np.functon) : function to aggegate pixels not masked into a single time series + """ import tensorflow as tf import tensorflow_datasets as tfds global tf global tfds - self.root_dir_or_list = root_dir_or_list + self.root_dir = root_dir + self.features_data = features_data self.suffix = suffix self.mask = (FeatureType.MASK_TIMELESS, 'MASK') + self.curve_fitting = preprocessing.CurveFitting(range_doy=range_doy) if resampling is None: resampling = dict(start = '-01-01', end = '-12-31', day_periods = 8) @@ -41,46 +49,72 @@ def __init__(self, self.AUTOTUNE = tf.data.experimental.AUTOTUNE def _instance_tf_ds(self): - file_pattern = os.path.join(self.root_dir_or_list, '*_' + self.suffix) + ''' + initalize tf.data.Dataset w.r.t the file names in self.root_dir_or_list + ''' + file_pattern = os.path.join(self.root_dir, '*' + self.suffix) files = glob.glob(file_pattern) if len(files) == 0: - raise ValueError('No file in the root directory ' + self.root_dir_or_list + " ending with " + self.suffix) + raise ValueError('No file in the root directory ' + self.root_dir + " ending with " + self.suffix) files.sort() self.dataset = tf.data.Dataset.from_tensor_slices(files) self.vector_dataset = tf.data.Dataset.from_tensor_slices(files) @staticmethod - def _interpolate_feature(eopatch, feature, mask_feature, **kwargs): - kwargs['features'] = [feature] + def _interpolate_feature(eopatch, features, **kwargs): + ''' + Perform gapfilling over a new time window or not. + ''' + kwargs['features'] = features interp = preprocessing.InterpolateFeatures( **kwargs) - eopatch = interp.execute(eopatch, mask_feature) + eopatch = interp.execute(eopatch) return eopatch + def _resamping_timeseries(self, arr, doy): + ''' + Resample time series over a new periods after double logistic curve fitting + ''' + + xnew = np.arange(0, 365, self.resampling['day_periods']) + start = np.where(xnew >= doy[0])[0][0] + end = np.where(xnew <= doy[-1])[0][-1] + + flinear_cspline = interpolate.Akima1DInterpolator(doy, arr) + ylinear_cspline = flinear_cspline(xnew[start:end]) + + before_season = np.repeat(ylinear_cspline[0], xnew[:start].shape[0]) + before_season = before_season.reshape(before_season.shape[0] // ylinear_cspline.shape[1], + ylinear_cspline.shape[1]) + + after_season = np.repeat(ylinear_cspline[-1], xnew[end:].shape[0]) + after_season = after_season.reshape(after_season.shape[0] // ylinear_cspline.shape[1], + ylinear_cspline.shape[1]) + + return np.concatenate([before_season, ylinear_cspline, after_season], axis=0) + def _execute_gap_filling(self, eopatch, resampled_range, copy_features, - algorithm = 'linear', - mask_feature=None): + algorithm = 'linear'): '''Gap filling after data extraction, very useful if did not include it in the data extraction workflow''' kwargs = dict(copy_features=copy_features, resampled_range=resampled_range, algorithm = algorithm) - dico = {} + features = [] for ftype, fname, _, _, _ in self.features_data: - new_eopatch = copy.deepcopy(eopatch) - new_eopatch = self._interpolate_feature(new_eopatch, fname, mask_feature, **kwargs) - dico[fname] = new_eopatch[ftype][fname] + features.append((FeatureType.DATA, fname)) + new_eopatch = self._interpolate_feature(eopatch=eopatch, features=features, **kwargs) - eopatch['data'] = dico - - return eopatch + return new_eopatch def _prepare_eopatch(self, patch, resampled_range, algorithm = 'linear'): polygon_mask = (patch.data_timeless['FIELD_ID']>0).astype(np.int32) - patch.add_feature(self.mask[0], self.mask[1], polygon_mask.astype(bool)) + add_feature = AddFeatureTask(self.mask) + add_feature.execute(eopatch=patch, data=polygon_mask.astype(bool)) + #patch.add_feature(self.mask[0], self.mask[1], polygon_mask.astype(bool)) erode = ErosionTask(mask_feature=self.mask, disk_radius=1) erode.execute(patch) @@ -92,24 +126,39 @@ def _prepare_eopatch(self, patch, resampled_range, algorithm = 'linear'): return patch - def _read_patch(self, path, algorithm = 'linear'): + def _read_patch(self, path, algorithm = 'linear', doubly_logistic = False): """ TF op for reading an eopatch at a given path. """ def _func(path): path = path.numpy().decode('utf-8') # Load only relevant features ################################################################ + #path = os.path.join(root_dir, os.listdir(root_dir)[0]) patch = EOPatch.load(path) - year = str(patch.timestamp[0].year) - start, end = year + self.resampling['start'], year + self.resampling['end'] - resampled_range = (start, end, self.resampling['day_periods']) + if not doubly_logistic: + year = str(patch.timestamp[0].year) + start, end = year + self.resampling['start'], year + self.resampling['end'] + resampled_range = (start, end, self.resampling['day_periods']) + else: + resampled_range = None + patch = self._prepare_eopatch(patch, resampled_range, algorithm) + + doy, _ = self.curve_fitting.get_doy_period(patch) ################################################################# data = [] for feat_type, feat_name, _, dtype, _ in self.features_data: - arr = preprocessing.get_time_series_profile(feature_array = patch[feat_type][feat_name].astype(dtype), - crop_mask=patch[self.mask[0]][self.mask[1]], - function = self.function) + + arr = self.curve_fitting.get_time_series_profile(eopatch=patch, + feature=feat_name, + feature_mask= self.mask[-1], + function = self.function) + + if doubly_logistic: + arr = self.curve_fitting.execute(eopatch = patch, feature=feat_name, feature_mask=self.mask[-1]) + + arr = self._resamping_timeseries(arr.reshape(arr.shape[0], 1), doy) data.append(arr) + return data ################################################################# @@ -144,7 +193,6 @@ def _func(path) : for fname, feature in zip(features_list, data): feature.set_shape(feature.get_shape()) out_data[fname] = feature - return out_data @staticmethod @@ -157,16 +205,25 @@ def _format_feature(out_feature): out_df = [np.expand_dims(k, axis=0) for k in out_df] return np.concatenate(out_df, axis=0) + def get_eopatch_tfds(self, algorithm = 'linear', doubly_logistic = False): + ''' + Aggregate all the EOPatch files into a single 3D array, where each observation is summarized muiltivariate time series (e.g. median NDVI and NDWI) of one EOPatch - def get_eopatch_tfds(self, algorithm = 'linear'): + Parameters + ---------- + algorithm (str): name of the algorithm for gapfilling (linear or cubic) + ''' self._instance_tf_ds() - ds_numpy = self.dataset.map(lambda x : self._read_patch(path = x, algorithm=algorithm), + ds_numpy = self.dataset.map(lambda x : self._read_patch(path = x, algorithm=algorithm, doubly_logistic = doubly_logistic), num_parallel_calls=self.AUTOTUNE) out_feature = list(ds_numpy) return self._format_feature(out_feature) def get_vector_tfds(self, vector_data, features_list, column_path): + ''' + Get ground truth data from a given dataframe into a 2D array. Each observation will match with the aggregation of EOPatch + ''' self._instance_tf_ds() out_labels = list(self.vector_dataset.map( diff --git a/eo-crops/examples/Sentinel data.ipynb b/eo-crops/examples/Sentinel data.ipynb index 17cbaff..c4e831b 100644 --- a/eo-crops/examples/Sentinel data.ipynb +++ b/eo-crops/examples/Sentinel data.ipynb @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 99, "id": "2714c2f2", "metadata": { "pycharm": { @@ -76,13 +76,14 @@ "import os\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from eolearn.core import FeatureType\n", + "from eolearn.core import FeatureType, AddFeatureTask\n", "\n", "from eocrops.input import utils_sh as utils_sh\n", "from eocrops.input import sentinel1 as sentinel1\n", "from eocrops.input import sentinel2 as sentinel2\n", "from eocrops.tasks import cmd_otb as cmd_otb\n", - "from eocrops.tasks import preprocessing as preprocessing\n" + "from eocrops.tasks import preprocessing as preprocessing\n", + "from importlib import reload\n" ] }, { @@ -113,14 +114,6 @@ "text": [ "/home/johann/Documents/git-repo/eo-crops\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] } ], "source": [ @@ -132,35 +125,26 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "e325fa21", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - } - ], + "outputs": [], "source": [ - "api =''\n", - "client_id =''\n", - "client_secret =''\n", + "api = ''\n", + "client_id = ''\n", + "client_secret = ''\n", "config = utils_sh.config_sentinelhub_cred(api, client_id, client_secret)\n", - "#Provide here your planet API key \n", + "# Provide here your planet API key\n", "config.planet_key = ''" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "id": "6bad372b", "metadata": { "pycharm": { @@ -189,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 23, "id": "9f923e73", "metadata": { "pycharm": { @@ -202,13 +186,12 @@ "patch = sentinel2.workflow_instructions_S2L2A(**kwargs,\n", " path_out = None, #you can specify here a path to save the EOPatch object\n", " coverage_predicate=0.5,\n", - " interpolation={'interpolate' : True,\n", - " 'period_length' : 8}) # you can add period_length in the dictionary to resample\n" + " interpolation={'interpolate' : True}) # you can add period_length in the dictionary to resample\n" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 24, "id": "ef3b89b7", "metadata": { "pycharm": { @@ -218,7 +201,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAADrCAYAAAAv8oAHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAMs0lEQVR4nO3dzY7byBWG4VNVpNTubtszRpAg26xzA7n/XW4iQC5gMBn/dEsiq7LwZJBNWG9gITkw3mfrQpEiqa+5+HRcxhghSVnU//cJSNK/M5QkpWIoSUrFUJKUiqEkKRVDSVIqy9E//vkvf0J9gVHm2VZg9aD3Mj9esL0KXNcHOOboaK8F7BURUff5NXu9oq3i9HCarnl+mq+JiGgPh4/Ebz7+8mm+aL+gvd6/+yNad27zC/KP1xe0177dpmtuO7vnBT4bG/gO0GNunT3bldzOSt9N5sek382//fXv//GL4puSpFQMJUmpGEqSUjGUJKViKElKxVCSlIqhJCkVQ0lSKofVqm1jm4xKClOw7FXm5bFSGtqrsB5jrGBhD3bMfWPlt1ubX9wFfs5z3adrXi6syNg2Vj6sdZ2ueTo/oL1O6/z8IyJ6n5cnf3w+o732bd4q3AY7rwEKvxERHTwb1419T7bBvpx9n6+7sY8ZOyiJbvB7fsQ3JUmpGEqSUjGUJKViKElKxVCSlIqhJCkVQ0lSKoaSpFQOG2Q7nBZZyBQ8WGQkPa4GN6PlyQGiGQ4EjGuB1wxM64x5PzEiIj7ur9M19cYuxmAdy3j/PJ9keVrZB2iFHbS2eZm0weu/LPPrfz7+evxmh8ckZcwFPmiDPLQREX1+D/YbO/8baFlucArnEd+UJKViKElKxVCSlIqhJCkVQ0lSKoaSpFQMJUmpGEqSUjGUJKVyWFkdsKk6UMMatrBBO7xXNgp0Qf+RegTpoO6dNVU7/T/eweUoZFFEVDI2F7bzz/URrXt6BE1hMIo1ImKFLeCyzD/ngH9nyf95X9CTERHwng9wDwo8/8omJUdbwajneTk/IiLO4HLs9KcPB3xTkpSKoSQpFUNJUiqGkqRUDCVJqRhKklIxlCSlYihJSsVQkpTKpPIMh1wTdHZ1nx8TbhWNDukGy8BI54iIoCOKG5jRvTbYTgbHfFxZbffh9Bati/FluuQEL1qF9WTyy4FB2+GDVOrZ89PJYPlgbXNY4sdvE2QdmhcfEeSHA90Z3ZK+N4aSpFQMJUmpGEqSUjGUJKViKElKxVCSlIqhJCmVw/IknLiJhobSGmYFMUkLZo1sFiyZW6OjadkxF1DMg6cfy/owXfOmsdHALV7ROnIPwCTWr2AZNkBJkY1mjijgfpLxtRERDX5RyDXrcOxygcXOescC9A6uB5wMfMg3JUmpGEqSUjGUJKViKElKxVCSlIqhJCkVQ0lSKoaSpFQMJUmpHNZ86TRZ1BqFVU80pRRGKe2yFjB2tl/ZzNP9uqF1HVzcxzePaK+36zo/3s7Ov5LadEQ0UGPe6fMD5xuTRnTBf2fnx8R/seFPDMiTUWA9vMKzq3X+OUlTOyKigy9nQb/vOOabkqRUDCVJqRhKklIxlCSlYihJSsVQkpSKoSQpFUNJUiqGkqRUDhvdFbZLxw4aobAe3kHTdruwBuplsHZ1W+fZ/PnjBe315eMVrXv7ft7Wfnh+g/YafT5Xu8EafKUD0Me8uTvo3zz4bBTQ0R+wUUz2oj8JGOBaREQU0Ihu8PrTX1uQW1A722wFzfvNGd2SvjeGkqRUDCVJqRhKklIxlCSlYihJSsVQkpSKoSQplePyJByTOUDhkfQrIwKNzb1ebmir642V2mqfr/v8aV5QjIh4emQjbN89PU3XtMGKmB0UBhsYixoRMXZWmI0VFAHhmFtUZAwywDZiwFbhAM82fPzZOOiIKHX+DlDgNRuFFjbJMWkTcz4q+QrHLh/xTUlSKoaSpFQMJUmpGEqSUjGUJKViKElKxVCSlIqhJCkVQ0lSKoeN7tcba2dW0AilYz7JnM8C26x9sHby9XU+6vbhDRtN+4ffvUfrjq/8r2Cje63zzUpjf39ou7eQfjW85Z1Wp8kyeEzSNi+FPT+0EE3a2nScL71k6KsC2/77Pt+MZsYR35QkpWIoSUrFUJKUiqEkKRVDSVIqhpKkVAwlSakYSpJSMZQkpXJYBb5sbBb2UkC2gfnEEbBR3FjTdt9YO/bxzXm65v2HD2ivdblf1XYppPYdQYrHdApzNHb+pIU9dvg3Dx6TPBqV3XJ00WhTGz7aMcD3pIPWdETEGHAWOal0d7bXFZzbBcy7n/FNSVIqhpKkVAwlSakYSpJSMZQkpWIoSUrFUJKUiqEkKZXDdt5Oi1Ao2uCYzDHfbIezQB9PK1r34/O76ZrTGY7g7exznpZ5ea/Ccaxk0jCsdMYO71Mh9wCMf42IiM7+NpIiIOnxRsBxvvT0d3p1ycnBawFPjpxahd+nbcyvPz2vI74pSUrFUJKUiqEkKRVDSVIqhpKkVAwlSakYSpJSMZQkpWIoSUrlsNGNWq8RMUAj9AZbrw20dh/OD2iv3797i9aVmDenl3FBe8UCx/6CGjYeYUvKyWQsakQEXFZA8x5VzYO34Cu6IuyYW59ftArPn35PKlhHnouIiIDXjEzXhZN14wZ+4XGHabi+KUnKxVCSlIqhJCkVQ0lSKoaSpFQMJUmpGEqSUjGUJKVy/J/V09miCNvr4XSarvnw9APaa4H/R/2Ibb5XOb5U/9Jp4Y5Mk6XtSbIONuRoERB15EBB8av7PWd4NC24HHgaNLxRpG9Kr1mH95MUm3e41wb6muMO7UnflCSlYihJSsVQkpSKoSQpFUNJUiqGkqRUDCVJqRhKklIxlCSlMqkp09Gc89bo0/mMtvrw9G66Bm6Fx6yu7X5jVtnI1ogCKt10Mioo7eK/PhvZLCI6uOelzMcMR0RU2LwnOmwUdzSalrX46bMxxvzcSmd3ij9n8zW0BL9f59+ny+v81xEzvilJSsVQkpSKoSQpFUNJUiqGkqRUDCVJqRhKklIxlCSlYihJSuWwskpaxxER53Vesf7x+YmdUJvnZIkb2quCvSIiKsjmggdms2tWSaP4jkO6SQM7ImLAY5Lx7ZVN8o4KG8VolDScK09K/B0+/wPec1a9h+1wOgsbDAanLfj9Om9r7y/sVxRHfFOSlIqhJCkVQ0lSKoaSpFQMJUmpGEqSUjGUJKViKElK5bA8eV5WtMkPz+/nB1pYQavVeTFygWNW6TRfUhJtsFS4dzrD9n5/D1B1DxYB4bIodX4PCiwV3q8iGrCuGTFAmbSjMcmsExkRUcg4XPgJBh2HS/aD5ckBysj1kY4QPtjjm3eQpDsylCSlYihJSsVQkpSKoSQpFUNJUiqGkqRUDCVJqRhKklI5rF/+8PgWbbKCEufe56M0IyLenOab0aYwm58aUckIUlo7hueGCt3wY/YdjCCFM2cbHCfLasz3HcFLJvpueDItuGZ0sitt54PPWWA9vFbWwi4djHq+46tJ5V+Ugz0kKRFDSVIqhpKkVAwlSakYSpJSMZQkpWIoSUrFUJKUiqEkKZXjGd3rCW2y95fpmlODc7VBC5jOJyZF7Qg2O3nA/B6wkUvK5gv+nPNzA+OVI4Jf273P6847vBakqf0VmKsNN+vgnlfYNC8FTgaHvzBA6Cx4cM1eruzXFlfyywEb3ZK+N4aSpFQMJUmpGEqSUjGUJKViKElKxVCSlIqhJCmVw/LksrDMWkCRqy2sPEmqbzRJ4QTYGKSwCcp2EfFfdMfm16PCxmNt8/MvnZ0/ngBL1sAiI+0Uki7mXvBNv8+a4NNwB/igFZ4/7Zt+utyma37+5RXttd1AyZK2dA/4piQpFUNJUiqGkqRUDCVJqRhKklIxlCSlYihJSsVQkpSKoSQplcNG977P26AREaUebhMRESeYfwup99LWKxxnStrVZHzqryvRqgLWkaZ5REQB14wNPOUjbDdQ/d7gyFbaYia7VXjNBhghjGvTuPpNRj0zX16vaN1PP32ervn0hT0d4Gse6+OK9jo8zjfvIEl3ZChJSsVQkpSKoSQpFUNJUiqGkqRUDCVJqRhKklIxlCSlctjR/PnlC9qkgbm8r43N6F7AXg0Owl4abHSD5nEnDeCIaHBdBefWYSOaXNkBm9q0RT7K/Kilsnb7wIPN5zVyPJedzA+Hf7J3eJ/Ite03NiX95fOFrfs0/1VG3+CvFer8gpSVfc8PD/PNO0jSHRlKklIxlCSlYihJSsVQkpSKoSQpFUNJUiqGkqRUDsuTtysraG2g/HahBbk6X1fgmNsK9opgo2kLKI5F8GJnq/OSWVvA/NGIqOjc4MjZzop0FZRE6TTi1tjnjALWgev6dd18yaAjkHd2bW+3eZFxv7DyJB3OXB7m1+MEi80FfJ8am9J7yDclSakYSpJSMZQkpWIoSUrFUJKUiqEkKRVDSVIqhpKkVAwlSakUOiZVkv4XfFOSlIqhJCkVQ0lSKoaSpFQMJUmpGEqSUvkn0Ij/VDiV8bwAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -239,7 +222,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 25, "id": "4babe8e5", "metadata": { "pycharm": { @@ -254,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 27, "id": "f0320999", "metadata": { "pycharm": { @@ -264,7 +247,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAADrCAYAAAAv8oAHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAALBUlEQVR4nO3dXWzVdx3H8d/pc09b+gD0cbQ8tIAwCoyNsUjmHHEMo0SNiWbuwmSXerGxi8XoTNyiZjo3Q3TGRc2uNCFmITFbdD4kLlF0k4mbwB5YKS2l9GF9oD0tbU97vJ0X8/sxIHwq79f1J9/zPz2Hz/ldfPdbplAoJABwUXS9HwAA3o9SAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJgpeR6PwBwNd1997elC8LOHiyLMw8+nLniB8J/jZMSACuUEgArlBIAK5QSACuUEgArlBIAK5QSACuUEgArGf5nlFguOp797lX7smb74r3hgrg6+eD9R6/sYd5neGGFlPv6zb/6v13s5KQEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTAChvduO62PfS09CVc9cnzYaant1F6zbLB0jAz35SXZu3c3CvlvrrmBSmn+NLp+6RcSdFSmLm39ZQ060DN62Hmto5zV7xpzkkJgBVKCYAVSgmAFUoJgBVKCYAVSgmAFUoJgBVKCYAVSgmAFTa68T+z7vD3pC/Xyq73pHn5xfg3dOJcnTSrtHE2zBTerZJm5VfEW9MppfTpO14NM6+NrZFm9Y/US7nCUrxgvaltSJpVXToXZvJL2jnn6N5nPvDBOCkBsEIpAbBCKQGwQikBsEIpAbBCKQGwQikBsEIpAbBScr0fAMvT2h8+GS5GlrfNSLNubeyXcn+92B5mWrpGpFmjk9VSTrF75ztSbnapLMysrMhJsy7VlEu58fH4fbZlJ6VZH6v/Z5g53LNPmvWfcFICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJghetw8W+6vvmU9IXYefdbYebSfIX0mgtLxVKuvWo8zLzc0ynNqszGV7s21UxLs2rL4qt1VVPi3+zt3mYpV1KZDzMbmrUt+J6hVXGoNyvNOvPIIa7DBbA8UEoArFBKAKxQSgCsUEoArFBKAKxQSgCsUEoArFBKAKyw0X2DWPuD+E7tlFLq2jogzTvY8o8wczLXJs0avqzdl/36+XjeYl77nb2/+5Uw0zfbIM1qKNXu1R68XBtmjp9fI80qKtL+3WYycW7+nPb3X6yPt8PPffGRD9zUVnFSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJgpeR6PwCuXOeRx8MNue7tQ9KsW+vPSbmjgzvCTGnRojRrNl8q5QqFeC9v/+bT0qzpfHmYGZqtkWa1lE9Kub+c2BhmDu45Ls16Y7xVyp07EeeKZ7V9x56HrnwxUsFJCYAVSgmAFUoJgBVKCYAVSgmAFUoJgBVKCYAVSgmAFUoJgBU2uo1t+crT0p2ntxw8H2Z2ruiXXvMPw5uknGJsNivlbl2tPdtnWk+Emd+PbpZm5Qvx7/HkXIU067cD2mtWNMXX5raVj0uz/pjrlHLKFbaFEq8a4KQEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTAitcq5w1k7Y+eDLe1q++4JM36+MrXw8zPL9wuzcotlEm54fH4/urO5hFpVkflqJR7bao9zGRL5qVZDWUzYebkm9ulWWvWae/zrtZ3wsyxsfXSrPs2vCrlbrv5bJg5PLBPmnWtcFICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCF5cmrbNM3tCtsy2+Ol/dWV8fXp6aU0vNDu8LMirLL0qySoiUpNzDTEGa21V2QZo0uxIuYKaU0OR9fTzu1oF1he+yNrjCTWchIs7pqteXJF89uCTNzl7Xl1XyhWMqtaR4LM0f3PqO90WuEkxIAK5QSACuUEgArlBIAK5QSACuUEgArlBIAK5QSACuUEgArbHSLtj2sbWqXfmRcmqes0PaP1kmzdrf3hZkTF9ukWfm89jt1++aeMDM6Vy3NGpxdIeWUrfTBUW1WU3u86by14aI0682JRim3uBj/bXe090uzlgraEvbna7TvoxNOSgCsUEoArFBKAKxQSgCsUEoArFBKAKxQSgCsUEoArLA8mVJa+8yT4WJkYZO0O5k21kxJubPDK8PMyrppbdal+Gra3HCVNKuza1DK5Zfi37NXhtulWVXl81KuZyT+m5WV5aVZzVXx56QuRS4salfTVlXOhZm3RrXX3NaofU6D+fg7pK3VXjuclABYoZQAWKGUAFihlABYoZQAWKGUAFihlABYoZQAWKGUAFjJFArapvJydOcnviO9ub4DcTdX3aRtas9Ml0u5jPBzUBjWZhVWxhvR7c3x9a8ppTQ2Uynlpobiq24zFYvSrMx4mZRbWhFva3d2DEmzBifja3NrKuPrd1NK6eKFeimnUK4ZTimlnol4uz2llCYuZcPMmc99Tbtb9xrhpATACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMDKsryje/uXn5Y2tafv0t7evXv+HmZ2VfdKs6aWKqTcs6f3hpnZylJp1q51fWFGvfs5N1Aj5VJJ/BEUjWib2hUj2m9jLl7CTu8OrJZmFZcshZlMRvuvHVb9SfucRnfHG+4Tc9pG/fjJVVIu3TSr5YxwUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYMVuebLjZ0/EG2vdYpcKC3Kqn/R+WMoNDddKudKK+GrXTDbOpJTS8dPrwkz1O9qCX1GjtjCYHYxvUJ3q1J4/t1b7nDLFca4wrX2lF7PxImNuQVuEzd2iPf/Wzf1h5lRfizQr06pd1butbVDKOeGkBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwMo12+g+sO6QtCqceSy+znTjem1LtX+8TsotLBWHmZFT2jWrRc1zUm7f+rfDzG/e/JA0q2RU+Bi1Re1UOh1vaqeU0oJwNW3T2jFp1vCIMCylVFs3E2YmU1aaVdpfHmYW6rRN7aIG7TM/MxxfYdvR8p40qyk7JeWO3PFj7QM1wkkJgBVKCYAVSgmAFUoJgBVKCYAVSgmAFUoJgBVKCYAVSgmAlauy0b3rgafCfeGy3a3SrJamkTCztVbb6H73oraF/fLvusNM1y/GpVn9j8Xb4SlpW+TF57U7ouvi5fBU/9yfpVmT9++RcpkvxJ/TrlXnpVm/Ht8i5S5NVYaZmhPivdqtwop7tXbHeLqgvWamIxdmcvNl0qwj+5bfpraKkxIAK5QSACuUEgArlBIAK5QSACuUEgArlBIAK5QSACtXZXny+E8PWS5yvfBCvNSZUkrFs/HjT3TXSa/ZXt8n5bqr48XC3J3aIt1bZzeHmZKWZmnW0L4FKfdA28kw89HqU9KsFyd2SLlVrwi/oRnt3t/q/UNhZnCoTpq1mNWuza2tiK/N/duBb1n+W7qWOCkBsEIpAbBCKQGwQikBsEIpAbBCKQGwQikBsEIpAbBCKQGwkikUtA1YLG/7dzwqfdC9n2qQ5s2tXgwzj9/zS2nWoy99VsrVnImvEJ6vlUaluQ2X49BUqTRr4xbt2t+X7vr+Db+treCkBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwAob3bghdTz3RPjFb20dk2Ydu+cJNrWvIk5KAKxQSgCsUEoArFBKAKxQSgCsUEoArFBKAKxQSgCssDwJwAonJQBWKCUAViglAFYoJQBWKCUAViglAFYoJQBWKCUAViglAFYoJQBWKCUAViglAFYoJQBWKCUAViglAFYoJQBW/gUrsh5wYGiw0gAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -278,24 +261,25 @@ "source": [ "#NDVI\n", "plt.figure(figsize=(5, 5))\n", - "plt.imshow(patch.data['NDVI'][15,].squeeze());\n", + "plt.imshow(patch.data['NDVI'][10,].squeeze());\n", "plt.axis(False);\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 105, "id": "93f2b9ae", "metadata": { "pycharm": { "name": "#%%\n" - } + }, + "scrolled": true }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -309,19 +293,49 @@ "source": [ "#LAI Time Series from masked field\n", "variable = 'LAI'\n", + "#Subset the time series between doy 30 and 260 => useful for double logistic smoothing\n", + "curve_fit = preprocessing.CurveFitting(range_doy=(60, 300))\n", + "doy, _ = curve_fit.get_doy_period(patch)\n", + "ts_mean = curve_fit.get_time_series_profile(patch,feature=variable, feature_mask = 'MASK').flatten()\n", + "fitted = curve_fit.execute(patch, feature=variable, feature_mask = 'MASK')\n", "\n", - "stats_df = preprocessing.get_time_series_profile(feature_array = patch.data[variable],\n", - " crop_mask = patch.mask_timeless['MASK'],\n", - " function=np.nanmedian)\n", - "\n", - "plt.plot(patch.timestamp, stats_df)\n", - "plt.xticks(rotation=90)\n", + "plt.plot(patch.timestamp, fitted, label='Double logistic')\n", + "plt.plot(patch.timestamp, ts_mean, label='Original')\n", + "plt.legend(loc='upper left')\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 45, + "id": "f260c1bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.45528363, 0.15000042, 23.16021074, 0.17572339, 9.23138875])" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Parameters from doubly logistic \n", + "#α1 is seasonal minimum greenness\n", + "#α2 is the seasonal amplitude\n", + "#α3 controls the green-up rate\n", + "#α4 is the green-up inflection point\n", + "#α5 controls the mid-growing season greenness trajectory.\n", + "\n", + "curve_fit.params[2:]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, "id": "0699a68d", "metadata": { "pycharm": { @@ -332,23 +346,23 @@ { "data": { "text/plain": [ - "datetime.datetime(2020, 5, 29, 0, 0)" + "datetime.datetime(2020, 5, 31, 11, 17, 40)" ] }, - "execution_count": 25, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Peak of the season is at 31/05 \n", - "time_argmax = np.nanargmax(stats_df)\n", + "time_argmax = np.nanargmax(ts_mean)\n", "patch.timestamp[time_argmax]" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 62, "id": "8dce547e", "metadata": { "pycharm": { @@ -358,11 +372,11 @@ "outputs": [], "source": [ "#If you would like to save the data in .tif format (e.g. NDVI on the first date)\n", - "from eolearn.io.local_io import ExportToTiffTask\n", + "from eolearn.io import ExportToTiffTask\n", "index_time = 0\n", "date = str(patch.timestamp[index_time]).split(' ')[0]\n", "\n", - "export = ExportToTiffTask(feature='NDVI',\n", + "export = ExportToTiffTask(feature=(FeatureType.DATA, 'NDVI'),\n", " folder=os.path.join('your_path_'+ date),\n", " band_indices=[0],\n", " date_indices=[index_time])\n", @@ -383,7 +397,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 46, "id": "f94d58fc", "metadata": { "pycharm": { @@ -400,7 +414,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 73, "id": "8ef78417", "metadata": { "pycharm": { @@ -412,16 +426,26 @@ "#Compute Radar Vegetation Index\n", "VV = s1_eopatch.data['BANDS-S1-IW'][...,0]\n", "VH = s1_eopatch.data['BANDS-S1-IW'][...,1]\n", - "RVI = (4*VH)/(VH+VV)\n", + "RVI = (4*VH)/(VH+VV)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "0a9a6be5", + "metadata": {}, + "outputs": [], + "source": [ "#Add the feature to the EOPatch\n", - "s1_eopatch.add_feature(FeatureType.DATA, \"RVI\", RVI[..., np.newaxis])\n", + "add_rvi = AddFeatureTask((FeatureType.DATA, \"RVI\"))\n", + "add_rvi.execute(eopatch = s1_eopatch, data = RVI[..., np.newaxis])\n", "masking = preprocessing.MaskPixels([ \"RVI\"])\n", "s1_eopatch = masking.execute(s1_eopatch)" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 76, "id": "3e549f7f", "metadata": { "pycharm": { @@ -451,6 +475,41 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": 104, + "id": "73335e7e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#RVI Time Series from masked field\n", + "variable = 'RVI'\n", + "\n", + "curve_fit = preprocessing.CurveFitting(range_doy=(60, 300))\n", + "doy, _ = curve_fit.get_doy_period(s1_eopatch)\n", + "\n", + "ts_mean = curve_fit.get_time_series_profile(s1_eopatch,feature=variable, feature_mask = 'MASK').flatten()\n", + "fitted = curve_fit.execute(s1_eopatch, feature=variable, feature_mask = 'MASK')\n", + "\n", + "plt.plot(doy, fitted, label='Double logistic')\n", + "plt.plot(doy, ts_mean, label='Original')\n", + "plt.legend(loc='upper left')\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "id": "844ed4e9", @@ -465,24 +524,305 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 86, "id": "543160b3", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-08-08 14:38:31 (INFO) MultitempFilteringOutcore: Default RAM limit for OTB is 256 MB\n", + "2022-08-08 14:38:31 (INFO) MultitempFilteringOutcore: GDAL maximum cache size is 781 MB\n", + "2022-08-08 14:38:31 (INFO) MultitempFilteringOutcore: OTB will use at most 8 threads\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Estimated memory for full processing: 0.376572MB (avail.: 8 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 14:38:31 (INFO): File ./S1_VV/outcore.tif will be written in 1 blocks of 29x23 pixels\n", + "Writing ./S1_VV/outcore.tif...: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:31 (INFO) MultitempFilteringFilter: Default RAM limit for OTB is 256 MB\n", + "2022-08-08 14:38:31 (INFO) MultitempFilteringFilter: GDAL maximum cache size is 781 MB\n", + "2022-08-08 14:38:31 (INFO) MultitempFilteringFilter: OTB will use at most 8 threads\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.012722MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200219_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200219_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200225_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200225_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200302_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200302_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200308_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200308_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200314_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200314_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200320_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200320_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200326_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200326_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200401_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200401_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200407_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200407_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200413_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200413_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200419_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200419_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200425_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200425_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200501_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200501_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200507_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200507_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200513_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200513_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200519_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200519_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200525_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200525_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200531_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200531_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200606_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200606_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200612_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200612_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200618_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200618_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200624_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200624_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200630_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200630_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200706_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200706_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200712_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200712_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200718_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200718_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200724_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200724_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200730_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200730_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200805_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200805_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200811_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VV_filtered/S1_VV_20200811_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.00890541MB (avail.: 8 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/enl.tif will be written in 1 blocks of 29x23 pixels\n", + "Writing S1_VV_filtered/enl.tif...: 100% [**************************************************] (0s)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-08-08 14:38:32 (INFO) MultitempFilteringOutcore: Default RAM limit for OTB is 256 MB\n", + "2022-08-08 14:38:32 (INFO) MultitempFilteringOutcore: GDAL maximum cache size is 781 MB\n", + "2022-08-08 14:38:32 (INFO) MultitempFilteringOutcore: OTB will use at most 8 threads\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.376572MB (avail.: 8 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 14:38:32 (INFO): File ./S1_VH/outcore.tif will be written in 1 blocks of 29x23 pixels\n", + "Writing ./S1_VH/outcore.tif...: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO) MultitempFilteringFilter: Default RAM limit for OTB is 256 MB\n", + "2022-08-08 14:38:32 (INFO) MultitempFilteringFilter: GDAL maximum cache size is 781 MB\n", + "2022-08-08 14:38:32 (INFO) MultitempFilteringFilter: OTB will use at most 8 threads\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n", + "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.012722MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200219_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200219_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200225_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200225_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200302_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200302_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200308_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200308_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200314_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200314_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200320_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200320_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200326_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200326_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200401_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200401_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200407_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200407_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200413_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200413_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200419_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200419_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200425_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200425_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200501_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200501_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200507_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200507_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200513_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200513_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200519_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200519_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200525_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200525_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200531_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200531_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200606_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200606_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200612_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200612_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200618_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200618_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200624_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200624_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200630_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200630_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200706_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200706_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200712_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200712_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200718_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200718_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200724_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200724_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200730_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200730_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200805_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200805_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200811_filtered.tif will be written in 1 blocks of 29x23 pixels\n", + "S1_VH_filtered/S1_VH_20200811_filtered.tif: 100% [**************************************************] (0s)\n", + "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.00890541MB (avail.: 8 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/enl.tif will be written in 1 blocks of 29x23 pixels\n", + "Writing S1_VH_filtered/enl.tif...: 100% [**************************************************] (0s)\n" + ] + } + ], "source": [ - "#Can take around 30 seconds\n", - "mutlitemp = cmd_otb.MultitempSpeckleFiltering(otb_path = '/home/johann/Documents/OTB/OTB-8.0.1-Linux64/bin',\n", - " window = 3)\n", + "#Can take around 10 seconds\n", + "mutlitemp = cmd_otb.MultitempSpeckleFiltering(otb_path = '/home/johann/Documents/OTB-8.0.1-Linux64/bin',\n", + " window = 3)\n", "s1_eopatch = mutlitemp.execute(s1_eopatch)" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 89, "id": "f6844f37", "metadata": { "pycharm": { @@ -496,14 +836,15 @@ "VV = s1_eopatch.data['VV_filtered']\n", "RVI_smoothed = (4*VH)/(VH+VV)\n", "#Add the value smoothed to the EOPatch\n", - "s1_eopatch.add_feature(FeatureType.DATA, \"RVI_smoothed\", RVI_smoothed)\n", + "add_rvi_smoothed = AddFeatureTask((FeatureType.DATA, \"RVI_smoothed\"))\n", + "add_rvi_smoothed.execute(eopatch = s1_eopatch, data = RVI_smoothed)\n", "masking = preprocessing.MaskPixels([\"RVI_smoothed\"])\n", "s1_eopatch = masking.execute(s1_eopatch)" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 90, "id": "d10c479b", "metadata": { "pycharm": { @@ -513,7 +854,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -533,7 +874,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 91, "id": "226114f1", "metadata": { "pycharm": { @@ -543,7 +884,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -555,15 +896,17 @@ } ], "source": [ - "#LAI Time Series from masked field\n", + "#RVI smoothed Time Series from masked field\n", "variable = 'RVI_smoothed'\n", "\n", - "stats_df = preprocessing.get_time_series_profile(feature_array = s1_eopatch.data[variable],\n", - " crop_mask = s1_eopatch.mask_timeless['MASK'],\n", - " function=np.nanmedian)\n", + "curve_fit = preprocessing.CurveFitting(range_doy=(60, 300))\n", + "doy, _ = curve_fit._get_ids_period(s1_eopatch)\n", + "ts_mean = curve_fit.get_time_series_profile(s1_eopatch,feature=variable, feature_mask = 'MASK').flatten()\n", + "fitted = curve_fit.execute(s1_eopatch, feature=variable, feature_mask = 'MASK')\n", "\n", - "plt.plot(s1_eopatch.timestamp, stats_df)\n", - "plt.xticks(rotation=90)\n", + "plt.plot(doy, fitted, label='Double logistic')\n", + "plt.plot(doy, ts_mean, label='Original')\n", + "plt.legend(loc='upper left')\n", "plt.show()" ] }, @@ -571,16 +914,20 @@ "cell_type": "code", "execution_count": null, "id": "d62d985d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { - "display_name": "eo-crops", + "display_name": "eo_crops", "language": "python", - "name": "eo-crops" + "name": "eo_crops" }, "language_info": { "codemirror_mode": { @@ -597,4 +944,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb index 14613e7..84b7da5 100644 --- a/eo-crops/examples/VHRS data.ipynb +++ b/eo-crops/examples/VHRS data.ipynb @@ -64,23 +64,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 23, "id": "0b155914", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/johann/anaconda3/envs/eo-crops/lib/python3.7/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - } - ], + "outputs": [], "source": [ "import warnings\n", "warnings.filterwarnings(\"ignore\")\n", @@ -97,7 +88,12 @@ "from eocrops.input import utils_sh as utils_sh\n", "from eocrops.input import sentinel2 as sentinel2\n", "from eocrops.input import vhrs as vhrs\n", - "from eocrops.tasks import preprocessing as preprocessing" + "from eocrops.tasks import preprocessing as preprocessing\n", + "from eocrops.tasks import vegetation_indices\n", + "from eolearn.io import ExportToTiffTask\n", + "from eolearn.core import FeatureType\n", + "vhrs = reload(vhrs)\n", + "vegetation_indices = reload(vegetation_indices)" ] }, { @@ -114,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "1a695f40", "metadata": { "pycharm": { @@ -139,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "e17bf6ed", "metadata": { "pycharm": { @@ -148,11 +144,11 @@ }, "outputs": [], "source": [ - "api =''\n", - "client_id =''\n", - "client_secret =''\n", + "api = ''\n", + "client_id = ''\n", + "client_secret = ''\n", "config = utils_sh.config_sentinelhub_cred(api, client_id, client_secret)\n", - "#Provide here your planet API key \n", + "# Provide here your planet API key\n", "config.planet_key = ''" ] }, @@ -170,7 +166,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "294361fe", "metadata": { "pycharm": { @@ -187,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "1f12b506", "metadata": { "pycharm": { @@ -198,13 +194,12 @@ "source": [ "patch = sentinel2.workflow_instructions_S2L2A(**kwargs,\n", " coverage_predicate=0.5,\n", - " interpolation={'interpolate' : True,\n", - " 'period_length' : 8}) # you can add period_length in the dictionary to resample\n" + " interpolation={'interpolate' : True}) # you can add period_length in the dictionary to resample pixel wise\n" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "5034136f", "metadata": { "pycharm": { @@ -235,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "b0584e33", "metadata": { "pycharm": { @@ -251,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "6c812721", "metadata": { "pycharm": { @@ -282,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 53, "id": "b869cbb1", "metadata": { "pycharm": { @@ -292,7 +287,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -304,21 +299,52 @@ } ], "source": [ - "#LAI Time Series from masked field\n", + "#NDVI Time Series from masked field\n", "variable = 'NDVI'\n", + "#Subset the time series between doy 30 and 260 => useful for double logistic smoothing\n", + "curve_fit = preprocessing.CurveFitting(range_doy=(30, 260))\n", + "doy, _ = curve_fit.get_doy_period(patch)\n", "\n", - "stats_df = preprocessing.get_time_series_profile(feature_array = patch.data[variable],\n", - " crop_mask = patch.mask_timeless['MASK'],\n", - " function=np.nanmedian)\n", + "ts_mean = curve_fit.get_time_series_profile(patch,feature=variable, feature_mask = 'MASK').flatten()\n", + "fitted = curve_fit.execute(patch, feature=variable, feature_mask = 'MASK')\n", "\n", - "plt.plot(patch.timestamp, stats_df)\n", - "plt.xticks(rotation=90)\n", + "plt.plot(doy, fitted, label='Double logistic')\n", + "plt.plot(doy, ts_mean, label='Original')\n", + "plt.legend(loc='upper left')\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 54, + "id": "964d4703", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.37726922, 0.3147344 , 5.91591333, 0.20032278, 1. ])" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Parameters from doubly logistic \n", + "#α1 is seasonal minimum greenness\n", + "#α2 is the seasonal amplitude\n", + "#α3 controls the green-up rate\n", + "#α4 is the green-up inflection point\n", + "#α5 controls the mid-growing season greenness trajectory.\n", + "\n", + "curve_fit.params[2:]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, "id": "926583fd", "metadata": { "pycharm": { @@ -329,23 +355,23 @@ { "data": { "text/plain": [ - "datetime.datetime(2020, 5, 15, 0, 0)" + "datetime.datetime(2020, 5, 26, 11, 17, 45)" ] }, - "execution_count": 12, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Peak of the season is at 15/05 \n", - "time_max_index = np.nanargmax(stats_df)\n", - "patch.timestamp[np.nanargmax(stats_df)]" + "time_max_index = np.nanargmax(fitted)\n", + "patch.timestamp[time_max_index]" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "8f80db4e", "metadata": { "pycharm": { @@ -355,11 +381,10 @@ "outputs": [], "source": [ "#If oyu would like to save the data in .tif format (e.g. NDVI on the first date)\n", - "from eolearn.io.local_io import ExportToTiffTask\n", "index_time = 0\n", "date = str(patch.timestamp[index_time]).split(' ')[0]\n", "\n", - "export = ExportToTiffTask(feature='NDVI',\n", + "export = ExportToTiffTask(feature=(FeatureType.DATA, 'NDVI'),\n", " folder=os.path.join('your_path_'+ date),\n", " band_indices=[0],\n", " date_indices=[index_time])\n", @@ -380,7 +405,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 57, "id": "04ac76a8", "metadata": { "pycharm": { @@ -430,7 +455,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 58, "id": "4cb2e048", "metadata": { "pycharm": { @@ -445,14 +470,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "id": "f8246811", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"c7d9ea4c-c797-40d4-9566-586774d82016\",\"exp\":1659969220,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"9d2e0eda-1a03-4aee-9887-c728a31947f3\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n", + "353e6fee-76d2-40e9-82d8-da90b13f9c13\n", + "1.4870982763449545\n", + "CREATED\n" + ] + } + ], "source": [ "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", "order_id, results = download_workflow.execute_query(provider_planet, name_query='Example Planet')" @@ -460,14 +496,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "id": "8c19d2aa", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "24" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "#You can access to all the meta data in results.\n", "len(results['features'])" @@ -475,14 +522,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "id": "f435d2ad", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RUNNING\n" + ] + } + ], "source": [ "#Check the status of the order. Image will not be available \n", "collection_id = download_workflow.confirm_order(order_id)" @@ -490,22 +545,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "id": "0bac7cab", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"c385bb4c-343a-4069-ae91-5ebba7dd84b4\",\"exp\":1659969261,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"87f697e7-2e19-4479-98e1-850b7a8a9ada\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n" + ] + }, + { + "data": { + "text/plain": [ + "'RUNNING'" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", + "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. \n", + "#The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", "download_workflow.check_status(order_id)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 25, "id": "52ab8a3f", "metadata": { "pycharm": { @@ -516,7 +590,6 @@ "source": [ "#order_id = '2f900fad-1f5e-4a46-b6da-327012d400e1'\n", "#collection_id = '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'\n", - "\n", "eopatch_planet = download_workflow.get_data(order_id = order_id,\n", " collection_id = collection_id,\n", " provider = provider_planet,\n", @@ -525,7 +598,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 26, "id": "b31542be", "metadata": { "pycharm": { @@ -540,7 +613,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 27, "id": "6d9f1d04", "metadata": { "pycharm": { @@ -570,7 +643,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 55, "id": "f8b3d85d", "metadata": { "pycharm": { @@ -580,7 +653,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -592,21 +665,52 @@ } ], "source": [ - "#LAI Time Series from masked field\n", + "#NDVI Time Series from masked field\n", "variable = 'NDVI'\n", "\n", - "stats_df = preprocessing.get_time_series_profile(feature_array = eopatch_planet.data[variable],\n", - " crop_mask = eopatch_planet.mask_timeless['MASK'],\n", - " function=np.nanmedian)\n", + "curve_fit = preprocessing.CurveFitting(range_doy=(30, 260))\n", + "doy, _ = curve_fit.get_doy_period(eopatch_planet)\n", + "\n", + "ts_mean = curve_fit.get_time_series_profile(eopatch_planet, feature=variable, feature_mask = 'MASK').flatten()\n", + "fitted = curve_fit.execute(eopatch_planet, feature=variable, feature_mask = 'MASK')\n", "\n", - "plt.plot(eopatch_planet.timestamp, stats_df)\n", - "plt.xticks(rotation=90)\n", + "plt.plot(doy, fitted, label='Double logistic')\n", + "plt.plot(doy, ts_mean, label='Original')\n", + "plt.legend(loc='upper left')\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 56, + "id": "a0df6d21", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.53688983, 0.26130331, 63.01277785, 0.17811609, 63.46261595])" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Parameters from doubly logistic \n", + "#α1 is seasonal minimum greenness\n", + "#α2 is the seasonal amplitude\n", + "#α3 controls the green-up rate\n", + "#α4 is the green-up inflection point\n", + "#α5 controls the mid-growing season greenness trajectory.\n", + "\n", + "curve_fit.params[2:]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, "id": "7e381fb0", "metadata": { "pycharm": { @@ -616,7 +720,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -628,7 +732,7 @@ } ], "source": [ - "time_peak = np.nanargmax(stats_df)\n", + "time_peak = np.nanargmax(fitted)\n", "plt.figure(figsize=(5, 5))\n", "plt.imshow(eopatch_planet.data['NDVI'][time_peak,].astype(float))\n", "plt.colorbar()\n", @@ -662,11 +766,10 @@ "outputs": [], "source": [ "#If you would like to save the data in .tif format (e.g. NDVI on the first date)\n", - "from eolearn.io.local_io import ExportToTiffTask\n", "index_time = 0\n", "date = str(eopatch_planet.timestamp[index_time]).split(' ')[0]\n", "\n", - "export = ExportToTiffTask(feature='NDVI',\n", + "export = ExportToTiffTask(feature=(FeatureType.DATA, 'NDVI'),\n", " folder=os.path.join('your_path_'+ date),\n", " band_indices=[0],\n", " date_indices=[index_time])\n", @@ -687,7 +790,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 33, "id": "434d6383", "metadata": { "pycharm": { @@ -763,28 +866,63 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 36, "id": "1dfea2e7", "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-08-08 15:21:37 (INFO) Pansharpening: Default RAM limit for OTB is 256 MB\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: GDAL maximum cache size is 781 MB\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: OTB will use at most 8 threads\n", + "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n", + "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: Lmvm algorithm\n", + "2022-08-08 15:21:37 (INFO): Estimated memory for full processing: 1.38769MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 15:21:37 (INFO): File ./tempo/Pansharpened_20200415.tif will be written in 1 blocks of 191x151 pixels\n", + "Writing ./tempo/Pansharpened_20200415.tif...: 100% [**************************************************] (0s)\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: Default RAM limit for OTB is 256 MB\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: GDAL maximum cache size is 781 MB\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: OTB will use at most 8 threads\n", + "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n", + "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: Lmvm algorithm\n", + "2022-08-08 15:21:37 (INFO): Estimated memory for full processing: 1.38769MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 15:21:37 (INFO): File ./tempo/Pansharpened_20200518.tif will be written in 1 blocks of 191x151 pixels\n", + "Writing ./tempo/Pansharpened_20200518.tif...: 100% [**************************************************] (0s)\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: Default RAM limit for OTB is 256 MB\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: GDAL maximum cache size is 781 MB\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: OTB will use at most 8 threads\n", + "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n", + "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n", + "2022-08-08 15:21:37 (INFO) Pansharpening: Lmvm algorithm\n", + "2022-08-08 15:21:37 (INFO): Estimated memory for full processing: 1.38769MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 15:21:37 (INFO): File ./tempo/Pansharpened_20200606.tif will be written in 1 blocks of 191x151 pixels\n", + "Writing ./tempo/Pansharpened_20200606.tif...: 100% [**************************************************] (0s)\n" + ] + } + ], "source": [ "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", + "\n", "#order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'\n", "eopatch_spot = download_workflow.get_data(order_id = order_id_spot,\n", " collection_id = collection_id_spot,\n", " provider = provider_spot,\n", " resolution = 1.5,\n", - " pansharpen = True,\n", - " otb_path='/home/johann/Documents/OTB/OTB-8.0.1-Linux64/bin')" + " pansharpen = True, #put false if you do not to apply OTB command\n", + " otb_path='/home/johann/Documents/OTB-8.0.1-Linux64/bin')" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 37, "id": "9e45f60b", "metadata": { "pycharm": { @@ -800,19 +938,7 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "7aa3df4d", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 25, + "execution_count": 38, "id": "8cc20fe3", "metadata": { "pycharm": { @@ -822,7 +948,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -842,7 +968,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 44, "id": "b81bdd5e", "metadata": { "pycharm": { @@ -852,7 +978,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -871,20 +997,6 @@ "plt.show()" ] }, - { - "cell_type": "markdown", - "id": "bf7b7c24", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "If you would like to save the EOPatch, you can \n", - "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n", - " - save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask" - ] - }, { "cell_type": "markdown", "id": "ed05b200", @@ -911,7 +1023,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 45, "id": "3404967b", "metadata": { "pycharm": { @@ -940,18 +1052,6 @@ "**collection_id_pleaides** = '9eb3a890-7984-46bb-970d-db30ad5a4209'" ] }, - { - "cell_type": "markdown", - "id": "0620dc8e", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "collection_id_spot" - ] - }, { "cell_type": "code", "execution_count": null, @@ -993,57 +1093,13 @@ "outputs": [], "source": [ "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", - "download_workflow.check_status( order_id_pleiades)\n" + "download_workflow.check_status(order_id_pleiades)\n" ] }, { "cell_type": "code", - "execution_count": 28, - "id": "e2669eff", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", - "#order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'\n", - "eopatch_pleaides = download_workflow.get_data(order_id = order_id_pleiades,\n", - " collection_id = collection_id_pleaides,\n", - " provider = provider_pleaides,\n", - " resolution = 0.5,\n", - " pansharpen = False, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", - " otb_path='/home/s999379/git-repo/OTB-7.4.0-Linux64/bin')" - ] - }, - { - "cell_type": "markdown", - "id": "fb00803e", - "metadata": {}, - "source": [ - "collection_id_spot" - ] - }, - { - "cell_type": "code", - "execution_count": 174, - "id": "5d0cd2ed", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n", - "order_id_pleiades, results_pleiades = download_workflow.execute_query(provider_pleaides, name_query='example pleaides')" - ] - }, - { - "cell_type": "code", - "execution_count": 154, - "id": "21ac816e", + "execution_count": 155, + "id": "a6495500", "metadata": { "pycharm": { "name": "#%%\n" @@ -1054,21 +1110,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"dbf7ea0f-6f74-4e6d-ae03-1b5455a6034c\",\"exp\":1643715904,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"b49cfd00-51a0-45f9-91a3-6707bf5fe210\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n", - "e7f5c398-0d23-4f9d-a6a8-03b2b0632554\n", - "0.25\n", - "CREATED\n" + "RUNNING\n" ] } ], "source": [ - "collection_id_pleaides = download_workflow.confirm_order(order_id_pleiades)" + "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", + "download_workflow.check_status(order_id_pleiades)\n" ] }, { "cell_type": "code", - "execution_count": 155, - "id": "a6495500", + "execution_count": 48, + "id": "5faa08bc", "metadata": { "pycharm": { "name": "#%%\n" @@ -1079,25 +1133,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "RUNNING\n" + "2022-08-08 15:23:34 (INFO) Pansharpening: Default RAM limit for OTB is 256 MB\n", + "2022-08-08 15:23:34 (INFO) Pansharpening: GDAL maximum cache size is 781 MB\n", + "2022-08-08 15:23:34 (INFO) Pansharpening: OTB will use at most 8 threads\n", + "2022-08-08 15:23:34 (INFO): Loading metadata from official product\n", + "2022-08-08 15:23:34 (INFO): Loading metadata from official product\n", + "2022-08-08 15:23:34 (INFO) Pansharpening: Lmvm algorithm\n", + "2022-08-08 15:23:34 (INFO): Estimated memory for full processing: 13.6552MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n", + "2022-08-08 15:23:34 (INFO): File ./tempo/Pansharpened_20200606.tif will be written in 1 blocks of 572x452 pixels\n", + "Writing ./tempo/Pansharpened_20200606.tif...: 100% [**************************************************] (0s)\n" ] } ], - "source": [ - "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n", - "download_workflow.check_status( order_id_pleiades)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "5faa08bc", - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], "source": [ "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", "#order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'\n", @@ -1106,12 +1153,12 @@ " provider = provider_pleaides,\n", " resolution = 0.5,\n", " pansharpen = True, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n", - " otb_path = '/home/johann/Documents/OTB/OTB-8.0.1-Linux64/bin')" + " otb_path = '/home/johann/Documents/OTB-8.0.1-Linux64/bin')" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 49, "id": "321b7737", "metadata": { "pycharm": { @@ -1125,7 +1172,7 @@ "[datetime.datetime(2020, 6, 6, 11, 21, 32, 600000)]" ] }, - "execution_count": 34, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -1136,7 +1183,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 50, "id": "b7f8592e", "metadata": { "pycharm": { @@ -1146,7 +1193,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1166,7 +1213,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 51, "id": "c1bd9e6e", "metadata": { "pycharm": { @@ -1183,7 +1230,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1204,7 +1251,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 52, "id": "56e6faf1", "metadata": { "pycharm": { @@ -1214,7 +1261,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1232,27 +1279,13 @@ "plt.axis(False);\n", "plt.show()" ] - }, - { - "cell_type": "markdown", - "id": "ac81a1f7", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "If you would like to save the EOPatch, you can \n", - "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n", - "- save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask" - ] } ], "metadata": { "kernelspec": { - "display_name": "eo-crops", + "display_name": "eo_crops", "language": "python", - "name": "eo-crops" + "name": "eo_crops" }, "language_info": { "codemirror_mode": { @@ -1269,4 +1302,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/eo-crops/examples/data_loading.py b/eo-crops/examples/data_loading.py index da552be..9e49914 100644 --- a/eo-crops/examples/data_loading.py +++ b/eo-crops/examples/data_loading.py @@ -3,44 +3,53 @@ import numpy as np import os from eocrops.utils import data_loader +import matplotlib.pyplot as plt ################################################################################# -root_dir_or_list = '/home/johann/Documents/EOPatch samples' +#Aggregate all the EOPatch saved into a root directory into a single 3D np.array, where each observation is an aggregated multiviariate time series +#The objective is to get a dataset for machine learning project (e.g. yield prediction) where we work at the object level (e.g. averaged time series) -dict_df = pd.DataFrame( - dict( - labels = [0], - path = [os.path.join(root_dir_or_list, '726B-JC7987WJFX6011GR-2021_S2_L2A')] - ) -) - -features_data = [(FeatureType.DATA, 'BANDS-S2-L2A', 'BANDS-S2-L2A', 'float32', 10), - (FeatureType.DATA, 'NDVI', 'NDVI', 'float32', 1), - (FeatureType.DATA, 'NDWI', 'NDWI', 'float32', 1), - (FeatureType.DATA, 'GNDVI', 'GNDVI', 'float32', 1), - (FeatureType.DATA, 'LAI', 'LAI', 'float32', 1), - (FeatureType.DATA, 'fapar', 'fapar', 'float32', 1), - (FeatureType.DATA, 'Cab', 'Cab', 'float32', 1)] - -feature_vector = [ - ('labels', 'float32'), - ('path', 'string') -] +root_dir = '/home/johann/Documents/EOPatch samples' +os.listdir(root_dir) -kwargs_S2 = dict(name_file='X_S2', - suffix='S2', - features_data=features_data) +#Features of EOPatch to load in the final dataset +features_data = [ + (FeatureType.DATA, 'LAI', 'LAI', 'float32', 1), + (FeatureType.DATA, 'fapar', 'fapar', 'float32', 1), + (FeatureType.DATA, 'Cab', 'Cab', 'float32', 1)] +#Read EOPatch into a 3D np.array, where each observation is the median time series of the field +#self = pipeline_eopatch_tfds pipeline_eopatch_tfds = data_loader.EOPatchDataset( - root_dir_or_list, features_data, - suffix='S2_L2A', - resampling = None, - function=np.nanmedian + root_dir = root_dir, #root directory where EOPatch are saved + features_data=features_data, #features to read in EOPatch + suffix='_S2_L2A', #suffix for eopatch file names to filter out only one data source (e.g. S2_L2A). Put '' if you want to read all the files in root_dir + resampling = dict(start = '-01-01', end = '-12-31', day_periods = 8), #resample eopatch into 8 days period + range_doy=(100,300), #subset in term of doy to apply doubly logistic only on a subset period of the year + function=np.nanmedian #get average time series from the field ) +#Get the 3D array dataset with 'cubic' interpolation over the resampling period +npy_eopatch = pipeline_eopatch_tfds.get_eopatch_tfds(algorithm='cubic', doubly_logistic=False) +npy_eopatch.shape +#Plot Cab +plt.plot(npy_eopatch[0,20:40,1]) +plt.show() -npy_eopatch = pipeline_eopatch_tfds.get_eopatch_tfds(algorithm='linear') +#Create an example of vector dataset with auxilliary data. It must have a column 'path' to match with the corresponding EOPatch +dict_df = pd.DataFrame( + dict( + biomass = [np.random.normal(1) for k in range(len(os.listdir(root_dir)))], + path = [os.path.join(root_dir, k) for k in os.listdir(root_dir)] + ) +) +#Features from vector file which contains auxilliary data (e.g. labels for crop classification) +feature_vector = [ + ('biomass', 'float32'), + ('path', 'string') +] +#Get corresponding labels from the vector file dict_df npy_labels = pipeline_eopatch_tfds.get_vector_tfds(vector_data=dict_df, features_list=feature_vector, column_path='path') diff --git a/eo-crops/examples/dev_test/curve_fitting.py b/eo-crops/examples/dev_test/curve_fitting.py new file mode 100644 index 0000000..dfd1d14 --- /dev/null +++ b/eo-crops/examples/dev_test/curve_fitting.py @@ -0,0 +1,44 @@ +from eolearn.core import EOPatch +import numpy as np +from eocrops.tasks import preprocessing +import matplotlib.pyplot as plt +import os +from scipy import interpolate + +list_files = os.listdir('/home/johann/Documents/EOPatch samples') +f = list_files[1] +eopatch = EOPatch.load('/home/johann/Documents/EOPatch samples/' + f) + +curve_fit = preprocessing.CurveFitting(range_doy=(100, 365)) +ts_mean = curve_fit.get_time_series_profile(eopatch,feature='LAI').flatten() +fitted = curve_fit.execute(eopatch, feature='LAI') +doy, _ = curve_fit.get_doy_period(eopatch) +plt.plot(doy, fitted) +plt.plot(doy, ts_mean) +plt.show() + + +flinear = interpolate.interp1d(doy, ts_mean, kind='cubic') +flinear_fitted = interpolate.interp1d(doy, fitted, kind='cubic') +flinear_cspline = interpolate.Akima1DInterpolator(doy, fitted) + +xnew = np.arange(0, 365, 8) +len(xnew) +s = np.where(xnew>=doy[0])[0][0] +e = np.where(xnew<=doy[-1])[0][-1] + +ylinear_ts = flinear(xnew[s:e]) +ylinear_fitted = flinear_fitted(xnew[s:e]) +ylinear_cspline = flinear_cspline(xnew[s:e]) + +plt.plot(ylinear_ts) +plt.plot(ylinear_fitted) +plt.plot(ylinear_cspline) +plt.show() + +before_season = np.repeat(ylinear_cspline[0], xnew[:s].shape[0]) +after_season = np.repeat(ylinear_cspline[-1], xnew[e:].shape[0]) +output = np.concatenate([before_season, ylinear_cspline, after_season],axis = 0) + +plt.plot(xnew, output) +plt.show() \ No newline at end of file diff --git a/eo-crops/examples/dev_test/data_download.py b/eo-crops/examples/dev_test/data_download.py new file mode 100644 index 0000000..f368373 --- /dev/null +++ b/eo-crops/examples/dev_test/data_download.py @@ -0,0 +1,87 @@ + +import warnings + +warnings.filterwarnings("ignore") + +import geopandas as gpd +from scipy.signal import savgol_filter + +import os +import numpy as np +import matplotlib.pyplot as plt +from eolearn.core import FeatureType + +from eocrops.input import utils_sh as utils_sh +from eocrops.input import sentinel1 as sentinel1 +from eocrops.input import sentinel2 as sentinel2 +from eocrops.tasks import cmd_otb as cmd_otb +from eocrops.tasks import preprocessing as preprocessing + +dir_path = os.path.dirname(os.getcwd()) +print(dir_path) +# read microplot data +shapefile_input = gpd.read_file(os.path.join(dir_path, 'eo-crops/examples/layers/POLYGON.shp')) + +api = '' +client_id = '' +client_secret = '' +config = utils_sh.config_sentinelhub_cred(api, client_id, client_secret) +# Provide here your planet API key +config.planet_key = '' + +# %% + +time_period = ('2020-02-15', '2020-08-15') +kwargs = dict(polygon=shapefile_input, + time_stamp=time_period, + config=config) + + + +os.getcwd() +warnings.filterwarnings("ignore") +patch = sentinel2.workflow_instructions_S2L2A(**kwargs, + path_out='/home/johann/Documents/patch', # you can specify here a path to save the EOPatch object + coverage_predicate=0.5, + interpolation={'interpolate': True, 'period_length' : 8}) + + + +s1_eopatch = sentinel1.workflow_instructions_S1IW(**kwargs, + speckle_lee_window = 3, + orbit_direction = 'ASC', + backCoeff = 'SIGMA0_ELLIPSOID' ) + +#%% + +#Compute Radar Vegetation Index +VV = s1_eopatch.data['BANDS-S1-IW'][...,0] +VH = s1_eopatch.data['BANDS-S1-IW'][...,1] +RVI = (4*VH)/(VH+VV) + + +#%% +from eolearn.core import AddFeatureTask +#Add the feature to the EOPatch +add_rvi = AddFeatureTask((FeatureType.DATA, "RVI")) +add_rvi.execute(eopatch = s1_eopatch, data = RVI[..., np.newaxis]) +masking = preprocessing.MaskPixels([ "RVI"]) +s1_eopatch = masking.execute(s1_eopatch) + +#%% + +#Display RVI from SIGMA0 without any speckle filtering +s1_eopatch = masking.execute(s1_eopatch) +plt.figure(figsize=(5, 5)) +plt.imshow(s1_eopatch.data['RVI'][15,].squeeze()); +plt.axis(False); +plt.show() + + +#%% + +#Can take around 30 seconds +mutlitemp = cmd_otb.MultitempSpeckleFiltering(otb_path = '/home/johann/Documents/OTB/OTB-8.0.1-Linux64/bin', + window = 3) +self = mutlitemp +s1_eopatch = mutlitemp.execute(s1_eopatch) diff --git a/eo-crops/examples/weather_data.py b/eo-crops/examples/weather_data.py index 3966489..2fb418b 100644 --- a/eo-crops/examples/weather_data.py +++ b/eo-crops/examples/weather_data.py @@ -1,6 +1,6 @@ import pandas as pd -from eocrops.input.meteoblue import CEHUBExtraction, CEHubFormatting +from eocrops.input.meteoblue import WeatherDownload, WeatherPostprocess ############################################################################################################### #Read the file @@ -11,7 +11,6 @@ input_file['Id_location'] = input_file['Id_location'].astype(str) input_file = input_file[input_file['Aggregation'].isin(['mean'])] -input_file[['Id_location', 'Annee']].drop_duplicates().shape ############################################################################################################### #Step 1 : Define the query with a backbone (=units, jobs parameters) and your input file features (locations,..) @@ -38,7 +37,7 @@ } -pipeline_cehub = CEHUBExtraction(api_key = '', +pipeline_cehub = WeatherDownload(api_key ='', queryBackbone = queryBackbone, ids = input_file['Id_location'].values, coordinates= input_file['coordinates'].values, @@ -71,7 +70,7 @@ df_output = pd.read_csv('./examples/layers/mean_meteoblue.csv', skiprows=1) -pipeline_refactor = CEHubFormatting( +pipeline_refactor = WeatherPostprocess( input_file = input_file, id_column = 'Id_location', year_column = 'Annee', diff --git a/eo-crops/requirements.txt b/eo-crops/requirements.txt index c536efa..df64e00 100644 --- a/eo-crops/requirements.txt +++ b/eo-crops/requirements.txt @@ -8,3 +8,4 @@ scipy>=0.19 matplotlib>=2.2.2 seaborn>=0.9.0 protobuf==3.20.0 +fs==2.4.14

Z^@Pd>r87ea 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 b^M?!%c8q#dHP|-*^xKVVCRfWZBcuKY2f{R# diff --git a/eo-flow/figures/rfcn-architecture.png b/eo-flow/figures/rfcn-architecture.png deleted file mode 100644 index eac47bded1388eade97b1f97b5d57a45fc979fca..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 172044 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%0DH0g8QJG$>HHYF>2W9p{;O1SREOQ$?- zZznw{aubH$Ko@eXTEO?Y%+T)jLI(_IB+@Ok;jfuNU7jwtVfS-n`pO&LA z6^rymI}i>Ts1T`nbESuNSp!(EK})ni@YmR<^1LEN=u3bCwkKvF;Wm}Pty@}(0;xp{ z5#{10%cDE-Oo8l!x-aH=zy&j&MBg?T`>H@MqP)G279P~f%$@1d`g!8|N2<1co<9~@ zO53T(?MdL;l)_$Tm?oR{2ZRp8fA*ndRLj@&I=PT*7=9T%=xEV?mss8~k{QhIOiLPA8uj4$ zX|ZpK+;lr31b4YtK9x>hYRYQU3kK_9X+<>fX5!(6Q?!PVYE6~ueEe* zoQ)c3gf}tjLaOEHO5s2pUbVeMD;X7Wa{a-tibEO^6Fuq{j$sxgtp@8ewYd6)?PWL{ zc=RP`N{ZJOdGZ*T=sthH1m$f*dBJ5angZ(q9&|lRZisNx1*7JjVA*)nzI$6OM}Ek7 z)Bc}%F7#CfHrd|Y4cRSItU4yFR8mwhui?-Fw$0$-{wUf)hN;j}yTSu}b|h9G1yaf0 zae>gd0RyOxhzKdGp^eGkhK3)N3;c5!Fh@XbA}>v{*Z!n#ZNKNHq5g3a?CtF}*j>H_ zjvmI+1!_f2vfre3lmUyV#q6?@|ye7)Tz zt!KAj2J4hP{s~?PDy}N4NmrcPOHXOIhZDGu)i1@Im%%I&zdKGz73U#-)(a)gRw{$71#-pNLd=}bzS6F-7Llx3JZLdBg3XW2Ly*U9%_{UT~OC)d|qUnLpS)C z35)~DOM;%5igoqMYUXjRAP}1|kR-j6)31fBuFF|M$KJn}E2y?bBhp_;1p{4aa|1qs z5?YP<0YkzOn_$<}WVfR3Oo)fD0@SUF%+7adP%iS*X5gD7+5Yj$vW~ zS2Hbr)gd6;)=D&X5iw|g=k~?8^?@j(EOpP}>*at+=<~k!lkW_Pm{LtH=jAyrL9qRs z;4og&o4=gsH{{%M@xqO$gSK6ywO@zkH$DM6J2)j|$;2f88KTdfjBY3Wvz)v(=@T({XR9yJ-EJcZ?v(e|fU zqAme56`kAP%X>DJj5K%6rQH3+Q2~Rmer2mYtHD%5<(EznVmvfFb&-947ZJK@5yCK) zq~Y_BSW;Bt#lU#8ZEqP}_nG}{){*p;;05e%|uGu|Ls{~gQlU?TEGY@ z_PEdstk6H-adL+Q!wvg(8cEOsjW#NSF{@=3Hh4bpa|C>eT12kkq=5i+c^(oZ4Vhs? zW?{-Sdifzte;v%xfS`}ZuVZo;2ASh<%0WnUSKUc z_CTA$fkmD$is?|nF)lkjt1$kt*d9KVbLVdC>w-+%Pfdc9)0o_FHh)HVemi%!cE_6? zV^@zSz)>7sYUNmWMt)_gx!PT{@qz=GH2EoaTDe)B1hF$eLX0-pC~GBBNFg1T`dq9z z-VHwqaW+2TXwWe?b9Lsk9QCtS8u+O587RzWqEQ5*J`Wbvn-C#wNCtN-}nOw;wtAvU++%dKkzF5!ldI z!D;6mEo_PSh@^e8dVbIFkUmFLTx|Y9(H(ABLYNc~3kn-_`LLsn+@+D$=foTun*Yc$ z?W|*H4Y!P2>R@%lo{n-slb`OryZkTk7!G5K!xUea(|m+Y zbJHy#=oUhWNHNogg)x&4hiIKs_=3>6!*-}|bYzgl?(@~9?>_I~l*_l<`elmJtv z5MVMZ-^w@L3L-@lRaL?#(zn5$3iNLlG~;x-t7k()y<{zZH{Run_TF<(5x%@Au2ajk z*(^+X_)3fvgP_s?P0-jFI@fa@l>gg8Fxzfv^JAQ?)MCw+a^D}m>hWLr5KKSM^P7nU zW6xQu=BAgSc`=LxJrH*T*yl0Z?MIGj2xtRwCCuk@vL>Sney#^$VdOH)?E&{NRV4P@ zUR@PWFlx$59`7`)2+>OX#^^G3(9EAf>Lp;L+{s2V6IY`ya5v4IemlHv=dG6OGc<-C zA-N9XYIiA$jVekKa^3!Wd}@O60;59NM{lwweyWs=JHjnWEkwRkL( zXx94Ds~~xEe4zjpkNN$kK%aBxU|2Hg`)gW=DF3MIcS>g%Jm))`*~i=Rq#A8}-nEl0 zWBSdp+lyLoJ@e`KAh9Bp6XL?-m-X9!6|1-VZv81f;ehSeCR)O9>;C}VKq9~1xx8fj zq#GhuXg~P#glA&T;q_WsHg(qh^OoNbbB^jCHV7e@cFj$AXHPwj)|?vF_V-=8FnQM4 zF;4;*SpI*O*uESw=kmHwOijIG?p4<=E*LxRyd-aRjGH}=n|jIR*H|5nE2CUh3~)~G zLt$9F(0X5)spaS1ED=@t4rErhqswN1z1;(6eJ2hTCnGVN;EkeMY_Yon`(;@G0|O9- z;?o8Ojh_BbZ*@lpo2hU~o@oOPXW9_vDT zq8X>gS|Di}ghRzCFxJFDN}?cI1`J97QR0#Iv;aeuT6fJNBiftdVZA;L+#OkHc&!+a z`?gDpr#St92#II0V@f6fpxb7^(ZzN&5SngAH`01 z@J#m$d^?;tQHA>YQxJWAHJ2CEL3Bw`;FD!g(7=>_Nl`SejcSFcidx-Al~StN59pq+ znz?|+)e%C#b1D(YF$_3X3yuNLG2l5CJj<#?BhRVpTBzzvHV{0|sp?F9ons;JEDXH5 zuOM(R2t15D4}-wLAaF2hOZ~M`U}5B07JWN7(7O0ktcQj{3yV>J#VEjRi*2aELPsh%*@wZw?8Q0r4gy9A*Pzje@$3K?|dRc%y)LlYk_P z2}u?+;!Fm_8hFGSc-RFFF?twy#0WfM3h%|G0S1EsMuPzcgAsy30MGLP z2;3eoj-RN8EJt6I#B|toEaYi`K`o;V1xtvMoP#!Z@49#=Z~Hwbyo83{zAalFCn-8Wi) zUt`8kx^u}LcV8JT5Am`|Q!!)0c(i@7E+XY|wiqU6;*9%D={b`lQlJJ=^iNQ)^T!rP zvfNMK`RDFW-u~w^K946%jdpm~4ir?33#`vybQ!Yzok2gX0bnm355^QeXsLKTjo!}2 zhcJSqL4Jc_qQUFk_hMODM2}y`j*mX7+3@Z=Pq|%PVM+fEf3+R?z`{kKXmwTiwhBgWcEy|ZZ_?IvFw?s9`^vSPF}F+ zH?yx=mKo`SIi5%U;uZMYM>~hTk24_-_g{O-ipj-!S4Fx#Iz$nZlM=D-z_qw6T6GMD zg38KUmfZI3E2A;}zijFZ>-c#Ko-`Vb*%2>XgWw~RYg$bEUMPQdwEHinbn>)cUUk>~ zV=e^o2msh(<4|(>4fxZCTjBK&opUul#)e03xpLf;(t@7?h^WHYKr!VUUiTLi@xJKh z+mcJiPk91SAksrH6~I2=+}wvk@y7{SE1vMA{SR$7fc>!(^v!sj$V^0BhX->%K7!6z z6XM$3Fm(G-&4&-j>8_hCGR16z0P7&bfa^~)aEpMmt`n`q1QYSWccKc-n#N$WzYtIC zd=AYu*{Cm!f!`5Mx^~8yU}*NCWQGaJ|H~p~pA1pq(KQJW>ItYuhbR6YBZTK2kXsGl zPB9=|{mdAOq!bH?(2A|Cx2mEk6XNEWD>_pkwoay(g zW5?ZmCi^geO0@3Ty%%k*ZSaetnk zsv=W2``7bosY*{k6eajYv7eA2`Xz{>1W}S9^%JrrL6Kz0k_=gt;P;6TeSU~OKm0yF zd|p4iULSl~c)eb@J#O^$sL|cyhTE-1kK2tNw?~a0H@drf;OZScJ?PS+vqxQ5!wr|a zZ*+S+@cBiEk_1tbAc-<0Q3`}8N{}QO7TySl*@}3x4GCr&5-eI+?MSfLkzlpK#0y}+ zsGhhQQOxejsVY--ZletS+^QkU3jDI7zScsffJ6a_ z(qJeGWZfk|&6Wn1)q){l8GvV5$RO~^fKLMaGEqYz5VfUD8TGYH;g>=}2K*9*C=*DE znm|w1)V8W+g{HpMNLs2{dZ?kVhgfIGN{Gj9h>HSrHw0DjJCNl?&^|-fY%^p?`Z<-f z^DBywBoUJ6hba0X`h5^ZKm2|lygn~nE*EO*>Q!a?=%9d5`mYyDOW%K?ynM`PRSEzG zgJr?Qix=EFb>U?Z@y8r3*y9|y>4AsAbTp%D-}cd~m=Gk)x}?ySRrG5Bk?OMo3aoso ztZen)D=H#F3=f33BKw@_xc-)#(f-A{hzz6OJm0tMy%XkFxc${Qx;zK{lc;1qxwtqx_ci$oajN% z@yIw$*b2&=_R{gs0I)=)z#s}KC986B9$%T8`@@L!`@jGA``>R_`@wtqdQ)93ViOX< z8-ml|1fvlb&zug2XNVaZgdle86zIu!siIJCbK_5ZCr^&t7nqPj0IOasD_i+OadE+j z%j<>rUii~%8&|&lx}Jxk?$}YJ=M{hn@n&Q>9t-EqMY4P7nJRIW(*iaMR1$sO#@a`E znodR_`3@;$fK@AAEPHRo3z6>!9lw2T^=oge*%auH11IWGlA8`TL=nkzEHaW4aJaew z03gXS{;~Fp-~R30k3Nfdg9r)%vg*aMXWx6F_}Qo(cW;cpXx`7Ry7T^7(Yo&^q-CHp ztpcC#KRN7u7ET=-bLouArvVH-@BA!5fg*)s^}gkJ@4zyQT7Mg3VsfTkdd1^o#!rq~ zR^7$ly0dul!o|M<5VbFJ3KS7aSHD>PtN*-G`peN!bC9&Wf(I{I@vYgJ1yOzMjW~+N zO@xwFfq#5FyxB)H#ukyAE}OL|Gb!O)k#0-Kb^q@E;X?IG&#fmH=h3 z;bXKr+XycDkVolzJpO!$MS*?bFw|1N zyK(9)*7Wkbah1a+>={6{PdI$!7`oja5U50*Us987>3+9Vo8~T4RoNII2g40URiaVz z9pwmtW?KuQgeY(s1|S-tNC8<14XP51P-oQZKC@wDo<2QZRv^g=6q!PnX~^dxAt{h0 z3PqxzS|}2QENY>xE20)5+vyD?G6j+JC3F@P!2<{nA_G)bKqWO4S%xAjfuJ%4p%i{u zf=}|pC;8zC37_PLD2Wgyl^ld3_Zvi!!B7Q?EUDySXh?qeL_d6f5k5(TUn3sXkRi%4 zL|KAgmLO`O`UEQhvQp93Lqk&3ef^>o9+CvVB*Q03V0F7#Cb(o&z85S*!mSy4hwfWT zLaY&jroQSz^ITSR+XaP&8T;xU$cmy~8>;mJLM#}9LFJG#^mQ!)+lAOR$dUp@Qq*fk zyY@s;f!8O&*DL&f30|Lw_Kq%`Ivp8R*|0&#B0}k&7t70k_d;c5bR=BiaF$G+^8a0N z``sDQBzdBR;)zqR=<2J{_0^Z~w~StrSI!oL_}Q0UY)a3GXu>55T*fNO-WN(se-owi zUr{k*#`oqgzv2AM5-|i)GP7~*9d|>lIt+IN_?6*;;RPhjy?lx_ulVPPkTO)mVu0D3 zlk?bba&sSxsEQ%KwBqv1Zo2K3_!MWVh3ozAR? z6d1%}D$9FcEGzr06&a1V=h4UE*}ECCI|74@gupRv z{@l3nGk-kt!urMKl+wL9IgkH3Lf5&n;r)LySm`> zx)Ga@*k_}J)O1YBbi(KvTwuzW%&--ffhsb5EscM6pFI5DpgWv7mVmJPZhWci*&AQY zA9?1(zM!wI+Vaq*U5EE}cDv#Ai%53#?e2`^c(ix*pvU9G$_+c#KlX=L|0@b@32oLA z!qR;&mHq13SM&c6jpGg=y|8f6r8nJrV`5r*RPX!cb1%g^huYBG-ZiZ42_bms#>*?N zT`=`Gi2fAgB?^Om`<91+fT#`b z^u`-MH%(uCG562Rd(CJc%b_X3fwq|pl=U%)-|s`4!wk7gfW_^{*q7SjIuHlj-oDzD zEiDW>`~#;s-gwcMHQgV>k%`*1=a~&;IphC zUK#v{r=h%*0P)E*m=F4pWJ|-;FOMRv$_)Szs)JvP9S$?Tnv;swN)Dz&1WeD_ePtR6 zgDl4M_UpDW(}uG>0|2!(wK&yy8lofy{cb6O3CO6*oXHxQr6n|4o;C5rI4xfqO1~+y+T#D>g!7Q6ni~H8M3H^D0o96 zWPeGNA&2Z2Hho`P*UQuE3XNd9W%xxIUQy~5vKH#=9-ki_JzjM5c+nXW9o-(Zb-U5( za-+S+gHE>(ou2-q!|g+-+lMZXh%S!^mmXdbJw6d`zX-Qagxlwb+b6=~4-E-kzXXpK zZod?GUtbS~x{uc%JRYAY2SZZBFUyb=s*SDQKRvdcw4RBQOBK444p3SKKNJ zg-n(3P?WF)b1G3SYb3P{zam2n2}zNI0|dH?Tw78~14-(1Wp8Lp!W6wB5lE(|C=mT3 zI@&u?Ti0+_f6yZY4@$pBBhz(Yx(ksB_8SpE~}{YM_1l)&*b=&sEHz?jz!ns zf`Y6JG_QXjR2q6ZQ>0+cD>m9o#@)-C%@ZPAG*1Y5m`Ku*7t71vQ? zV2sIPjZl%JkEsh6Val}WXx+39QcuKYybcLNl9R+vn7K@FI7gn+I~+Vf9;TEW$;o;A zE+8W3J8|r+xlfOuJ1w~l2U?EyRUpJ&pz;M8t%!r*j`z}jC@q!36 zuRjO?zOP>AKm0cE^oaU>$44L4eERQyKeg}6jY?j{*a5ejed%JPx=t&@vJfy?I{odZ z9!7MM1qlEiG5CCkUn(uV^XUj(cYF74YX9Wzw;nyPZHts!S~1{uQ|8V`Qb&VGMgO4X znKJXhTkY*#4JV(9MEm-IKq(%jlJUrj7t8K=`ss)ch+)&-z3s1jxZ%-_UmcRh6=e^& z-ITI?eE7vz?ti|&`MUr{&vG@K` zEQr#JG*RhAia-(|A&>+}@9o-_`TenbmrHV&T*?JspM1WbyX?-+%+Ad2?LPCJ=Zi0Y zyI_?+YYaY~?s#U-)H{dwj(x<%)dQ6FHkpx@Gy@OORvu>-Bn%wV2m@h_8P; zhw>_Yqv<`|w0QP`$z2B}#w-V1MzCr?@r=og)TEi1=ZbO9aoot>!)}}Vze>E1o_3E< z_kqI}!*xWuEi?e01&{_{E?UK!~X8+u>lB4)xo!jV!*XDsEYvi zr`kia#s^t1_r=Zk6OsRUEX?WN_<-|6-%9%&b0sTc3sfrAGB_AC^$!33)>R)jnI_8QY=J71Rs>uu8x%mSF(JbCFVcX*~r6 zAu@?erJA5q5@eYL+ok&|C8(85d_h^7F9L*ENniQ*nLrQ~a?L`@ zRPq8Uc^*}~V6{rVW_yL1N14ein^7@SZ7VgJP---xO!+J|nowdeq14utV@vC9SFFrn zLYdKwa+4Vq#@be{Y%e$Q@-~xfkb1yg_PAJ^KMd-?iKA3WiX z>D>no{o4qxHwRibcRcX#XQ0!Ux0(l_Qy>I>gKmq|MaHd!YaYe|KS?Sonf5 z_skm6F}h6^I$9kJ%VOsIC(+(rgW|(`TZO!G7T!Jj`?+`S`XYeV_6!ANd4?||BcqZc zBA#tYe=~z8PJVyNBagRgFqOvO?&XbnPcB6Hi9aAULJ~Ox!m#ikHvSH;ZhczS%iRWn zgpjWyx^+9frdzjREy>6~EUfRSX?H*3ia>D=PrghrE0(Xrra7fRXM%!a}uQ+vRs9#$zacvLan}}|@(`&lD*_!9g3>ZK0y*nS8 z-)8rHFF${%6Gz~eQ!iI6@Es{cl8q?$qk;Z?#tYF%ezko|`oHvHk%ep{8jqdJEMErJV!`T+YyPkzN-;09FAw1+?yc$chLA?Kxe(>6@;VK?POr7`Fc^{PF>Y@(3uc zgx}zs5H$qplRUvpC;{nUM(ES$p$^u=EwLEk#PM@fhLOTY;4o%@8@^u_fGbnYSk>(k ze5Zt=Fvt_sTaC`aEWZBj25uDR;k|=r;LlXq%_}{n7g$jOktjG`f>((M<5&qLRsJAE zCW?*Myr9`u<7i}XQ{iT3Z-V~O=`F`w z(wIfrcw3Xx)%QGBOb}oYM7iCmt%+7MQxQCsWD=H8nWP1^nq>VhL7)yy@un3dNhWW3 z2NMON%{DvU-8IB+&3LRaQTFtumPv^k=?01#J!nA`p*I+jos)-(O8YmVHbksM$euL` z2|HGG>(;52@{CFtIAqD~v*rc1CCTF|gmsR_)L9RrI^_%uxi{LZTvq3XfDyM3*F{7> z=fYyF{r_$E?vc&OfYWM+_Z~U=kwLdlZmWlWm%=9?5VIC62J&v8DlMta$|Wp^z|oTu zJ-WoNfa|pAVhJI8A|sdV2oHau$^9MMyWhM?bLUTSRS>O)kkD@+2KP)v>B&D@B|nw7 zALrY1&?5Ktq1{>~LwlgKCn!DGg6m5T6gPQls|O5f3@ppxu_Z4;Nc{_ZMdKQ$&cLt# z@ZP?ChOC5ZUoHWlCqNE1cbxlm?(8*u%9IrW9YPy@?C#L1GdrwnCm0JFUQxs9+*F?3 zdad+~?%l4b^=UF%KJEYjeQ&$1(~vu-z3T4e-RKXwZ$JQ&4vw9Uf8u03ZNK zL_t(FvhN!s`o;$}mbTSF(G!#$T$8YJ$Lby{B3hbVRQDdUC(oOIXIlp*jqW!XM~WF_ z6vF8Nh!X2d=o~ z!=Qb#TlB+=L$>yw)WPAB3_>ZTJkR69kH5hFKMtX~yaFaOZS)Y_;8K@anUO6vOfMMhyP?7|OFp8I}CCHSlbt}OVV9T~fHs2`)r4k72M0F!d zY&%8bfm%gS?KNDD>_cPoT9i;H(Gu;94jma^*Sr-*0Ns!vU^#AcgC3ZY(=hVz~y}Pxc_M({^^d#3m1$ua*F6f+#{!7P0n; zO2xt3%M0;w(fHS+vyl*I)%j5oLK=0+U6YXTBjg#kMnNd`ri3`Vl*0_*3z6qvcqlcs zx$DPuUAp)9?;|h2c~6(bp8r#UtQvyA^Z4||XK^n58ahm!14h$!?*=7Df6XcQ{g?ZM zs)WPmf`1JEY*w^}W|ked2dqy4S%^6Gr| zzZU*7_0cC?uEXjGW}^|yo_rL1Twl0#Y=w9ll%inY=6waf@3<3y5dhXEB>YSPXO{^# z<@z#ENnJiXzSf$1~sWYR&D?N$A^}GF$=Kw(o%yp32$x$7^lvgg8C9Tf8LbhBT2yP52Zfa zXa#TD5%d@$<_arAeNF zO#qyd0U`vxlsebmL}_nA@LK!^G|NMy*RWCVKla+&3tg=>>?k}s7I-H zPVGV`#ClUqpX>vbhJk018Sc9@$QS(KGqV%{Il0yYG9&#VF$8D&cZBYygsxBPF}Nff zWn2xt!BPT^MBpuQ&`1R1y6f?AKLMhi!;LsETIjdCKcDFSdm0gGH9$x3W!)J6-Crv{?r4)coAUC_&S%bV0n}cl1 zP>5GhfVUTMn^+D}T(zw_0<xZKKaszu&1u!3%LQ>+hbN~z^5p9i9(bs&mX5R;3UjjY`cv~^3W`L#5l#n% zY%wIW5jmUI94k9_VhVu5H3ZriiucTtdtFORs>~t{Nmdm7x)m2jV_U~VJg4zkKB#w^G~w#-(KVT-uM>Bb}F({C?M=yf@cuo{@4b=ZL-i$up1#=O@CO z3<6|Ris$1u!l~=cg3zvA$It%H3v2t09_!?!ZR>+d64tI8iOP3OcO-#oJHjr*f}^!~>KljPH&y%m- zTny`?ZXjg_3YsuM-DEU#+(!)@J7MEv|1jdcFee+IEm?Hv+|ffb0XT|;T?oLH&v@AY zo(It2bB`maMyc055GURHzf%7l}1ds>; zqi`o_6$H}`sBoo%AYsh=NHRu&J#;7HhOI+VyV_wD=4gMx`(AUfXHpy_iz6Qe`1K>u z@5K{f^Z?}AY_>aTu#lkN;nBrXxZch z)lhgWy@I5)z@Nu{kbHOD{np$&ckT>N4^MEM9B7OHR_|I+fJy+70FGr8ZBqGZh+zl_ zLlk{mIj9tcBEg_&<4TexAQT0qkTq+mOaN;*u3=Mg&~mlScE9C+otlGAWn*gD+*CHE z=HRAL!QGyzW%JOe;GtE+Q>SrkZW?%M)$r1(;i;`}URq_pM*c3F7G4_JytP_*X*KZH zXyC2Wz~4;^f1SlNvT5Z{Kb;nS%D#3wE&O#l`0I3Nr_-UGoBSzn)52GyfsaNDU#()6 z?>hO@N2`UmR#Rgd4ZJL-R?DVQ%k|P|;H6d9Gf%A=-WoOhEcMh`>Z!5T)89=8KQ}En zh5<_$FgC^#1}q_985SJF)(c|BFhof!e{u{56~opT%R+7ap8?0np5Gdlg}SaWoRXG- zmSt^>gNEUtQ9iY-<#-NiR@rWA90v_6m&q{w~ zH(}=6E;yD`ptJ)h{W2mU;pD1>gh5R>vPZXp!=4y5{oa2Zc?$pm9YS#5V+&xqngV@R zdYg%(GHNXXMo%8#78(6ATr5%#!0GmXf!C zJn1;^KTE(|PldUppz#BofN$?XvHm>bsY%m?8QZpXW-B$SY9OMeE>xK~G#JB?h44E>c_lUcuFKH@y z3jjKI56qf05r&M^2GbFig=bvPmjj24bJjDjRX~6cfULc5ZNkZW*EZY^7Th;+Nbd)3 zAGV~a!n+=Qa?Gs`Od1xO zfJPSer5fCoar@vol}q`i~m-THlek-7@kP zkb}tGHGjc?eq(Qc8*O`!wylLSUf(*gy8FrjjivSt44gZB^7M)SMDi8@dJG?p0*?^< za_qcQ=_d^Ct-5Q}z`OlDJtw=kYPDcH?l0brM*9si@&59Z`A;VPlgL{@erKHU;3ES& zc8z%+KpT00)I$h>wE#{4PW6Wss*##ciH6+!?Nt^rTh*Abh2qtK_N=&gZ z=j*_P`{P`%P~-)BA+3VI@K*_ro;Tq89p#wuaRnYe#-T(dAl1!)46PA2H6~ou8F5u- zgalwrmp;ss(!;azREA8MhL7tBi<2}LaJRy{8z{N-iSab7$b0g~cVQaqW0 z4zF48!rfs;^{WDC3x!>XiJP$20!flU z6iEb1A#3Ck0*1(*k_-bdAhH~S#mke*q^?DWlp)0GjYud3B?MHGtjqKn2QmW|Pzr!B z_GJ_rI`O(+2tYv;uS_{#d!C_I@6Lu?aH+gbo=_z}yJ?hjwy8uduTP6K1tE|Wo!5q( zgBgX~wB1(g90AkumYRBy1ilLx=KtET$i9+94tMIb zp3lm9BNvc^Xbqn_~!DFWj zWhDp8Q_g_EA(qVnlN@9(BiLoPGUOl$e6R zHXyU32?!4J>fYzwvcHbaL=#uJv;rKBI}6k!CQbdILqt@wA4(Dj48-x{$B=$p_gO2U9|IgonSs?3ho#+qbm)o4 z3>B-*`IG=Rr(PLN7p2*T+KsR`bhFpd+pb~ z``}>1MxVvy22B;1|?_+=m zG2uKDiBq?YL1grKlqGmVAHsu8>ImxTj+m}_2rF-otjL<5LxUfOszNQg_*@6e@+j8C z!q`;@?l6I$vZ;!-nNE)G5c6A6<8-)V^GNDH-jIo32Fa#i=Rzkau609{ft9Yi`%ZFIgFbxyp zw60h{y(-t_+35K*U~C>d>dG7l5>RcfA@=K*WRWDOHX0$;5zDm@$8r@U7)_>n`CABF zV%58_Ut#%N7%+;rujBI}4Ql>Ts+gnwpb!L6){nL!gc*hb$8qrRa7R?9a6Ie|n6aedlgbk`FAq(avC9ScSyhB9PQ`4VVv~uKKGuxEpx)mrZD#Y{mPPtjmQj`DgJ6z=T7tBN(lw~sMY^L;gSFMz_Tx|95`;`Kk}i=7FA`XSUhcFvDv$w zA7R)wJ705YQMIWs?_V7QAAbX`l~AyUN=nIs%*+*=Cd__l*Sr^A8TxmN3S5+%Ltk0+ zWD@Tm)GBYgqRGfrrkvgLWqbb_aHWKTeNt2zKtjPDDgp9DM#hToraiv!-!mTn_q!UMu0`i& ztggng*H@S{y#_bPGEq^Wr6>PbkhATFPk}a(P_PHCe3@~KP=laR}q2d zv25A0GSYoO!}@+yLfNT9ujFiB_cGvm2?YnJpaf6+I4Al0x;x%lIQyM{-#6huTni^H z%)Eg2*ZuO+l8=9|tIO(o2?cwg6$E%7-~iEb-jdw-5OPZkjEcPdbU>kb?w<_>-^;_?~IH~Xxr-C z0;HTg3e)i&SU$(Ox#q)vU6vNVxAuqAm##hv!02iT1$!VsIe^FGH(*_zU5O*_nz8=T zSKj(ZJN{IZmf+Lp7N7p}*WEKwpGbGLgn~Vk1Naw!A04KMR>wR#Qv5YrU_uwfh{&ua z2v-wy&kVp0_i`AG1S9VXMCxt62>YDEW4j7ZcgsTFGs8c1JEuIu?h!#=+w!E!ZFv0)CT_dRrQejB$nV}LNL-w?#HlJT<=`Rk4pmFE-=vd zkkE0L0e+bbF3t9Y$c&`k|IY-7@5Fg2!U3kvJzXoSpYy~EnG>eMXcFV zv89wkqV_|JS!qEEP)H6)T$^WfLhW*W^(9do@xTQ@7}-jYD)W{F);K+OWYWP4O? zNB}s7fmlxi*rI_8NRkAzAl4&!t@TlKaO-*DD(w#d4545dS^lGe>egoV?WLhIA#JZ8 zDFp~iz;H~h*#Virrw~LQWfkSPlAeJ+y}CC@Cbv0i*Tn!rK41yi;3#=PUiP`GN#}Bh zPMR9oRuBBu73C-^Y@H>&O~LWKztAeed3$t?X|o4yi8rG%tqvOzGpdFr$QZ5K#N z)K`Pgy0THMuJ{qa8*Npt0t0{#3jz|G&t6V zb2SWvkoS#7%_acuy@!o_s-@&D0BGIaF)X%o{+3Ov3jxyL&5Exm84KVu+#2sdJq6w~ zYc!i|wt2+#>OG^S*W!F!%Y&1O6MJO(9p znbA`6768;L4!ycY+zsGO$N?m8HS`4JJ)_1@@4R~q9r@y2k3Ko{??m1LKwww|&bN=l z$xB)2AM2a~$?b!B_#D5Gw)|vL`f)Vkb>?E|3B`K`6Y6>4X?=VmhD?~e%!_ef*!zo<)}aIyY}q!%H(lD z?p>6d{q(iu3s2nQ>Qn=G7r@pAQ>B?Nul7*QNQ}a-pI&A?P81Q04VExDtPt}%2`KRQ zLP~cP0`n@tPtrgg+!ZhGBxvthhWzCsw(Tj#C%cUh97L`!=L8rT3HKHR;8>O$I)@1m z@8ltbi|EuV4W{+MxIEtjx+;I%UeFGzHzgz*lcCng8o6I_^Ds2+D$M;>$T=@FNbhrA#!B=rbEm6ry+%U6LGc%z$;g=%g%F037ib|`}H zzbGo_)~_dJfx?b%FnUo41rqX-hoP&q6<+3ibSUKN6S#~_`gYjL!@Y{fg~vRhEph`q z&8Qe5wmN}poS+B)v}(nw$6`w6O}_k<^~sH47=%ZJ!OhJL6&01BqG%wb=-EX9>#X+1ErlsznWnx zFMbw4MO&5&$Nhgb`S_7HcYnX?!|9JN3Uu|7KY{0QWan1o6c!>AI;h&Uoud*T+=U}0 z6)k5poCK9bRA;1~;Y$jiN87(J?UW?$sjRHmEd70S|Ia_H@0{54QJ;1#ciK36=nwq1 zcQ=G~A&oETXap4{#k9h|LjWl+C9JN6w;W1g$jRDcF35QUfqoCQEVCwIC*`;WbI+a2 zv}{N|dVI<6n}3WMch8(oEzR7h*JH~!pCPTd0&3ruIeAbjAv-He;`{^Kvl^{D8{Yy5 zm1UKDMcK2EJy6;jJ1ND2jEohTmJKOqPJJKUv(F0+O;!|U-^9NCzry71c+yG|B_v%+ z_h-GlJCX+EBPHHcO^d6S;MS0q^~Rlos?!JezZ(&k@PSt6=I{c&c{L3?cJD()1MMJ+ zA}!3X2v++C)_7{zfn?C<3&l5{!!2qDiE<0pKUlAjGjA*a03ZNKL_t&?EU4Oj_^)?+ zbcy`HUFTR2I5jH=Y88jb4vrlXEA-g=!&CeetB@L;0)dnF10e)T{f!^Mp1?AbaXDplL~Q&& zo_J4BK3`H^P;l}VS7j%FCjtBYQ5XDK{=_+!n{nQk-Oh1P&5n}Ly^l9i{o8?e_s4*< z1t9up6t6Ca@nkl-3@QVE*L37W?MArtrYaa^dt z*q-5NPj6uKjx;a=g*fvHGCK{%fIrGnn&1xMhMP>@DoFGbF|F(aY`InjPRXl>3FDJfs^Ex=g@EJ_-E}8ek5s z1jkDdRP}FjteHi*wmq_=(~y{b9bTET&w)EaU{4V#EUgTstS2tblI5dJK2`83peP$4 z;riQVbpFT;^G%OddE(&-2YnX`UAXScm-j{=s`a888X5u*cO6t53*Iby)M`{L47>o2 zFyIt6Q^m4ihy+ohAd0+#Maz^BK*ccdcGrSo7zlzW%PcSiq9hY?8nsF$=2#YlA@!D~ z*Od_+y9@f?9}U$FL=!9Tuf9y~Ij>)=evu zp*&?EI%sH0Dcl$qX0syAQKts5c;GS&^!12Si+8Oe5kgVxylvAlkoAf=!q#b<+8)o; zdLH&ihwND{+MP(Cgn(fvM8ei0n+X8INDz1tCZidJ1;r>TDuH{)wqCW{ATBYK{`-NH z6sKow^RH)q{OeCY42+EHHYvPotSjq=OQ%nw;6@hwJ={=b5P_JUEhdDVMPOVnCU56@ zh(EW+y7B0)okOF0_I@;R@NkzB zoG13}0>iR!X9;}umEZ$=f>E_i>@;0SI7~(P;L8fZdAQ!&*qC#pkS{5E1%UH!sV&D} z09}-kv9fM|)06x6JR2O@spstfd!aAW0#CH!{9NQ^UPG|IKdvw=q>!in5PrD}ec_Sh=zD4?z zM|W+5e?TC-tBoiO>u(F6M3HvTqy2Z{oZ;{03$`T62Vxd1`yVA6mEym}3GXVQ|P&q$L4L(~PO zFc#*#TXps7?=3r>CW4T^C?N~yUbt}BQIbuce)w_6&e21MO`bm8-hQLL8b-YyJ!7Ns zTTU5_I)}Uy@$d;$u{w8DT>1;dPFw;iNz_=Fx4bGV>r%7Mr};R`P-fBha~-#X1+TB( z@^M^L*s%M?51D3ff0f>d%4!45f`H(5zR;@c--jrr_+j_qAKqBCCW$AgccCBGklycF4V?hlNc>U_M(vzIdr zn|?jJ)fN@r00lw%z6?;{EJLv5Hg@#ARWvpf&&druFC) z-yIP#EsvY`$CjUOo;`Z-|8Q$29-JDl0IE{Yo>{u>n=hj0FMl)6&BL`^_`$6kQJkBN z6Z>{y$izEcT9ySBCB;bFvjHzp8w9n=xyNl$lJLn-d$SK;xV#*I^AP}B2nw8KfQ9iJ zaHOGh`PVZ)*}HB{|4wn;rnvf@5daL;RrvL%A29KOd1%X3Whp0*(WAd?+g@Cd=UB49 zwKxl4A<%Gt*n@CN*uxHD9uU09x`Xa_6Jyvk42TLt1+F4BA`=zm$H0f^;kS`R_F@r6 z_dQ@l3W+7?tjR#+qcP|-v}r=`9o5iHd#?Z*lH1`U>5l{>Vl$L zfTT9Uy^2NAgMe3XHGJo|gNn`LEKD6K7z4nT6QGa-D37W#;nSDLrCqM|YaJZa9=?8l zAS^3;BT@>3S%fH2a0(G7YtjOe1h61rE#8X6;;l&(hLDlHVF>}pa22gjAd(5Z6lHdV!MrsAXHMeD@JWT9T+4Dk|Y5V z1y#P=8kHnSq6D)jL7)I{V|M?SXdQ!ML^fL6%o2gg)~Nhxw3t}m3?hL+0`wxF7Zei# zy;S?tAOZ$SHlxKv#gzX|lmQRUYG!aSQw}C7e-{`vSWXRwRn<361y-eoPOF8RRs%P! z+Qw9H)2gAXCO+^G68a572X`%`H0L7m zwif&cjfTVvpuB72&j^(jk})@HgJ{zK;?ja@P)sRZl#y|@uRT&rLD|`Ze?0%^uX~!k z)Lj$>9N)bYBc{&4kO`9ztS^OFQQq9_YQeYvNKm2qj>@9JU^eDuzh$m0Zi}0Ue0{~l z^lj++O8N7|$6LStbazYcqiN^P!rQMM#@sy%;r>2w&rWZ4Ubawq`NAVA7Lw7>>^uxN zuAMOC+<3lKD&!oT8Rz_=%^MeGrCrXoxAXGZ)9BK@2ZoQIh)z;9sAPWykOdxH;=y@& z+udg_Ek0Ov@%(E|I)j$MI_?@GZxzr38`mvNzi{q~y`5JsoI_MXBKnWK4P6)$AT)eW z)OG9xwU7NJzviO6O;u?Z>P1p^A&Nn;hh)B`qmb6a^gJ zwH+O!V{rCh%jPPmBq3?@T0A7b-j@_>}4qkzNcK85H|uBYq%{4iUci{u+x#e{y)~yiDE#a=fgS8J*yN z)fdHEBO#Tlk^ij*n-3HG`L2M^_+s3?whZ@bufm*IfHH44oERL5_~cw9p3lXx-B@ zA6p87hMG>I6oOySX7Uydye>Iv=}*0Fxw2opq(^ zK?rf?;gtuatJOTe^uDyTA|xj}U7tF*kaYaW2fuCjamA#$kNPz?6Gxzugx@y)i0*@i zqJ3CL44*O`KYjczd`q%X<{Jo=uk+eaErH6%58mDTqax*OiHw)QF`(K*d}^~Qb~e7 z>&kXhVUG105h0M5C06VjUipF5GVsn-|(=e}JFJ9LWbGUJKG@lBQZt*$6X+PO2B zFnb;d!(impnJE6|3uF~!1A#4H>ERXM3&z~*prQ!UM6Wt?X;G0-RPY??$-&SGgb=6N zU6R<|gosYJyR+l`=-wSE9ilqF(f;wLKGf>mtj-L%nb!~$9%1#`88><~%Jv^bfqMf# zafHA-aR7>s{#t9ZXfl+T^YZ?UIxlk~rMEjf?kFLB7+E{FF*NJG{@2l?Iib;;UkVD3 zSmWXCW3AJ*lnaQAiMIyg9XI}V6m8#yT+fC{1@B&iP<(hFs95t{C+MrLn+gk`MxAKH zM5N=vIC=en?MsQ|%;Y8y;B(%jS+-&RnR1|M&o{pxKcBrWqT@?Zq3zfBd3#vvcJ^`x z;-kWpXF4DzA_U1-Zy+J6CdOz%X}RI2{U@F|a3-y&p)y2D$1|YLoj1$$B@&!IZA#=)Z69L$^g~oaB7WQWBXYAc5F8%aoUD*? zU@s$3q( zouM=z-Mf2X$EdDRcRun&*CrkdK)&x^I{hbZpFJ0)1qC>?Z4<`bH>X+gHH`XdZ2tU% zT^EiX`pDjXO364tbgKO*gZ>OyKwugx$yGy$I!`l;lP#+nDOMlp>v^(+u1*UMVL^8aRbIWeazLH z`S|$9T}P6y-gpbO@3CXy zud8Cg*b?vCzWE$sUAm%Ubc{>NvVckwc76BXoQr2pE{9{;f-!)T_aR^a0K3;?9q^E! zOJ77Q$?k1fvGwyI561ZfM{D080zesnF#_?a*~sYL4uJfMLJ2|m79%*LggrCWIK8bH zNq<%2uTwHXUudf7--swJ#`1oksq+7nXHcP5VN-S?GKvj2;iZuJ1aSBD#9NmcEDZz( zAHE7skl^Fz2C=dNm7(64G|dA;Mr2_3#=l_5`yB_$6M*)kfVk(du3W;7yp1?gco2g^ zQ!zWA!soI9g=#hSy59kBO*?3_iqQS)6_jN~pd!5X&oHYMFzC=VWcdbx;eo({N>q4h zaWNqn5D35mVPA{L=;wo?M8`kj9z_7R+a06oks__(>i41pC*sELmXxVy|JuMJidBw>wHH0gxK;rjQfcS<-Kl69ENB2ncbU z7fT3;8sN?Lm;cMl>j|_R1CB}-VPU)FQAq-UR7Wqkb~<7Sbfz5RFfWV5EV0j45)ep= zZmhkAwAQ`>_Lc%L3K9qr>hH7BhNXfTtWE3>YLk{ys(4OQFf3DZzBV7SM>ks&#LR}7 zwN#H~7^pZ-(IU1Ze*k$bQVQ66J+;(H5UEXYw>t6*L>3aUC6O)UElU`vRVsLUc_J|( z7CN2QPAT>=Cpr0ovuVGLkJmWiBf1}wwCKT$7h6RmsU$yl&7tj^26yS+V^&P>ey#ct zb>_ftpp>HL(2)QDH%~8&m@)(Ve)=BO>E}Uv4R11`&|G-M^@QR2HHi9Zux_m{`)ex5 ztuPkmuLO{4yS*v>zouI^XM~ko)c+<^_5Ra;>|Yh#qt`QoC*0YpLe7VGY(>W|UC}AN zI{<)XIgFZiH#U9#5j<|D!Q>YJM%y;p(Yg-da1ZYSL+%ZzyjovM!H}JmBa{^{1yIZD zDI?*j&APq}2E+BUf9zio-*50|@%;vPIeQ$X6omyxm3>2?nff8N81_q_e0NETkd zzT%?O6$G&1v-dx3-!Wpu=o$A+0|1l3fa=N$1V_|J5(kEaqEARW{FYYg}E#AIq84ZP1}@lw<HIC&vHHs&gTp(G z8b52!!-No2l$LFwVRgStjy&$V1sYaK6JW>ji;#&kz{(kT#z1rKKOCRkDbE;M?F4c?8Af*6qQv%#j)`7 zsv&Lye7$fzuL$K;dU$)dL6Rue?LPA9r$6o5*;xJ$r7Us!yw`MJ>BM={{SxIC&P#c^ zx#vyK9@xKZ%a|*8{2ol`_VmmH|e30Qi>xxw_?!klfbeZ+68w&`>=3aI(-sxeFrqTE_>FkO*?sD z|9{{>I$>_gGfubP>V%a}JTTGy49HUtBtP2{ITiD@%KDrw#559 znRuTx6$iI&#PlZ?xs-T6_4_{apTF+=QD0H9yMbg*_XhxHoT7FDSOlQeC1VzLy}07b zGu?drJFA}YIzy0Hb`5H+2~{2%P`4mdbEN+0%I@~wE9oii+VYts096P)QC;!x-42h@+oq`?G3hZ2e5r^njygIf5N0LM=*{~7! z#i%hWvo{K3Jka?_8U6|j0JXW+1d|GkNa2oZWU(C)C1xPKO90vxR>3=6KuL)&itm#k z6lqY`kxyk7!K+z>UMfdvIESj0Rfrj-0n_{iY~V@>+8r^XWE4$1mYXtm!vR=H$9fk} zr>IWw^7Mk5V`cwF<%$-FtT8JA5U2!}5-?It^{GUm;W*h778agN4pJs-;Yx~kqlJvM z$So*}3wHQGz~WsiFFzNkVv+=2lE705Jf#pM2?7;i7DbpP31&%xsg{W_N+L{>2$RUm z>FO9SO5jELSY8rq%A#`Kf@Cp4{uBgAq6kS4>>3pXfJ)#%!B7fTF^0-P#4N@E(6TI4 zgt2-rs~A$tEc(M72sjW~x&m^@jM^p>ud+cgTE}WUmL*E;nn)FIRLK9+IwnzhpEV7L zOpFtY$$6Lr5hmWO7%!WdhneSL;>|FaP0$;S;CbF^0?$Jbc<=%bGjE38Xo8s+APBN| ztHlIC1TRPsMG2BfA&T;M(XvgErl6J+27x5mwu|BwP8Fh9vV2F4Oo&Yy(c*neQO_jE zZOaRy)hiuJzM%5Nh*qmXXh<-+#kZWma29o@AW|tI6CX@Y9@ARntpaoUg>$cL{pz!G z<;4v;oiquB**B4N;s{1hzqgi_T4Y=Tq7!?fgPRKc)i%`WCj|b(#z8bxfjS7N*IbB( zY8bLJc8mH-S8C>6CWK6Ah5n~G*U~@O^ZlAb+1FZUnKl5V{&gCK**7rg_DQw2`v-ME z-_hd`q*H-jK5KUZ##Qj?I}{**WNux_6LVQHZ_K-~N-!E5ldWh8E>nuzGcw*B(^T?S zf&SEK-zbbL#$uhesA*X{W47e6)SK6>HkA#{w6LEWHp@%;v(Q%Ep8 zZl<=%HN(1l!ZWr9L_@XH#~8A%{$b3$;cDrCOO(>_85wVmX)1ZEfFA#4;{uC>z?BPs zAao1e()`E@SfBm176GzWd zN^vti4fb>j69*1K495fJh9xq!9XdiA7%Y?6#kp&%ucWwI5AY%Z#;toWc}z>mTMIte zyyZU!&R#rADaECXo9NcL{tA#@F_AcXIRlhZ>^Xk!bJ=QwdM2`<=xX)zcBrkUOiDj4mz5B+-9;&M_%j~Bpv8v_y#yn2qsfrW*Lx4Mv9*M(@8gyPf9 z;CTX~r`vVS=)kz*Xgu_tO#I>HcszOADcoxQH{6zTBd*FggwGOxg(uIih0$<7UYeeO z`|eId_Nor-Yr6vL6K{sGI+%Dg$P%ov(KvGD7_^Sj`qd^MG$UgTh1_IB)7>1LF#^PV z3Zc=zZPIZW@#}e{?-F4yG@&Eg1ot=vZNCiB89G4c3>zaM{-8b zl4d`$8}6WDdT*SOnSuC(cyJu&mpIU*KLJ8~WR(g{CzRDILMb3{9E=3<;wO{5gqW)OvL3yJV&9;?EX*LHk^roh$qW{nc@+V`5r88Ee4k(-5C%M9z(OZP z2?LJNgD_foL@R><0Yl&q1kCIEVsvrdP+F;4Xv6ji%V>nA9$u1@>Qjbg!3%=^8G!;o z1_=mF7D1*e6n$RpbDRjMzP)e%z1C5^p_7r`@DaPZhHLMCYQVbQ^%ZFIGF72a6*AQ_ zv=s`-Dj=&A9z}&HYesh(ajN=4p$ZgLfzu;Gk`*Yb3Pn{RE8fruT3J@$7A5WPz|cQa z6h$waLg}R~tmtKVb(S@fR_zm-4l&iY)9b1P=o70dsN!AbZI1z=Z%-8!iY$Xr>I;Ty zZHi}E#73Jiv1lyPQb%YAehBE72rD7v$8LjR>LX{)jFcEq_31-j{$|Vj@3!{mwUH(>UaSBE@@>A88hZ0_YqYOe#mh>m7B zAS{REdCQzRTa4EFRYe2Tize`j{CwwfFF1ahUr7l5$_Fpc*kcy-SEa=kB9Rz zYB9H=wZ1lF#uXt1OK-ayS*!}u+TUot!6Bw-3i$ZMur!Fpj@D+;+V&p+hJS$w4GX38 z2T4g?(`##A9M*9^{^ge~JJ)~oe8rJNQvQU=2xa6%7zWo}zZ^;3trxw)#a}iLP!+4o zZvGK~$oBU6VFB=TgxVbdpsT9NcI1oCesXf}PIqAl5*yIk)wMU>f~3y+i#CF|X>$RB zHnpSqxk%KnA6Ni9-JF*){ey=~w?(qxs;VyAx*bP;vSt5C&t($}L#{&z!K}%J`2650 z$C|ANf6&<2IE-AILBRsx>AV#8^oL8IiP-nLP348yiK3j)GcRQpobEiWTws1g-`$X z=Guy5$427b7>F(k^8LJI*NjI>pN-`4gWYc5ba?xg4^Qmb84=^Pj+SPeKJX=$-F06d zBR*abu=Mu3vH!D8uysZ5Jpcd>ZC-~NaSG;73qQ%{tI9gOy=mw6s>arEBtM3NE&_b7 zy&W?quf~oDmRnzOXy30tUHMjIiTAxbp(-+FE)FK%7v6B|h!XFc-g>RN{Me!YM6V3! z5kMD!?*fHlZP0C=_` z7f-ZKMB@Vvlz(W0>DngbaK8`fqp67y+rR4lLMx0TYk6q3duCtSw2XdN2xS zSHuPlN*6OJ7@bn>F5-~1l1J7m3WfDQLs}l@AudnT{vZ@}|0|;X-O$o}@z*p0uh-z{ zA7XLgXAHPI%{aHIM>={HEq>tpU47&+`aG#7B_$vwH5r`1YlJP;h(Co=sQU19NmhNt z8KoMjDR7$BYqZe_g;KaZ9uNRL&uJQ@0qM0W)iP*hMd?e31qFPP2#j7vs9=4hs%DPH zFr@z=-gyQL(Zl;U!+>R2tqj6~AuI@CH8}}}^$peMI1UCu055Rh1-?%R0uO=bVK5rN z@jN(=1?vkAEXRT2IIuhiR^UN67L+0W=tTr8pil^)GDHtR_632$XrFn>T?K&31P9fF zuv9bbVgW{Hz$xS3pGE@vBbdq7>IX(Aq5+?|myZC}4ZA#w96;~}hnM_yNwS_rt%VFd z^v^|AGk5cm&w-)W7y5Z6I-wpE4Dp%fF@%6Hy+W5b0MVo@ylo_K9foKOzTSV)C%|ai zdyj{2TUHB(V<8v>B&Q^zcEywNK8$`#F9B7KNpNfEW7Jo#IQhAby-9Rp>Pp1b`lKfS(>R?1mJ0F>Jqy< zeuMrslZFa~0Y>{_=PQ|8PM8nzq=LI{@L zemA0d4)Luukb5E`^Ar{gX_<%_KUE`fBLHXpg&I$H$8(5~R#gBLLdfepFBjF;{`UWl zAAchv=Q~`3t?KeKh>1_^_Z$MioMqP_KPeu@hLHY1g9e|Jis<|zC?5BK>$#fhPCJ`w ze~ie!;41)L6GUS+Njkkup?#Cu1 zV#16PoZNeH6FEvLHof)Qu|uD4eikE_H7J9SzYvL(IAAx;~>?yvP`nk12EJVb{9Vh(y8)0Mwo>hqLqmR$Lpt{6%+< z6Tkc0hSCFHo%=a}@Q22P2N@K9B|y=XHTcU&w0pbVzUlDR%^#kOz&j%Vv^O{5^novN zWv@}2z{nEsdp53hp4_+dEm@WiM6}>w$N>HVpa{TUff2b5^@|ln=kC8C8@4x1jYSKW zjPak^kYIM=e67FJj)6wIL@5lWB$#mD)D&#E&xA)!8AyD`iTwYin7F$gxo2$1tnNYT z4_XmDRlDSwrgS0INO4t`4YOXfAn$|?bN?|JkB_?%`BUG3%0;30bTcZZWT0`(#T8mS zX>kxNsfeETD)#(hC9W~9M)%Ge@$2qf{8ji4T8+6Vy)q5+`Gc6|K83V5V!1eLc!O`n7ad>tS_CK3}^HW1y4_JU}C1AS&B@U>4RYb*03>41K^SIH03okT5 zU1~?&hfZ`pD5GKd1-O2cA5@fjeN)ls=rR_mPAW-Mo&~2-v{j zSOy%c5$YVvY36pmAijBxtY^V6tVT$qS9nQk!UXJDH?Y(4u=R%|0#${-EeAeV>M72W zq(G(q9A(*?!aOSHa6Jw{o+y%+wM#<7;1Fjbn zpMZro+=?WD1#|A?=t?QfoCn5WgyJ4vGNGr_>=rv(Ux6e=It^eqKufBtfBR%*j3TNMM|<+t&+L< zc>s}oYTvC;TJmsd>38m{9N4UAD5yVQv3=XBzrAa2tnW89CD15tAQVh4#-s`35#Lf3 zk>3m>7!f~ne*aPml)_n8wN*4XkA!r-NAi1%`?hWQ{?-rvRyoj0PP+|f4(`M3E3fW%9hT)V@46fD z<)(EQD8tn4bf97TYTUng8d4MEFl}5OzBoE?=I(`tHg)CZz3)`iG>nuK(Jrc@qhQ77JaeEh+VmfG5IOeTklod7Na@I8!N zN7cn3{ae9_}Sm{al?!0D41XZ zpXCOn3My}i16w9Q{`DAe@gll%IYeEfy;CvKT0gXstRnmJ8hGkrk!z2|ub2M_BxxpC zHUXl6MSE)KTQT1jz~3kgEY8CCj?wJoJF%E1F2j@L$XipFD79hZZu|moBXI1qpk-@(3!V53- zUf6B5;j7c7usfU@$wmOe2Aei%S&JH>MnJ&voR*=g4`-JZZJ0d6FfbVf-;j1d8}>p~ z>eI0ElC^z@sB7hThqu!{#H}`!6^#t^E)QN0T2Kl}QT>tu0Ym$J(f|S51=dLo8Zxg- z3-~fcwe2J|Aj4GEWd#V}mKC^U8E#pDTc5gQ32t4lS0)5bS%y=R^bp|?B{(E4>>dxS z4hQTW5j~<74pCo6pE@N8E?Gg3q^~21a7fl;BYmc)YsA0eZu3S%FKGG}AfKSF%Bq=>TL^?Ug~zfMtnB z>M{fzr?o#2su{8os}dbY4ay=}z%x2CbIQ0kYa z@J=aw^_CSSAiG=JFUK-47zCuHCgI8}7GV0c$$`D*zxu^5ei6}L@7vPTO)4RK9w{w- zW@CH%=xGc1;p{NC*2toJ$+Y>46WBo-jJcf-Z29}!xZ>73k(zaJ_w=m%LNr#LgWP3? zg|gsc!`F=(4j7IH7ngvZb7#Pr`ZseK2vk+zIA3~L>}dNofQyd<4+A%+rkWUF_rqmn z&unUMZ;M2k7lGW>*7}vh*1crf{Ke^lF?@4AKpU#IcjH=IcmE?WU4)1NfaJ_9ba%AF z(`AOm=?0rPI&vh0VPH(pfvx-mxTxsT$zaRlZrWc0Pj$^`57sEQkTf&YGIv zJ!`e@AF=Z-%W}8mc6DbJjJql=J0~a=jZ*59I|=6;8cik`1Od&ZC*h1u2H}RucMt+& zdJY`t%fRr#j<8gg&{K2vZBKjaOT*iVhC4DcVyLR_e7LOa*^&Nzwbs=h^0?g#W-MBg z-}^e+QdfhHrbf)r%^fd>+_B?Pd-Nc>9Zt}=aC|Wa1|OdYvAqq7%hAU~(%sfnEw$A@ zsCYaP>o`hDSrh}{i<+9>JvS2V{Prim_r!G%Jn|Ec=fnD8Up8wNzF4;gT;{+XvO-eo zBt9m#-G1)O(c#qZ){Kl806QKjEq!i-**s$H?t!2D?3c^#_|^)B3Gco=bM|cPT=y~9 zjNAdQi9%v(J|CAX*(**Ci)fp6OIi$Ju>He_OMhCrVdRd37r%Y#-e0Y_X~{!u2uY1l zn2?t>!DtZdJCBw|G!yHVw5wtmu-hLledebd%-cufz7ECX>GC+8;+P2&mnCOp_IV@q zj-0vt+T}3C4gA~{9UBX~#R6-G8L3&Jld+Gjdk;^{$wf+n_B=HvBL!a^DMfm6JmO4! zv%x*0grC0h;r7+r4}KRBmY#ZYB4R+Wed-$g^wkQC%JBw(mfGrriYQ(&ec=_kp?-s{ z^|ffJtHEVg4BSx)0NDlOuxH~ZD4aYMY>0boM@zH%(Vzb3^|Qy0yb_Vh2jJ$^t6~X5 zK7XY2*->k+0HDfpoy}^Aj!#OuJb%)Z{_WxWL1Wc<9N+x~Zg}W12!?^5WeFk3%qzg| z^{bIHwg{%Uuzg4SV9&=Zu{fFH>N!)w-{yD){nPuOeq7nm@>@hGd-|!Vh#@Mr7O%zg zquB199qny3vd4YJwE2q@2m8+G#r`du008r@zp395NdSy6gyIz9bk@_U|8IVn(@)tdaMy81|Ei- z9yrRAabS5qIwu)WC^n;0jt8H90p?eCBRRhYuy`=$tOeG%6!awf&$00wfzUu8j?wzQ z%zKt&S@S1Ia-4wOz~ZaiPvArgO6J8OE!6<~sqHvniHAjg2zN@`vEF(&V&7+wP?Lb{ zm;V6AXZyf>(G2^H8aPcngajv?hjSq0T0whXRVcuB5J=e+Cgea0F|d-ARm54{Xw412 zMtEQax4an4ZIcnj?*y|y1CF_Nh*8>iGgrH>dTdtJfX@;k30y^0as2p6SS{U9bkbD? zpr{nu!;D5!@hl60)3P8LXxX?PNrvjxw*`ff7r^rzWLe9=gsQ?L$(m$=p6lrQM*@bn zg8(|YrwvypeTKPv=Ru$odm5p~1Z8Xz-)9`pfa4f&9IKIkzIi=Z5;Ax_ynhRfrmf3) zgCXDA8NQ^Qd(O^J=(I4?f0r5ry;td9UD)_@FAkL^y4FX~X z0kQf%V*7+vAK%}CfLKARYm7mk3fgBzmO~WJ!6fi72?9)lcb-Qy&m&sUb&@$2MxKL# z=V0VD{bcXFz_MTo1A*fp@Ein=gMri9n>NqE!1E9|&Uftl1jE9>abOw77hc_C|1wt3 z*42XbX6|~!n|%xPZmsYxRTLGXB>OrCyyj*M!y-C53ggBW;FcS&MN(o=uX)4?-1TO2 z$40X`A_g8qg(}N+wyv(|gp`!a^CwOo)I-#c)gK})Cl}M^FA8gY!Z64flaKQ!4nyoP zLr%#88KisiP{GG1LGHFdvb2M_$irSJxEpI)#ny)JtBMl7K-@*JvAw;0LwoyZpZ~6I zOQ($xvUu|B%S{74JOx6LC4Bb&yO_RkNl3Gt{*YZb4i`=xg{Qp@u9!ry#_%#0h6~mh z1wsg14K-k+`X62#5|qMObFR|W((o7%xd-E}uKn#6%f3h$fm{@wtu3XF?(TxA^B0x` z4zE6Qa32yWrussm1c8d8FF;4t|Me8M7PBX7fg~c|_aYvU?s_bmK#h z{V66sA?%wO!?MWBNX5bZ`@yHA_rD?`;1iQeRF>>@)tn#li|(0?X7ia1=CecHelYm< zEz1^t@1E=blo)3U`*?6Hi>#EySysD!&*}5^O_8e0M)MBy2J`k&`QCx(XlXv_?r}_+ zHgD0?-kr0hhYuh&Arbi#!y}zC#^mGJuI)(6&P8u|j;iB_FjZ{8yvg~#WrPrn&&$LI zTfRieq_OBtqQ9|jN9|kdcdzJixgvI)y?C_(ZLgMN)Q>j+kJDx;k4a2ko5%aX*8L@8w@zQV=E?>%tp8! zUxBDNdI-{)J^0?Oi@}9SUbc2x@!VhDKf32cMMN_)UnxV|E9Dqi7iR=8T;jczTme1#EMn)I z(UKPjLyv?f)_SmHNheI77s68=3+`Ssk~LDG(G6H5Y?# zUx?^t21bh$@fCF-MgxR&E27gjBetgo^##cQ0fZtuqW7mkEDRWVMghhF$a)@;YOy2M zoe57=a6T4g2o#<`A{^9!90A4!*zA>POaBU%slbH&RWR@_w2q5GN2BNdr}E1;UF>{> zByd@V#fcMNp{30Xk0gO1M3*zrNG*=jWD{71(a2MV0bv-Ov|@bZmP#pjo&(3Sn%=FR z9V@FUIF8kHNp&$%5+VSAFf>TN*85rDJXr09->>d1O8|}mSOUT_x<09%JK(36d`4cfZU`1+45nv9%Zd^#X`uK+QvAy#MGZC-Q#8XcB|ri} zQWSV(O`}%wEmz@@6}UuM%Sa9-p`a*mNiy7$?Au>Zef7GEvI1GvWC?u6WO{hBbU}%> zEaWlPg$xMsXIuxGwyA;H)qt0E4K^s#riy<2gMXENlRZ(Aed`c-+ad#j=a85fkGZpF zV(H>}=+(OzaRT>Jfy35)%5JgD8aHjm_)sQfp-^$`Flx`11c~f)p#5AqJV_bD{>>1Ug^-j2XU#birUui=?n=KC_wF9ubm_@9*jtpvt zmoOaN)>Af%rDWXH8RG{_yl?sY+gNzhtw_rb@7>R6GJz8W9R1?+;SlfYhByDZrtw16 zZ!mI3rI#eEO-dV+LJr?OIsTsc_a*bMu5Q7)jTY2dDau<^Y;7c1U!kJep~;e_CiH-R zG8@*EXz-E(!L8ujEqg~)+6|FG|Fq~uHnyw@eL0c}@nhX2?h@ZG!Su8Iotc26uT69B<@9wi?j0Km}ze>Jw7XQIU^?^fu)D zR6uko1N#;JM>-k>5P^q6J$;0;T+sqZ4+E;_PVkKcYCNFo$_$dgL5U(r`&|@jW;&mK zwCLPh;hc+*1TN2WI9FMP+S+=EqNtO%6f7ZN85RbP^_hSXLZCoJw84NFqYqQ+mV5W1 zP=9&;U#ge9)w0q(lH@;DUIks2fzfD0PIe}4xNaE=^84IezOe)@0I|KPvDD@4Svq~e z6)C(hFxh3ZbYaKp4{*&r4Qn zr@%$Wgf+CD$`X32%D)sl%})UsEywDShHC9>KVi367EQT)eol1Ezz?I^P_^y2{((nf z7(zB+Tv9Sbw;T4B23UI>V3P;P{)!|BfiWWowzA`34N+l{V2aBDNA=kavd!`WE>Qw! z5O6u|JvB)gnb&6K7npXeS%oWZy>m$CkT)2Rn4FBd;|I}WN*WX)9ukCTS)u1k0f0K| z&c7sfnBN&*q5piCn;Vb096cq|7A&4nceVnGqF~}>vxihxcEMOQmz{#8vkPj%@a0E1 zQ!M13ZYXvO+~(%9j@J77AW5U=FgQ%y^TTJKzv`}gzde)}H~_e8_8jb5zZy*XMI;20 zQuFz^1ed+yt9?VQ>qz3k??3a>g5@{gG?-49Kun!66JKsz3!0WQAfd;{C1whSSc9$f zSVUduBaL4^cHc{PT|IBe$D=4Wb4+4v4FCDTQ(x;2I~_ePr@b{jJMWsz{DLS|QLyuq zkFfZrJ79Ql2 zXgqkqfQIwu#dUA|`Ni6@(lsMc^-Be9c8f(c7^4Mz&g9SrfT6H)&oSw>Pqw|&(AxP5zCInL z;Xv#d3i1BQY9ys+U}l(dQeLEG=c1wVEIL}6heW)u{GVSRD?NPRDMZ#=;cEl6S*@F} zJgW5X|LDBC-7E#&C>Nxu=x`Irdh0yi#bWt2xj?J}SF`|oyb+xZ0{-|nfB(_H7fWFB zSD@)h0~!-t$l2vW(nDzw8)J00dVo3=xa(pej88(6)PynTENEO11GkAox>-fhkp!fd z*CVD@hB4QL@~d5e)O0`Go%d5dwy1wJh1*!`pq?y;|Bl!!o_f z^OC7rB`BqEdo;pW2_OX(H8><$@@b>?30=FD68|!pQb?eXL3Pbs-4u>xp%4acS%q6s z;Zju1EKTwLt-$6HVe@!==4cLCfm08MtiYwHa4Qrt2;924n!A_rTHxOvl|tiBgEV@tdfsP@x-@5pOoL77F0YaMt8B zpr1?l=Nah6W5K>GUOrZDJUVq9*g*gv5gbSgtG#q@RT`KTtSt{V*7LRv6^g25miscp z8BL#;=Q+g2m@sKV5pG(36{7n-pnj7HTmWdZby;L%RMdj;Gx~psqN<9mAH0jAX){qY z{jwqLh!BFTfFO+;S)k(f-}WJb-N&%Tf!Qe?5w}g;A(Ao0;*g!3e_7; z^mMhfHL8lVWa_+yas81Z9+wNBz5h1mFTWWXWAcZ*v+TmLs6Sf{vAq>Nf(dN&MSW%> z0>)qj8x;j-^*ON7{R`UzTHAJ9s5k)hKnuU+F*ko3|2*@7h@!izquOb=rbr%f{)Cw& zWH{$AF*OZ6ZOu4;^pL{kj%9|TEgT4j=fMaDbe}wM($!GC0$=|OH~>)E+FA|}MY_Re zu_Q0P<#sSb%$_9-gRJ~QoZr6_T`Ehtn7H8`Z~(@P9N5p6%FddqA1HR~!QqxST3B}H zJ&SI9=<%0h6B7rof1`t8S>&Z9s|ODpkolDK{#jr`z{Mraq71jkRaeU?K7v4mfio2mk{uYNhK^RoO0Bhy(BZ^zkB!cJHC6* zwZAe&8HRN{@-kB|b9%(Dj+I|HAIbXtGhl6Ruk5jPXBE$#H>dRQ0g_uZ0U3GuLn_bM$JDW7@bbr7%ir9%`$1WjEkmln*8_^( z+H223?Mx zQoGeMaZJ&KsVQ06{od#7Rtr8~wGvm~egB|GwRpiB42Vxk#+UzCj|nqpg(Y!uV%K(5 zY+Z+++waTFKMd^L39y>Mv6 z`}#Nj(spR;r_YFP_u)b9^c#lqJ+5;~GN~g1xz)?N{AQ+%H|EJW(Z%4LO2790g`)J{%>6r<%w@ofZ*NTBL1s&K6XVk$-X6Fm6n zW*k4sqBib&+&r!fP4&^px)5yN5Vwa#%uxRntW47@(g-d_*RR!xUM*u%QM7rD#q&qdP?3_$ zvI3{1PkV(!mNf%4S%zDdwf*WQV_I2iP~AKV4Vc&D6MXfNHTeXOtU%O13k*q7eMWAg zqCnB5Gy=(SS)tmxa-gI_FoCXR+G`+1msMBK`=e5^QHG*O)jd{AVsb|2oZN8}LOxOLUcUzMDJfwYaSQ~8VUeDj zhYQCK!PVXhnlT1sh?#VQg^-vEx49XL-3mtNpa1c+Hg>t&8lIt|__ZOn!hy?b=_;Bz zXT`j0Zy2`V^q6rIaPX6lWSgw8hSbbq*G))Ff$Xqb9Ouj41K=KZftLVex7%hgM&EYF zcfMZ`j#1n|h%&{1Q5AaNAM0QmH-!xMH$w;mLwY9Mtqlh}=H^4gDs1#%eCV0~{CMot z>4n2BC^;>I*lQ{)&Xt~Nakn(I_7_rDyH&EZ&u}$VuZqMMh!9LGe)?albH)}8dk8~J zd^~YA)YhH;@{3AmZDqZ)wz45qxEgDkr7rV$S4;isNPK|^!}R;7?_WKsAZOUeBR1N| zvkWuwgU`PF8@>T#Sxas8L0d=1b&2U2nI%iE8dh1^1>>;&;}4K&tHlFLW?XcAmSvEh z6pxozZ}n{6fAR-)&E{{^{WKJuPG_gn)-82gx~^Mt`(4b%jN%4DbZjhaT^-oA>b<5T zySClqaX2DoFnI|>>1t~|*<-O@F?IgJ%-*`ofcBpL`KpyDoIG{NqguR3Oie>qTMKH+ zOEI>1U`3wx<|b5Z_&XLAW#DXW6G|ps{5B*?GG2IdZS}fcN4}@3>OVzacr@U0^qjF< zt&_%#pD-;Yb710q+p3kg`dbf#O}_TVP>A=VJGV(&Kls~Q=EjD<;G2~JJtWWu^(!`u zu|go%@eJ_jI0cgvD304waHvg_*G`r=e0re{bthF6PhlX$@mT#%J6gJ&zH&ZoWRRZj zK0X=iHNJ52DUp3u}VGa(x;<(fdyiW ze{icB1H>F);mM~+*#h(=$G}z0!D9mQi;NJ>r*YDL7YG-Hf+P#_51kK6D5VY_@8sT( zWq&Wl7^VfRnV?Hd1G~H(&eXoIxiku(0>F3xsy8Xdsm+Tf7KNFQLJ>^p(S7e2Ct&yk z-Fm}+oxTTyY*YO*CRte-h)amqBnWhQ096xd)krl;{l;SeJfaM@NAl^Ws``*}uN;Dx z>y#B$Ulv+I!8@;MulhAoRW(=(Ri*)Ytg-@0mLW+pJb@w08mXwL5G6fiEhI&s1}y8H zZL7&N=!BgLsEXoC;iUfbO`T9ifV2RCR|(js=?gCrtYs?;EFWaJ#RUY2uvaIAM;GidXE&NA?2n6eB3qsaV|4j1_3FF379%%(vUNzz5x)c zzB>8B`Zr!aW$WrY(xkn)38xS4!z)I(jY;s9lZn}!g5Gid>tg4 zRqI&@0af(CS%2XR*=GIys8wwAL7QqW{Bg^B?|#`_bD__Nl_!tG+*pr=%WsLu&Qdb7 zF!!3}NaX}RZ*r}_jZk^K8vu^Y%HY$jkb@lS!U3>3? z5pj>>4F>$%|NDg?o;?Z47MY}~2o$!oj*kB@T;V%D)#N&MX93Bqq4G~zfe7%xuU&uH7>2=;DxiIwkaaV zgHnpKwM_>Bh{LbeB>^`;JPWSBdDsORqM|V8s%sHz2>+R{FgqQS3UXAZ%Qa*(z^@zJ zE{C~j>U1?ZefS-lGZrm{U@$7(X0ts4Rr|W2uKe)6UvGK;offM0eJ(%sLg!ZFuds zb?DmDh2!V7KBScBXsnzQgU50S8jn~pZ)YvCs%)6Hu^p-unl~W|5VbZ2{O7SqypRo7 zcM1w!8xSkk!CF}7Ra^*yZJC0E%`CbXQFvyk=nhD>ziyrkWA(fEhpPlVM2^P1hw;w4!MS)ul`)8a zoSgXddFEyep-uIhfy?t8PM;}5OLGfUSq7zk*#lM|z7Cy`1T^hXp5uImX9`t8h(_8m zMElVJ0QBMJ{TYsF#GN)|zBf4+7%a}CYQZ9fLWf=mN0MLi+dx=c%abbyeJb0D?&vD>5whw{GvO4+6YTNWa zhJo{Zh-1qI?vr>)RYtF;UMAxwSvBLj5JqyuAB1Q`I0FPNXNg8a`%LOUd=ecj%lPL> zKz+alZNm_qFb|yXuW!Pa@vXI6((5DNe2^YP-!fE6wd`9;gS3sk=4J8mv6xys5!YRN zCHT-id*ApBTpgCqj`mKLVHQo9JulXqi7ZPJwyb;$mtC=J&>BPoA*Zki)n`t^Wp0Ki zE=6;w9|f>cCJ;*DY^?2T=0YhPHRr0_E%lEBxTJ>AjsV=|#)fmE+r4!9g2hSRUTuf1 z8{0lwiDh@*i@}%_Tnrgw^3hgb3uj9sY>WUdcKC)^;eg?JaB&IfIbW*j9|wS{3LNK4 z4~reGkK-FQ)NR`33;*+hXMXljVrqKCdZpqLlE5i4PVU@>=&_RrWr!9EgykTlWQ-TP zTB^j(_VNf-^Ph#x>+WCi_Od(g%^U7<@q!S7iPL9d|N7OCjVAE%Ny9GFkeV6qv2~1d z)}CLBOJBNzN{Z(|cEPyYlF~8~hEvd|AFOOScCIReumihTiXCnLu$3MEAuciEvZtl{ z%dDb;<*C`Z;kzS+z`K9^UG0UA?tF5Q-fGd@{I0#?bl4hiqYZPr^UFzNGnbFa7=&9? z2y8oi=ID?9{LzC>r}G;@;7*;p;Q5E1`_Fq5(;{=-k55j)`T7Olz@O0&Rd~^H*`a{N5cisQSwfC*aj>L7J5Q4%fQ{$U!sxq3Yt2W^hyAF*ML{Y4? zb#`W^kI5^^$}jZw7<9BWWADbbxbFT(Fx*isUa%a8)a)GWUcVY+i>HV51~~ZXI*b#W zare^M;5iO?nWvOjc8ktg6c;!5|lT& za88+oJgE`x=+K$llm++}0?HAnx-ATk7%<@B;cdu$HwxUdT@7a|Xvr_^$A|R0?w7!2 zSr+w;ji{=ug4^SPqWU#(p=aXqoJN3B5C}YnD2@do1hS%nVHi+V1<$b{l!EGHnWCz} zS*Zxrxb;$IUIVURV$SP*uxF<{1VI zL$qyl`36?&ouT9ls-3Km_Poc+ZPJ zqc})rRx1MT#Z7x+&*-(J#RJ1%`C4Yb+>$Rp6+)uui@++bQZ1PIZx z%6qLBSZA+1NXYL3uY5u;{?$w18U&=JrQ({amtfMwqW)^}uR`EL_IS?rSgpBfx%nlT z`2`FB?BB8p05ES5PR8MY~Z7f-TdeiFBZ>T5OJ2gaN=ZC z?B9)!j!qae!*dfJ2wY68L6wwZdwu06kfg6GiOwy&;g+}W`{A=ohhh{r5Cnq}c?AX7 zyLJ_#3MLHyH$w=FnPUn>n^pF-HtvZ`Ek_P5)z#g`sF=bFaYf>&7Rj@ zeZ@wM(E~bfDo$sk%UpAh+}(Z2>0ozsG`S4M=nG?~PP^S0Z5onreEEqZJ!>|7$}oaq zKp}G3ZYj4`)!z@%e#w$=O&uLB1J6~@nmqQlm}ujWjz?WfyY014c09K4MCm1|^E+7N z42lO%5{{oOj@tnifos*V5W|sGz5%3f5*FW$mqDO#u zA6GmBg0XMX&+ZLtojcdAddb$=@j*m(`VGXXQ|i`#yF03&P`1x7l`>d9qX#i21>2kb z@84-gihqA919y5XD5@;Lg8F#Gq;-Q&_CR0&!mCh?z!z6fMEn{fnC|}H-K|^WqRae{*SGjH`wN~i!O1V)|*%dv1vl4b@b z%DSE`fsxn9QwpldA?R6)ni&-Q#GI}ftC4ZKKCSnYAOk7g@QMMz1nA-hmE<>?0)qgS zPX$p`T@OLqhoUHOxh2T55+u_Qq^GL{5Uc@)SAm+m1Qe`~-R?zV5^V{~Ffj1ECT|d6 z#O5==(n)QosxR9#NZP;`EO>?m$8x@5{JsoT@82w=XSc#fe*4Ycpc}je(2@b`5S=*p z>NPM#&$1>fePpv zw!!=I)hiT<>-|a~1CoZm<`h8L`u?YYLN(&P?@&7emgQiIjz-bgeB65Tb%>4a_nqcn zhQI|tt)1U`CT-eW@);fe(4wB8HIP0q3lpQ^0XNb|O+r@yj1QUF8;{2ec5Us-k*Y8h_}lIUgCliV;B7nUfb1Qqoh#&$w*f zV0Gwa(S!f~+4D7uF=os_>rq+qxLO(?m)feo8dhaT0mmw;FJz=7q|Plax||tgyO3lB zZ*SQ3-!HD*@b?j_-e@C!;Z3)%y!G4PnLHE|t%1NWETXasaA3za%%6}G);2NGMx-Rh z7M`tZzR+y$DvM}^E)h(;Z1&^ddip0%XXY0~{JNi-l_NN8-IHr7%Rlot9N%OkxIj2N z&22T3=w32y{^Eqg+dhM$$e6$U=7=Vbc#)M~h>GKfA$dGLqh7bufxYj%jHj=ehA|nz znyp1+GO*`(1w>g!VYXj>n^KBb*KV_}+P43fHizr;h*$K|2DNsyAGddP&Y#qqcwe*> zW5!R6=+0u|6X13_LlW<`XUnnrIh`s1cyinpUkBY!pFS zXBiHhPeNw$7{r-8$UasJVv_ND(=OJ2oTq;fIXg$hJsi`8y)=~ z6DEYA8C9WFD)w>Te(9`vILEtR0$1CKiX%r(z;3gH5)}*u6kWrXVHgmG0i_x-sp?v= z(NRV%8|IY)A?u%sstPf%Ed6g$ z)pUL(RW}k-6>U4+7|d%9<}>5cm&sHQ=zptvy?WPK^=lA&WCb2cGbfXD!!kJ_Bt?N+ zlp)EAmbt9@P0AG2zm6m+P!+HCaPLrcHkbsE?0R;tN;TsFqq(t0bi0=}R#nC?y7@MwWse-umRV4Urpj}0HrK-u6$>_cz~rEafiW1t3Id$9 zRbY+La8{o!cegcu8^FJUaYP{G&X(rWU9GKG*}A$?mOuDt#D=PcLP};fY+aqOH`l>N z8L)AQ|DV0@4vd?;-+$gA>4x{-Gx3O%5V9vE5CS2D5LTfijIzrpqZA5-?v^e(el4Yi ze%n$?Y1u2RK*CH&$lk+__ujsJlHT7R(hWO_W3YX;15bFlJDsHWBkAreJ$l~f8MeN{ zK^TLQl!~5x+reZ7j`DpU`r4Xr!O1nmlT2H*_?N4{^Sul0(J{m3D{Hk!Au%o%8(x12 zw!+dug&G0|DXgTV7pWa>P2QG(=L@cS>W`099cXOHB_}X%_ck{^ z-Lr4o_Xk(y@MFhE>(`e|o4GJOH?LnJwlDthgNF_@di=#F3Jmo%*Z*Z$;R5tt+Uy|e02d>uU z#v_`lE}T4fLEOf-*Fe`)%w0M>#Cv*PKK5+d2-WB7MZ7=t>!0o2vTp5{N&!6>{Pji8 z%k#dLH=ia;c^NI8`1@goS89yYq+8F6Le#bvJh9D&{CRP3%-11rS0L?@VV`IWQ1Tp! zf#a1-^vu%1xQ@(A_akm$J?sJ-pp?;{{->Q&4KCGED|9U@KreH%LFtRD1@k0fJTm z2v>6o2%#UPJOv>j)M(7CEdUWTKrjer!yndA%?e@=x#Xy3EbsUGdszr*eTZpe{nUIN zQn0FhtOqnRY|gMDKv4A>RJEGN%m}4JZ^f$?T3*v}%z(Eb!K>;}H4#=%XdcZZl2ujj zO~`72_YGyXsv4FP+HnY6AxQ8J%uyB#BJ`y(>@j*1ui*`*`nIo8M7Tx6Q4oQLz)b?( z>@%QZHdMWoF<31Mva&L;Z0TZTXJ_{J-TSf;xX^XI%GJ|-&YW|W7fe0vjA0{!0OO=6 zBd-95w|t78`dW~T{6P~!1BINJ0#8E?+%<6?mtgL&MpL%2RR~w5Gd(6IciU5l&7KQjiIS>_|V*3?V(I5FPJ!S zr7bFYKtC82dv`gW{@-&NkuCiWDfc_O5BsZXzV3H*jfLPKO{Z)}LFt5xqGIC)^gaJ{ z-P+c--v2O~NOHg9y!~D6TRWSpuS8Fee`rb_esp$rs#IdTCXdU#Fd@LGoB;bOYa9Ra z{Msvam)A57cYTpS-h>G&F23=OhYBZ79@gLenoE&6104NKWul(mFx7;;*IDhxKBqOV!D8H`!kh7__`eYBq3c}gddC=$aTz$a} zw?wCA=MHOM7P}o>lCb%`w*d(Fwy(!+D^CYM&i%e3cu763;lKz~V~t7=tuTdPe~{c{_uDy3ytUJH4ca!qJ}cz^MK$QfS@TU0dOc;Se$!M-Q_>9OvU>?*eGC2k(9u zi@5j#e3sRWzv?!qoqHiG1pn^>8PN_eqFa2ZDoOw-;Fzaj-e0RQzNrq$-A;7HZ4Y z06A?Ex5s2%bu-+I_VKL^JKl^KpFc_BK}(6=A!?y;G)n0)ZX}olJPG@p1)3Sk79j3* zO$2Xb7@s|39?lq|qmA&gWlPV5#nSJ^@RyFj<($u-b@sW}UU1zv6BzF|^JPe2wMRi# zEZFqwbE?~~5^Gl8u#(0>5CTg^4!U-I*5+-jxf3Us8gsyiNlg6ulFP2V^7NIL*oNbd zd0%izMsj*4K795me`jkmjT$$BoJbiqRIsFF!c}>&(^GfkHvq;0VKYz|AzGJQo)?K@ zNC-jcsnhV`^Z$Vs6+a}QbV^D_yuYh8&sBB!d5nRJ{ox3T>kl#U34qs)?eDLHy|5I6 z{mxJ>L5fW%_O`X`^mnw3`kNUQdv=t^C#NNjpK|Kl6WN2PsvkeT?>ptH#oq7T1)=%< zuEx5X-L;1{4Qa8%i0XZN8lq$4SkaVei%<0T+3j@dzxv6KYlPL_?=TwO>+SZ}S6<<( zt*#i-Vk3Z^2P*3mVxrmXN#hqEk9Y~dT z_TT;3#6+fPYUz=K`#x}Wbu|okf1?3OnVHw0clC8kr=PJTB6s#vva(TiU>~-={0x4w zdI^%_`X7OopOJ#?2P;wE(t%e$+|u;I+E4Fw`+OTCQR`@iv%Bk%&+Wc?<&C#QrDT1s z0TG`YR(ljUm$2#Gw;*((zx>3XpR21l{8NnnVAfHE#%iCdy2}6VN!*3jRV25@*#TBf1Gm?G6Zw0I}%Up)Z5~=_I7Q zR1M1qKunhlnnQ-;vlM7u3Su%kFd_W_VkHM0+maFWDMQMqKFDkAkexc@3>PHoM|`sf zjd{oT9_oO{P7$9Zp=QT+tku4W-CG}nnzRr|n2H$39^94H1zFe8l4VD$Ee4vMKyV;2 zw;8;|fgR_@!|j*QvSSvk1xI?Xp8#?TLw&dF{M*Ovdv~bzbH4;GAp}iLE!ey706ZQq ze5z(NO$P-aOAH<(lt3Z`3;-2?M2y$rBrgjntc4MP7ur^0HVV#2(6^T}28l69oI&Qs zqtPfh=TIcce9eus@446ouk(Oa2QcCiMxx)74F{{xPGjiD!h)|6 zMic;8WKr-$atfRl51u^WMz@3E)PEPllf=++t%~kNI%;RxQFx>UF+CnwK9%w5vTW2R z$SC@;Aw-YvKKgW0?UbQ)Dd_nu8M;#fp#m1g3)h|m=x&Z}3o_u?n2Ox}ov5E?gKF!2 zk4&l~(9N%BevSug-}FGlPX{WV0HVjiJ>d~tX?YLc3?EvOqTseD@I@InbvrE4@a#xN z!oOn>`&*7@x>mxMt06TdacU};iP5<6 z$hbkc27QTx&9s3q)zC(`UHJQkvN|v=Jcun6g%)zd)lBc(a1vUg1QMgLDiYFCk}zpP z@vwOGjA4+R@x|X+e$DlB({l$uEc$bGObC`=eLc<3%s|@*Z$kG)?mX3&H(rXFGW#1m zI(|XKIvpLb7Ehh=qYG}hWl~gZT*Ny+ZTW>{+O+9t|8yPH?#_tyD<>o)an2dbENPin zM6Ac2ym3hPR*pZ+%UtBj<#^ zw;e6-JNE5(c*rY^EVO^T`u6QR4^3#oZnz64$4xtwOr3G<`PbaABGSM6 zPdZ$(6Z_qinD;#=-K?bL;5 zJQT@(M*#7qGv@qw#dSB2lZGKQxj)!rVsYB)8}XO7x5DW@@wG=>v>i8HbQVd9jfw{_ zJYE4~2%PgdljqF8>GTyBMeO@c2*JXYmmncEl>ms058Fu!|91ao^yn88UHGn>$+6M0Cb$cwzqk+mr9zX`PSb?N}akxK8MBA%*X!=_TvLBm-#GV-VEXO|- z!pGp)k_>N;4TS56{bo6mzqt=eZVx<_(a89Lg5KG@hNN9K*Bz-C1?*M9Ff_muBxMZDuTWWv00BaG5e@ev` zWh$y;(xKM&4qBfHy_5STwfeRQP=FOjNMMrxle0~+Gro$pJfEo&1N*M?t zP*oL_QG={CeL@4uM$HVI3RoGCfDJ%+0|6nze2tJNY%hab5>ns7pwt3qOadf0U4?)j z;hwI#;qeOH)itQ92Cv`W+lw|>mq9FoQm8;M{LB{!IMYQa^h`Gb&wPQP zGjl$lIn8HI>m8uhyLojDJ~PzJuL<~c0iULsfoNvaGLP|XZT>$^X_X0VxY3_{Zl z-(4d-&950Ayuh&>6awBD279lYa|Jza&E+ViVcxdk0c7EXZ0JTo?@LPKg%s`yCx z(1t@+EXc~u$L4p|z}@43EpJ@J`nIHHMY|hn#(SIUUd9+uq74O-GBa;oe%1BYO+RBv zWY3mOP{vSDG6CD(eG46R)v%A7a8$72a6wK^SN!d*MXu_@Zvz-Bo~uV8DJiLF$*ODq zH0SJP!y2O1A4*P{ijA*42M?Da#U&1UeM(|#w7;iqytCrKa{xx0A7?~@;`)Qt9)-9l zJ2tL)8MbkygZ|DC#vmo8mU!FSD*bJZyN0ODVMF!)y$$y0SgmC0j3tcoUdO=ea*2n3 z`2A{OwfAeDsQY|wZ$s5L{0(*chPT?`Lw!X>M^sEqPtoM5%OpkV^&x0$Zub8155H?8 z7JFKM>(Jb;HeX%k*Zn=6^}}23@Z(T*b4Rq*=9o2U{4zzBdhL&nZin~r=hxl*uh-X~ z6vOzHn3!=(FI)Y`dCOJ|TZmSFNGd4Cnpa-Mf})J$`h|vrGlsH)ti1hI^(e1x8jB;H z$h0%g{Ke{f9vrryxc*>^jv*GCy{NA8@Q%*r=0S(*j6#s?qLK$Myz#cLl}?`(8R=~w z#3!eqrl}Rxdv{`HN!|(PPfv=6u8WMlN9wvedYoTo3x&jqGv_|G>YfLt#U>?3v}0MZ zAU(ezuKK{fjMj$w*D?Ce7sm|rI=y022@X7XXUfIC{1`&2CH(jwjrey;Gv;)~;NP|; zyk66a%ls74Jrq7&hG%0Ue0yWzf4BkdOPb)(;}P|S7qa7M%7n%GAp8{mB;d#sUc|o1 zq3@1DR9Pzs6Yw041#t!bY!k>e6d9g2G|p3?+W?8Fn7z3ImQD@XbsgAItKoxvJ#eUL zK1fKCV`#-K=&L7ssC(4lEY7!?Sh$cExQ zXkQT6g?)Kh7~x|iNXL>e^<&`u0D))vz@m>gZrJ<*n+2mU5+s7d{Zn;fkgS4)lYM4y zraU;{ZORw}V-gtWM>R^RK?<5y4gnI`Aag?=!9v&J^ZViV`{7en_%$E=en0%G3cspC z)l?9OATdbHbhiMZ9UwBfIn+N8=tfLm*8o{gP35e_LgXS3Ors1kGc63v{U?svkH$a4 z@_-q>vCL4L2CNNaMxk&9nR77Hl0atMuqI%}bjf_q7zJY-vcw^C2@01WOA-`Gf+ER~ zB^eTzAag0~kwfM(WOH85I3&V?77Lt*tPohBA2WWAn)TZ)Rw%LzizGvlWmpv%c8diz zMS(?@VUZqkG5H1RSflTwAF$ro5g&zBFbh#jLizG#foUV4bf3ih_>6I z$O^0$1yOc8k`m%^_Bm%@Tw&fozI$I50ylf=X^Z}}>e~;LSfipwtcZlvG(c0a%Uv@^@)$DCQ8H;V-u=%% zpyU>T4z?CTU`fl)*Sfo?r?FCL&pQ6654wj6; z`_1vFXbGxsg4$U1vg&q^`o#FXn>T!#Q#4^(PEl_QfnVK!&z^P_WhYXddYWo~?KrgO z@nJ180@$}@)ArQt-0=lvlO_j76A2;k23GS8L8iWF3BMAsW|ZIN0?GD zFhOcUY!sCkE8csgep72__i>fdqY;q`it7)V`GvNon(EU1TQLD%&$e-rErfaDYv zKXl>E-@3G9+RPK*$r%R3C#OQ!wXEtx`<%}1?hPYR!^wiiLt<~~%^CGE$g^_(`iqGhQ2qY%Ha7L9lK;ml?zKGXwtC?ED$y5P$M+(iOX zD*+hLbDj@*t9HSb)`Lzp2F=XBzYp0&eM9*cx4DiAxP2|UIRIo%0wWeghb^&w-< z5ip{mJ;@HQg(JJF1C`?vv43J3l)@;uT{`xDv<+n1pMdKB0ICzvy>PnRm}$#KT$vy7 zZ7%4PLX#-yRy!(pOv1rC?4UQ-qOf2$0HCWy{qGH_yKWe+{d&SXQnD-~D=PzBmcTiK z5Qc)3PywH=K@kF+07B@HxCEbH1Eq$1QBzeg&cV46&;=oaL~8FL=7ueUE_z?<67)8J z(ILQu5gQg-oCN<*%up+z&>;vtdf;Bz%2WtwVbenXyx|21P{G2&vJfPX!x61Wri%Dz z=$a13D57NEt6IuJe@qAn2&IrrWio_eQ4t=J1v4~DktHz70Mlc(?@kh?y+pvGO*aGO z`fj74lt!;@5-|E@)Uc8Op&=`Qu;V2FsHzIDs>A2kjQ}{42q(k{o(rgpon8&PuA9EH z3%p{);iw%$8P;5g07K;qZSg&n20@tV!8mEiUop}=4pF{+r^o;fTRDZDcz=uUs zH3*@@uWH76ByI+m0T70dbHJN9d}{-*bRi&V#v=f5&Y=qdMhR?IEAsPmFrl({}WnFl!`GM_;n9f!pEOU_Yy zoHx7cDt;T0PKOYa<}CQmMK|4c=4d#EnfZlSwsa|8`|xcfpSfbt0b9%-MdD{JxZd5- z^tPw+@cN;ta?nVdxp>Kgr_4Y7#8-C13_=LLanE=0y<2aDx495X%HV}~aZ~4(xErb; zaeut_av1l`M>F&fUj6U4()05s6_!oT1%P*7ezC5+wIiF!{f}t%ceHNo*}LsW5vg+c zA>RAffA7c|Up%FB+Kh<+@a*G%u4q$55jnwCgSV~erS5|}9*sni5rp{5v+M4dP>^-X zyiHbQcWr<4)mQHw>B5EzlV;EV&IQ-ra+bw5vTg*K$2D&ee?$l*rzK%JT~kRM-9F{Vn@0 z$JqHy4+#{-wsiWUC09&8i?T7#dI;k(ok)Gkj_UIjBwo^jgHw}maPc^l?ruP0Y6G~c zLrU_XJ|P49OH(oRvl>(uB*HH<94t*mT)h`9=^AWKAI``lc-CDDQS~%P>3tB}?lLw) zsCaI#A3tw$pe;EHy6L9n9!KE0(1q3cFQPsw7VWU3r&V3|_ANWFz%cq)45#ag2F*%MhDDK&CP)bk z63-;ZWV-@F2~?jCnx=tLW)6!th)1F8hKDYr&~*Vx3YG5n`-7&Xgb+A=hEmvOj{>C( zT;j0W?VyxG=sMg^CsfsM5_YCHZ?LSu1)_l0=Y^)JpoBov4F}b(u5S4J{=ghvT@cY#u!41=rAsivH6DE;r2@;wCs{&P3;dHr!^Xua1-a*A6tSe;w)PuL6lsfJM}}iB?zX;oG#%rgwc#=gx?9It0kf%bR`1#h2Zf zSulQNuXw_+^s-ghzHx)rdSEAsE;(h;za_SUlBD=aGk@7od3Z5^kyeGW`RA?p?fF;V zctJ&lcb0`Nqr%wfm={hQi8dgaA?GV=1C>uhZk z?|$$RA@=BgZE;kWv&P%dc+&X6hGWaYgRRf4+kD@+?9^wyK2`ni+Z*pZaGn`Ex28njU^}-R2uH z`oo{-yz?&j%>~!pa_UIfiuFZId;-q9`i6_U+M3tx`|PtPN4lON052??^w5fL+&Cj4 zwO_ZFh#@^UA2l-;<1ep$f_pDJ%MiNtgK^nuxaE>_PH$@Kx@Ui7{mBxLI1pq{nmh0N z%dQ$7#QTctzgbvUarh^@KmFuON2Cum{(fckFO%ol;?6oV;k(m!MZ?j+u&1*KX^C~% zGb&<931w8M`Ai$4MOKLWUG0RXnPF4TI;ps?!Tb}6wASOi0NtOao$Zq%#N zfe+twocrvv!z)-A(6=KqGXrt4v1o5;gGvYlAHf+an-6^b7zcK?0Km$UlUe$Ljhym z0d=r|fNuKvl7I)R*+)R_O8`UN8t|y?LyGDqQ%HmWGYRj&3i|E`MhPgP2oQ)Nl2Jf6 zNlQ*yFVdTY?T5hT6O(NXR3gIIN)aF;bR*i))iQtZf;A6$Q35Z z4d|Nb+pC-Jnfpc4gGVE@KE1aRJDdm(D1UqXnG5V=Q^89K1tp<<5LkV$^$=p#VUosS z^Yq^K5P2WIKZJQ~bxjXnz_6KM42ohwYFY|r&z}BOcv%RgWi#j9wdC^E38QJBr03@2 zqN~4we?ImnILh}TYFt@F`X!trWzl)l{p~G3bC&PB4r6m@{c)iv_OoZ6an@Bc7oRh# zf)`@q6L7_?ci;~{dJvu4Hz0m`g!1GFLE^l#@;wdJzxM6fb`gNFaG@VNWx*K{4^uf2 z7~{C*!5`5deCwM#TI#EZ#8+AKd1I{^IX`jNSKmGq>-(Z8nL7Qt<=?pJ{E-NX>kkvA z&m^bMm|FMV8~^Lz_Lw2LiV_gl0r&{OsQ1Ht>2Hrcm6kv5tPel@V6twDKBeE8g@CuI z;pgtU!zZ0z;hLxZ_GW5c&J*vg`(Tl<*d{~k=R954b#F`E_dQKjMwJaXFk7Y^PtWr)Bf2}R3S;cxFeg*(rmGoWSC660|5 zMQ2}9-`w%`r+W@RH_Rmt3L_O1*B{De&WW0F=DGJBIdteFPghsPNY^tM#3UwOHuv1~ zFPJ!I{>ZcAVVHK-Ie4>tFW&uZ56+r7@r3iQTr^YJytjOHL(5z1x}4s(BT(W>Ni5>jr_KQ{YOp?GKErMl< zhR)emlxz@?>s)ZDPGlqi0YU!0tby$FV0&3Mq@*O&-3Lf+H@M3NSFw(S=Vj#HDZzQS z1x~vRTdN9cH7>1XpN5j1-C$^g&!V9^I~7h#3}Wp)Q2&*N>Z&BfcQ?TIV~#(xM4=$z z67=v?O#A20(W9EDyzV-P+Lu7a-3YPkLEK!V;r#5wcx%rB%*YE7xPk-i8Foa)TamcE zwave&dd5HQ9sZm713EEJPD(^_LINsT6(}JvVw?nQl5s7?C?~+tG!jE%v8pTz&s`)Ym_7c4+fDP2yir2DF3!&SlPWpNRvP&E&Tv2GGZg7%i;28dz=<~s^u z?5PNBOm7KoFZ+l-WrWW|P1W(Sx(TX!iQ$ghXA^t%b}a2LfUp}6$NJ4CAdJCgx1%6G z54qWq@!1>$h$=dD`cE#n{^l}Ubj(QCaunvByBvGBeTI!2*TIsO4IUMl8s)?kB+OcP zf!5RWj;Fcy-x29FGDx2|XU_MRUwcy)8>CuqI8Zu$7S3LIAzpg^1=z9+phU5w^G}~J8joRIate{5r#rejQpgb85z@RKP4oL3hoZK@ zASp9*d45URs7z2Voi-!=?X~Y&py^3Nu|Cb=IDoM;`arCG{^h%yyBg2(GuCf>IMIpb zD&O~7qza2P);#{`1MRv#o>1Dq%7RkW*U+#(LS>B@9(nfN`)X@zPnsLBQx`7&(aIZd zn>X5i_meWR(3pJ+KHhT#^UCrEw9MjJlj1h)I{3p~N9sRzxm*pyT;dmkB{sHT&N<8O zE}AkeG9F%^1Ls_ERcY1!J->PX<>xQK*cBO+OrAaeJ4-IVGI=zKM*!ny^xR9X!qbmE zjMBVxWTo^!Vv{q5JHNgxbJyXT@4xxUwmksqB2($eASN;KvU$r^Tu?T9-l!tpXPeruoa=q8t{nkj=GuH9zLlxhg_p_+D@$)(^pZsY%>JLtaZKnj1QH+|uc0%rK z$AjZ5@aGi{bhoD?^8pLC)OzsO#~X0TRjDA0n^6CP7r)J`!6n{goW7$ScDE0zPk|#U z3o%+HbZ{{E!Gs6Ss3_!DHUNG*v=$D>mSi;D2ppM|iUTj!Vzu6mZ1NO@?G&g#I1{gb zvJD@s?SRiGfP=pU&Uhb|ia){H-G-Y!_2F*14Kb5b(4F0EY!CzVEGycr7WY;bTYCS! zEfEpy42ZzBTCK=PO@_=FJd}V50!5ZVi2x-6L;xx^tP~if&@|2PNcF4msYjpl^-_gG zKZz3;1D4I`o0_YO$LrC^sAt4kx4JVS1=Kcbf4aX+!0(}dE zyw&?3DJFD-3`S^^!>cigM0)f{?f}7PS_E*$z$gt7n_)C|V18W}ph1c7(M22Ntq8MH zKp!GAKxKyQ=RS<72v{QY+LrKnOyXP+9B=ml0g@MCjCNQdL6NQDf7^>b7hwu$Vt5DB z!1e?e4pSr(8Vq|2U-wZTkYMUvc#-Dk%Cveo>a#=%BuPR-LL5$+JOMV_$a_YP2BhWY z-?ZdwtCkd$O&;k|jtRy%zIM~?D8J)ow60%+)N?OIq=vD@Oqw3+syckXr@8iH0F@Ex zba=t@ipw56|GJx|C#H@_aP@$2&ev9B-`1@-^!^&8UvMR;JS0NS6T+4^UWz?s_SL@D z*0)r5&&Ltz^b4ZBzJ9~n|NZ;Fg_EY-I9k*X0lf6YW6n06*`=76!C#RH0e4;18@`r? zUkyQNgTnp|AK$(9*{4gEuDWJ)_>P!xJ01ATuO4nwGICNt2LIdW@9OAOyE^Uy&^Gw$ zB7?)*K5PN-^hnn+(r9XGast>s(shg$)YjIzN4kcggkn+RB}ExsOqU5cDjJUNngP#G z2tl;XDn(0@)pg?8M+7lZQPK9;xKVl2j&li;Vu=DUstB~t0c-Kp89%z=awIIS!Ty~Guv+#) zOBHDF_;7kT!8JY)Ham4(GGQ-fM#UhlMS^t~Md#HT-q_uagPrXtt@9x>0ccP%5NC=( zDO5nH@W~9H%+H6-<;TLchoJc^AhL#x-^L`*+x~bO%7U;=9kS#NwM}s1_dppp_`XbI>{Q{?iV(L~0+h zAN=44KRD4$gb*}0HDk}-{cwA{pcIf8H3>EfT>!Ey8UCx94$ZV42!uri`L!@bW-o=O z-b-(Kls;WRKnv2eMiV9}8ss7cASfVc82K3PBM`7SAQXxsfir3-hY2zKQNx=V#1(vx z^lpq&!xBN)L&N-!)y%?7O>1y}1$y6ln*74wSx!PRaomy^b*}{a>v{560d*q&PwYNZuqmn%64}nnqa8&Mp z!rRjDhoPwLD}05oFm$LreCQ*_*qM`N&(9c5f5W@m+t9xL1zf#o%7CrOHts&;e)QQl zf3W9B?K{I<-WP_mr>Du)+0MsJKJ~QNq~uX`lKjqppQ>E@?7y$_IGv+Xy?i1hWoF*G z{Hp7(n|{WU$lRg-f=J2A!QKOh;cco$S^kMfgcW3_(vBWy?w%vnRZf?8cLYj|G_1v^ zPW!_ZcYk+bT29_b*K$l)?NNwJO3FC0e{XD8Ys;HB34Pup4E+zUYOl<;&RN8mKkM1D zLwK^wiM?JO4rW{yALt@zYnSn+Q^f(B8-+zyO#WIlNDc6RA2*<`%7-(H%kbTe?TBr) zBYkZlV*D+Tk~|>XAOM*rP1j($ za*%|PnA9W=K>(eG5usuK0&-IUKsPL8jjxqBx)A_G5a^nKuIkWL9YPZjnt-kf2vq=@ z05ly$HpAW;SjXHXc2%ve}6-)9U8=ZLac z5N)+Wkt8Ub_i7f&eB{P*7S6+(6nZXkNR&b*1Qv7I@IEERAae$rBn9WUNZg#4K{4Ow zVf8EKa>g`bkeg=k93^1{Ff*Pr8alQh2u?GI)KE|xqXe9BgM4MZ30KZoh(u-7B(=>x z2nky!0cQjfWssOzN1ykZNz4X_YbmU8LLd>-cp>mvK!~Vj#OOOQJ`S^HPR0EBGr?H@ zcT)S{WF&ACC(fMv*s6Q(pBkH#JkqtC5NSDiaJDvM&qwQF%N-A9jf^OQS*)P8s2opo zLz~vqHI|c2$4y_j_z#!gac_ZQ9sTO_*n~vL635ne-vCcchZH*`eBcQ|7>AOamhEY( zv->;S-i%16UmPAsPshIa#N?$pMJ3TAU5uux`2Nk;G^vT{DMO)>S6wcjyXNqN-uAXp z<0seJP`}ONa-DL@ywfH~%E(`LZg}f;?_2M_=ab?RKGz+|gdo zSDNeVK65!7Gp5Wxy-1SfkuC=SP`Pi9_m#i><>yrg_PspPwR{msk~C}fl4TFCyz$m_ zE{&Rdp~nOv1ZjmucyrC0C{2k%Qe6M1T7(cx8kb|+aj2?rZ$;fYjG>V%1A#%j-!STl z_tflM>gwsqtvR^A#^Z91dN2Pm0ADR>ee=Ti#WDMNoZUrLvE$$*^>ZyYbrnhOSZ$vE7Aqp(@U{q z21RR1G)Q$CylXj9msWtD!=(>Q! znc-Wji=e78^hm-~uLP8Z2t3A2C8hbCGeb>D7y;u9%p?qr_lzb5r%})Vxfe#H8VXes zR9Hg5BxgenLV%cxQA7P{#Get$y*Wg!;rm8wrO@pdw zrYc&8>Q{{*G1I<47a@KdFkbsr9ez!RUlUMu0aX+5Yr64VH;$<$M2I6dIrM-NLLe3` zU@1&Yk6L2-9uPvzWlWVaH5&;LxP(#=YJ5h52--pzSeex}=mRBm9j@}d&v_baAHdNAeMS;` zYfaV1gtD{CX3j|&NflgodmDc7-EX(?wCv=geVsl(eC^FGuKJ1_b&u!Z5R~^7zQR`+ z26VT!l)GKd)RJj4X4_+8NBr;kuC=dYS-L<`R_cJ}7ee4?e}8f3W6!;P6@aect!_x5 zH8s_LqR5tWN~g^n5|8o0!0mM4U%&k6%bVYO>pK|bLcHe| zmDnl|>?y1{bnv7j(nkWdZg-CwN7i5a?Tiag0gWn}EaQ*or^DUGvAx9s07$f1k(|Yl zyViooHrJ!GT}84Y@TUa{&`X_2O9eJGcHuFp70cTa5yx%tHrruIa6?bFqANKUTTY9E zO5Dh;Xa|YvMv9{YUC9=-|FIY;6YIcb6)mZ~Z=^7jJtkh*mui>IHF>FgU0j zHc8Q-mv67W40{S;ZmXv2&~?oSNDK6>=}^sSLYRFE9h%V1=SFQlRW;`C(~P=}bs76C zuwMoG{?mizwdnOakXfdg+YW?VON5>Wjw0=284(C0Bc`ndGgZEn^;Tmu8nCr6$>8Ar zGSuLKI6MIYLKq0;VWh0Fe$dcsN;wE+#&nZhCuTE9a}AoQBu8*NC@5#J+ifVDP>l1I zodwGPRRUo+sR&#}u`OG;@{;?{zT&F*(K7UUAdnRcGIR5=>CIQ*(*bKngo2m}fi*ol z(brg)?`>&(31jSJEIB>vmh-N;{`whbo^2WFT0RdbV<;#s!J)7jbM+7y8jhZ}Ka zv*!MJ)fgk*Q!=yDs`l?qZEI>cX^8ZZgw~|BoOOBP#)S)_E?Z#}QiB|W1}DeH@^+j( zejM((w-9i9@$2`hp_^x>nK3bVyT*a;Bc1q`y&DS(CL-e#3A1vuari|Q@zbi&^UU&r2-Ci6nGDZ&P?GtcYZ1CHSL1Tp_ zR!~nJ4mC~%jV;4#n_k1@cp%=>dfSYPcK+W;?Y99FxQsD0)Hh=PfrIe+e6U*-=z55B zB&H{n7o-8_NVKMIoR= zzz-c7bO^KQFxG4Q3x7w1$lYKX7QzTR1XY^7-!or>gb3&GtgkQxuY7_;X7A}jh@hV< z30oHpKAL1DF>C@XiV~(K?%gEQZh;e+&ne`vCYhEDGNa}^h8kHmmzNoX!YC9TZoj~w za0UxAEFO&4A^QiJ8L#Dly+UxFkSbc{43fkkaSoYt$db`GgZWAjQPzdRrU({;rM>BGT#5;MBQG&->-d8*j@P?RU(N1$%T1;^Pyr>CIQc zV&WkuM8@uePzFnCR=TILCduE?`Wi-;3bZfO?xy-pN>udH@sm$Yh;-*Zj|V@z_4-DU zl9fh=AVf=ZbUR$tm3L}Aoe>}AG*EQ5H0^VAb`?yTJ#U)TJ|yl1p9^dL{SU{+ox2H- zjvYLKECigD2iLl5kKBT>n`ZtMzQUIYzOJ^G?NPDu=N6PriXDjpRKFj4o_!p5o-_4? zio^gKT06u;e|`4<)@|PN+hHzm$kEZ%xXanoT{?Nr{K-m$EWG++_r{NV-g@R=_cT^l zjp~rq<3UmE=bXM`<%8$0{zd|&V`A`MFJu%JW8J#+^;nw{} zHUJotUd1LzX8!o^U3Bwpmz7Q*Tf}=}S~_%H_hpwrpi_3230b28wgXF6)8&rRMj z`*7FSylyYuxDVLg-i@!#NJ8p}4~-^-b75Eek144y4w1 zqk3Evy!PJlG^La5m=fKC=UZ>WBJmc^k8SvA)@^t=()%eK114|*pvU3B)@?iBa=YPE zRcM+HT^EoU10fW;Fm$dy)fl>e6v9-DdLW1_j2sm-FoUU5r38WqfFY>B43Kp}b*D+J zfm73dArNR~26_b==Z5tHH7poH0bnc`S|xMV%L?HrvXmP0$R=^hnd$v%z89K@LtzF1 zDs#hQHb8J1%^*o_k_4;7gCwbyGgu`Kt0ck3IcyS#U6Emxq#y~am`!E`3Zt-uH**~p zDd4TkV3mw!;S^TRVV5P?WeGM(f=!lSlR4~)G0iGTut^+NSqeB{?)LxyAOJ~3K~&aa zlOX%GmZfQ$H26~==Gd4aK?`! zb&Y0DXAH6=L1xA}B_7toUrSPO-Hb6Kl#Eg^ZU&Sw9(+z21u-8fH|7m~NdlyD;E^*} zEDAES(y{XVrASWtLj1JVy8fq#vmvdByQH*53)*tTwc3Zty#4*J(=r5wsR5&X3|I6E4H=-w7 z13`Ud`A0(Niy|E&*Hm4JKmOvU9a3uckPPSbwKUXtYiq93{GR%uSl?Ip3SVLP;p*vW zbal2%BNec<<&|gf_0m{mr3~zxTGcds@6l&Id1}oE*8%VhZ*{{0QG58%N0jk1C(oIe z9%=iW?)El3{m3t#-tp1;pJR02P(B{grz|-A&sW@Y{{(x?h}?4+G#KZI&CJ7^mtMxa zl5AL&{@tP^&QO$-p1A8!O>R|V%j+1MpL>INzwn~(EnRg@;#eBB89>hXVx{&-d11w# zof`psb)GW>c<05|LrdqmDz13XxALRbE&>2Y{0{7`b>g6-cmA`YP@Fd}2M4OUu%m;b zaE1-YN`ZTl7pJ^YiRLna=FDi=w=%r`Vh`S_ap2$E86NHO;<Haa4DqHJgP|?vPFW$BEc%l zu*g!dS!D?}MTS)|!oN6}sW@f95HMMiAcuv4Nv7)62)_z7*$mYRsZUw3StJg{4E<7M z2^NXNYEHAt5|lnISesd|O_pI*WZ29Ws9%u{!c{g2Tba{fAeTWP8_#7*48oXmlWYwT ztHv}dXRymM?6QO?B}CrZ&Gkpg66}f$i%A$8#BT3qS0pGB2WQOOR+G3jx7#3@8FU!O zFyKYZ`ZPi)RDqCf0!SbAEHf<>3|j+wjK+h+uSvL?YTbaff}y}Q$mEdiLYVae4J>0= zDiBj?O-v75VtV2V0Z<+yfEhPPUs;h66%~bvWhGd;WD)om8)AG?5V$dkiK~`ew)*zd zR$LS{ni7mZFBs>@FDk~SH(r6u?Sd`4AYy%6(z9bdjdkO_&Gj#1bf1iojNHQeFTCm2 z%gbiY8GF*(Fc3meIAJ2TzxNJWsw)sRuI!7b=)Vw@lys}Vy`|J$Q?Uj>XGA*vf*6T_ zt|HMbO>JS1{{Pi@5(SLLBA0k}^%^T@-~)zNh*Atm+fobkmG8493l8h&{5 zwGF09T~? z9YXND;h_-KnGvGC3Cj zy1O*gxqQ8662R3rr(@z=3)a8W0U?0W@fMu+gdN^9y&zpWSiB$3Xa$MCvm)1T!G}}* z$Xjeh!Ul>;#fy9^!9rLeB^j68@f|L3O-E;}{kR0K&UEDLRbT$oH}74IQEiPBbioZKO^*sC8y|dw|X8}7Z(m@14r1#zlp_c&Zy=POl?@syr{+OA~h8oCbHyh^Z zV`MWspU>w#Gs*7EYu=yNyD`($-9N)1NXN-pzZ|PrAFxW_vbd>d7#J7^Izqq^B4_y$ z1{@*aK)@0}M+gjxt%06xnmNqEQ_%D*q}FH=K|nw$Q9NTA5U8R%k^o7h?&5GxmlJ{@${x%f z)*UR%A|j$A?z;VE^zPN;TL1RigMiz2#4UGx`QURecQXX}#kSF_gm;caXmBu&Y+egp zbUbw7oqRGb!|9-picNAsW% z)iD{3Io5`T_Zd<(YsfIe^SznCjZNj6X{&@2Pe|+ht`yc8M z$jKurUAp%``k|u;bDGdS;mUrneNy7Ng7WH=V`uVC3X+uXgAlz1*R9{cDSv$a<=>_B z?H|x5El=;JL)?H!%|R+UQr;%+*{({!|*LS_lmwis>!`fB^-elKh$|CC!Lj{z{^vQV>m9Ai0Zoflxs8-Bray$njCgCc0{2 zE?I1pf941S0$ChXYkrX?|531zgrW%MN!3|n5f3YRFsdeBm$BWizvd$3vlp){IeuM66F}x z(W+n~=S=Y&cAMSG3Nt|EeO337Nb>IkQTk*l1*0r11Lzn6ND?GbE~@9Y#|43o z;Sgd7Lbv23-21yb5#HgNlcWM&zzyzw!|<>F^70##;<~2zI~K2z)Uy}LGS4FSa2mpT z_6Om7lYye^(21eE(4DU+J}Elwxjq^6>gY0f+=TBRe&yf&LwzJ{`+}H+L^#bRoZh(w z!O1%vK$!_2@Bt(yd?r>0hsRHv|WM@(3W$I*v~1 ziM1!zZix=|L%z$Pi7bO$StYd2*B){NLxmDRMektfABB=nt0zI0(#b_ zNl^-<9}JU2NB)25W5Ag@t)?K3b8 z58oY+ltU);uPa1Imk*$;D8x^@OR(`^177UqgqaP+nA&2LT6nA}CwQ)p2z@6PT$Lf< z!g%{z1+l?c>eIwK9vx9I2u1dfqgrKgr4jHF2V7EB{ zDvM|=%RmrCS)>I3Dhprgly!BAJ0Xmc(Fs77K;1tx?y2mmAW9%IN~R=~tVzfP(L^ez zc1QpuLLpEJUJ&3CcsO}w5d^rD*LIgnUU(NA>c70a>Ue6l76R5Crgo06`Mnf+H`A z5JkC&8dU^Ok*bB)Bt>8q-PxHsrEr#-y~;36i=HtAAdtWTAc|-#3yJc-s=&-p2^^yw z2`UTGETLcluu4B1fl^pZ&VJ^IET*#ra+WSptqfSVjR4g1qF4y9%KJe&wz24$Vilnl zMbojeD9;fz7Dr=bO9wrph}x0_o5KZ2lDsc!N~)qO~Z2 zP{^+Y@`S|dgZu499 z+}40$7jJ<571v?;$RX!Q?8mX_YJZot% zbssQlY^xR6+V<-b^PcoWqAonbE7k$_f}B0};@rmpxURTy+e4@?D>)Jz-to>JgN8)3 z#sDs-6Yo9!SQ(8;iucCvylAu7tp&MnNEYLEFNCL|q2Wh-RbVSCeIJIA3XJTN((E?h z|FWrI?&{rtv)Ju{T*T>oTy<3yr#p0tyt7-s0j*}}D)2mhn)>0keQQ@e1%Pj@aaxh! zo`Y`q>fu-3yg4p8CGZtM4}wF(;9!GrV8=F07}(>A+34Y+A&80ykI%>}38^sFZ${gn z_0oITq+7rGI(1phunon+$f`7}5a= zQ8tJs18S1GV&Bb)uy?it93X`PhCBjl0PGIQRDPU4Wak|0tE0u|wu1c;Id zp~+Nyu`y$nQaGsuUdcQa)xM~jp-U8zP*UQ6EC@nQu4M=VRc7eWCdDVe*pF{_tQ zz`(H3D;5SsqF~hQRSH0&;0S{bK|u&L7!a&CAV_aOkWP;vy&ge&1N1r_3_3kRbsR#u z^F3r`4_X7uAedueVC2GN29||^mF*PdB4)&0$V{jF%MpNMluT&I76T0A!f&eO0;6O; zv!GxJ1*2pqtJVxURuO-db*v%~bC5Hb?G9eanpHApMR}o;Y<*zoc{JD@5CjRLVu|1q zMDT(HUKHVQ39vbNxOh4HR&Xzp+d_dVF^h_5u5Kqvk}@`hPAA)00FAnuk`Jx?&cSW} z07Z0Fg;{r|G$C?gF62d0laC>5&Z0!&bn$MBkj4yh1_pxxaj`M@?cKK_F`-3Mt^-!U z)#-Gj$K3IokM4Wo*)G2HNb?mT9XcQ?Hio7x|Jlw&#78r&Jicj{9KLjBN?vfPgswnB^ ztgcvzHhwczmY=g1pf?X3J3hhNMJK9Di}BTe->KEbCB=HY(neOz)n^SltA zU$EQl)ef7LN$K71rihqWuczUD_wK)|i!H8jHYm8oAL3LJVa>~2>Z~l8j5hMQrJjC*0o5fP*uvkJ<2MrnDF*2%E zu0ysgU0ASb@q))3Hd}FP^xxVZ(m>`$BraAQgzKnIv`);YeR~U0vZ;S3!s2Y5Zt1wJl&6YXl4YSU&|B}q9n+o=LIO%1r%^88L0r=+sfiD zb>AI`px~+ecfu%sw4M-UD!n9%po+*RTOBmsVGzjKpd5v2rh3u)N0tx-0f18EgOwYr zO#mXV3)brp9Mt%|qGlPZ7bgS&D>xy!1X)lea`r4yvSTS#JZ7l`hEjkKd7tHEQ1_>T zL@5Ntg+uZfj3tde#8k0NP+VmJDvOm2!zi8;vekn_5J3du&W5H`Z7;ue@&e3GLFv!q zOex3FC5W)tov`z&Er@EYK;1sHEe=X^aeNhA-T@uF_WSKoy|nH$^2zB6~3F^hi$Wir&4i+50xo z>C|WV=nw9D;+Y=pC+DnKKU%W;QMLE8crYW1i<@utCvFHQyEVGh9tP&_Su-% zM*YEUTVLxrWZ2>x@4m-thQU;lF!i+;N=a-|yf?&K$?24wrG?XZlPS#$;rW$}g9oOq znmv8|lkb0We@K}3YMLF}yW4r>wWIPW`_kC)4&$SvB*!(N9eN z=(j;3-pzc@Kbzq?uzvNl`s(WAUhUX-+%S0Dgl8t)`#`H@DEk{i2*y3|FxGzk0S2X( zqgU6{!QUN=;O znh8h;0c?#G=+N|g$eAQjGK25`)*D%+UfB^ZbJYTFcz6dSbcsV&W)7ST3qceVe^@Ge z+bTtU#r0$l2PLY2Z>vM_l;;)iNmKxM-Q zwFnl7BC0CpxrD;)TiZD0UWr%PAC?eE3=5vfp0%Lzd(=Y#~%APNJD;~CHW;{r*Qs)D~PwtJpQw-o}z zfCFH6I&p!v;yzxgRf7EbLa|sqo*wNzP6SnabwyEX@;l2AfMHmGB?t=-!?2-)5f-+(3Lyl)`Rn6RyVtLEnKMs=aIDWv%SF4DWmsLD`nTXu z;*z`le%x<=KPaqI`|-WK6eDiAJ!J8BU-b|T!JP@~yCQ8aW2K1%=}*Ga_GkK66y)sM zx^&^Z)P4hBi%aR|m4o!l_utf3IT4}{Gqha2r4+W}oGp&3vQNAaT3bLkv}OIj;=6V4 z_26?a5Aa47oXu>)^pD=J*2gC&dLcdt=6Z{(s{B0wmEP!2LqntOP?D9kVdKJiKc)2P z|3Y*^qSqd5p5D0$_x9?H=!oW3p{JDMtHtY2F5R;KWwaCD+e_fuzjed&i9LJu{QVQp z^!8S#4x1G#XMDHr#Qwcsd#g`h(`)Fk|NiEYCwh8Y*lufthId5I+waGM?JM!YBUgS_ z9uXdjS04V|kdjK{dk0TvKMKHc#YVnmmastA36?1f7SWHVUOmw(Fik zuUa<9nU$XWZhZbPj{y6`O>$$ zm>mHF)}vwLrk)wPjS{zKS8AGfW5##md$MnEu-<@#xL6G6+tY{Xd2NfD($chygZqoe z-0_!h8`x*hb0a_{vvfUXF^w{G~fr{PIx0 z;iHCijPyxCYQM2y%7+diymPQ2^2!x}y@g;kQ&*jFnP{;r_t~H=o;=D^ns&q zY|#x6r4(Ph{;zVOb4(29g+e)06ksdLTj;8-3Ygzt4GoQ}`CsKIQ)(y z=kg~Cg0QI-!@Fww3?1?IZy$N0UC-JCWa0fce|>y#RY~znxu;J2)8Fy5E6gzRg{}v6 z$%ZY^qg!*E1xXCj7B(OxvlGUQ;SpqYpp(uFWB(9j)pbH%a%YI3AU!PzFEPNBs6(9P z1~`j@fBRIwJ?X8vOD*N9J#YcQX0zesiPJEdEpYKX1c`zn1VIKpctL35Ln}$N(c4y( z;1YQ79^R*dC>ILjMFB3wOV`26g~seICoFb5%yv7hb~~&N2P_UdtWF24P6td*J1lm2 zu{!K>;WB06J$+WC#(zbnc$QogODV7=QrT-)6d?$n{;VQILH1&$f&@Vnn)tv{rH~n@ zEV?qFjm6ERrVA)_7Z+2Dk})94BBRAdMir#0Yf+M$jql!n*KFw8Gu&s{n3TerpPAz*FM1q6iEjqIA`PbM%4&&V!hn%u zIqWg_3Piib4;AS z!)Y~6AJ_vf`yigWXTlW=nW>ai88L0i#-mw9Wz*2st|u818<&(aHg&+DcAfP@DaD>O zD~!kX?w;ew)5FAc&&ge6z}P>c{bbQCxgG&rzbSC3Fr1MZ395o&Rw zI5`60*&>Vs43I(rTc{pvz79#Bb%H4(<&oQmeff(ocBv&?lYmP=a4`KS>T2uY;(53K zEiVWVCF&MQJ&TP=R2Ff0i3gQD3ypbtwaTvr^_7R1rwVUG^;KouF0JmUn#Rb0A*!5t z@r9_O<7M(GDd66&X)H~PU%6-QUl5UEWuRCd=vhV)BO4b&;4VPMF{*GYi>552im-Bl zFIMS?V;hBBRe;sAvS@4ISh@Ha$3VxjZZTHJ$^xxAzJX(*=j51lECU^5{2?OF0AGyfFDCd~4jaC{AAz(QcK|uy2 zCnezC-`#HV2o>m1VB2?Gl^Rby$42RNr|E_=pB$4L-7^VC zNq&W^qUd=^6i@kVP%q()0$Vdbc&93_wjm4%&=3FsAOJ~3K~#(l32XU9J(Xa~JGaVF zR{R>;sSj&uUd~=ZaLb@E;}fpsL5i`w44=RIpDJB^a)LJ=Qn>1jMpsGxlY-NJw#A)k zXlS%)yj5W9$l71B!6w|p`+Y6$Iccw4h|Ks}Ij{~q@>$m|3EzZu|%P{OM16xo; z&Qxo}qR&45>BPQWAL1g;eF27GEH67{Gn*z38aqC=rNVYwq^_zG$Cu8+>-XP?hz`wr zSSyGkKAf|>Xz8Z?FA9=$vXw);YHVin2~%DBy=PQ8zHgVfX3q3Ql|=J{f$&5 zl`~P~5HXO4z>v${d&IhQC=POhXXKB)<5d910E1KY$n6ykW1k>Uj|nAw97R>V^^M=( zz2e(e-3c#oO#&{ zf;bjIifF6nWU*Gy$=fibQP6}U6s!H|SO%;|wy&qZE+7l9c3!rcVi;9)RfSF21J~jb z!Ap`X)-sGN!YT#jRG(a@q=>aF3x;9Au$=swWx%j3SWaG4Z(WvQz_4;(EW?0hWdWCA z2^2M4@w)X`7}bVB{+W9E;SwTSZYWj_>b@|F$SYeoG;XWL!7%bZu^fxAun-I!&=>Y_cdWBt0Ln=x5;MvEEZDEn|gwwV7p_IhCV9n3|)@iJm(bB#&G&BN( z%95gkPMdxB;Bgasak{IwQYg*IM3=H-xMNuJtzDOF*rI(gJz(Htvo)AX zV-gc@kMEXx)yA(>lCb3KsfV`yvglC&)>eqmAJo*>)|hoV-S|GkMuvLB7rw0^iUM{l zn2tXVio*@PQkvav*|s$2%oW?duc&Qk3x$s_hG48HKV>zWCk+}qKBm12?>|oYFzwut z^k)Io`#YZYj8rD&lUVi~F_1r8O6t>5S@&@;jWP=baJ-ga;*d@-L%yVfJ^8m2J@|?8#fIsk3q{AWE?{*%jAqV{m?ME<9edguuWk;v#93h21eJ z_5`6i9rRpd2B}5R}Yk zUZUVd33gF}jThk%*Iwa1vkRaUw)}Hv z92F&x0jToLpjVB}SXG(NyBw1Sjh)bm^~$=6(j)trooh{8J?)u4|Gv{>DVB*C2EEnGCs)XN5VJphsX)n%w5&`U|sG*^8 z)rb{k#Rq~7hCBNV8+lcx_zs&Dc`N7O**k}UWt;cWm0MgPelYvjFAkp0o_|fzwgVb! zYjP|mQu^;UDF?T#ui3u*=V$7xsse77&*gC1?PshF^{MeG-EW9ZN^T!F z9{>(-UXQrC9Q?oAM>qREGqbP^?@V8^{m9w8SJ1YvCuj7FUo*}VJDKU_H&VR3;Ed=AcNI2@eun@RIB(RiQ@uFlwh{FbFkPfaO4)xXI z;(x@Q3@G2?YqL-w1huubIDPsI>^2)*f}pHtJj7Nsc}GQho~;py{!m9pnxa=0;S+3z(wWuE(x%UBCNa!8!rpKE=lg+ zB}s5d6gEZB<*9s^#!~_Ta(bW$22Kiygn;2#5RL<*WYQ9j1;cS*bUIL$1E<$Pr`JKR z*Fk5{L#J044mzCH%0*a(acP_njFR7$} zba!`mgM`xE-MMt{@?L!J_xGH?VXt$}^vq|@SX~L>vh;tbP}!K;HyAt2oZWw!%m0Qc z3;X15m@+uzTI+3r1c}{x_2Q_;!J!JFis#bHn8a77t9=S7IMiY=jeyrNuSdxIz3Rmy ziYL%KHP2FFT~98j6KDPDFn;bdH?Ju~Mdhg6U*fqvZH9IudEL#FFzC*vQ)2GcY-!Jh zI)oh)Z7Y5xaPZtXbZ=_uT?^UK~w`QGma;4o;9PO{qJG zM40*Os^pp?o((Y(AUQe;yK`^(6^{D&HgD?bguf=kdt*s}%EdaCpuE4}Ly6vzv z$Ho!rS8*g;$0VrU-GEVO<{G{Xt6*Y|^M+dpCxe*LU6YRW>FJ z=xIIInW%^**`WpZ7`2`SeZj!AT=~V&GWoNi<4Mq}H$rk0VZde?LtDX1AlW#e+a*Z&p)O#p>t$$R zHpd?K(BiJbaP!kpQfGBr<4()W)>b(N^mW8RGMN-bTt*=u74t?Er)+GjVy{hnVMvvw zSczrw887htv`QKW!F$zc+HQ9p;}{&s8IF# z^mU%a=kM2LM6acpLY?8dxh!%j9}S4<1-U+&E@Cil)DuvDHHGS731ZJ*ye^iJWfjZM z_So~F!dLjaWaHr^lAUeISF;-xv`CEfyVq3hw+U2>2FhsT@Eb!zwlg$ZcvDl%ES&To z%iu>8+Q>D0MPuTs$E|-k#-=`^5e;-t3XNBeA770cW}hThrz=MU_1j;}1r~2K%V^I) zju05_2^`X4f#)1qo<>N`^sYap32&Ev#Xy17!t(E1+ag*TBO@R*3`>NKn|LCR+kePX zPuLzK_|!ra5#6ntJzYDeZd{L`rTLx1W-vOV&*hN+v_aSN>daMS_7`1f;`Mb20~rx@ zx6bzEQ~X+SnTue_za8I(f;;OmHHL?|s*Ks;G)|@>nF=4L(B@WJpi$kb4CH{7sknC# z=kVvcx?AOXqFdb#au+_2YqNA&ae|Ci+PWF(bLicKgPPtC0=Me?>2;RB4s>G{q=+u7 z-qT*OwVa%G2SP=y$Qqf6-O{9op4=a{qHuzlqDi8L(a+)rUlyCs#FdFcB40pbxI(S^ zUZe|_)RR~*xo$`y@Uj1(*h`#rvG!(iURyKeUw#@R0)GMmPWDwu)#2R9G4zf`KwR0& z(0L4(rLe>w*_c$+J0+o8Wf9L$uL zNwujIDDi1hjI4l0iN0MLpXju)#yN-)B%!kKX-4&v0%L!2+;CbP?CrlQ{O2)BqV6D8zo(I7^ilLFzIWI^a9znKBE zA5Uo23HpmaqRwHNRlXF#)>UsZ9P{Q#-+)4xH*raYUUzjJk2dsUzsivP`T$*U=k9pA z81(bRcQ#)%%ROG+#5x$S#u`*dj{Br>&J_vN(Vhb8cRf9shDi6(S9HWSQ>dO2AMG=K zSK`7Wc9S*4F0|DRrHDQ@Us>1_n>$A7C;lg#sakY+gI|mZ^+@RCE#!a zHhaevC6(}|RWH4qub<_w`!fBTR*s6x-Oz1jU2>-jOG-rQK-1@7PdqAkM{GNc{SL(l z9*f6(psCxa2R3i=_{wD6+eEIrou{I`ln@vw{f72fyWzgKG1nII4EvE}2mLfIF6jl1 zm0+47z-b&_b$(QcC`uygv^aM==6zVc7Q#;3Eq7d-G-dGGP%~#%&vYsRn7Lqx?8Zq+QlHJ2e$;kYF{9qdp zNb`F`zr3naY5j@#h7Qj@#qDvF8(GyvRJ2z-g7K08=*2OX>nAvlgZ>Ol)^zTKr z;4)42L)S$*_^V$8xdme- z5sQq%6MbS+bKmhbh8eFlW*aMH@wrC5Rekh$xmAb1o4tOi24(vw9qWu>5~=;MbN_OT z)SrkmzWJx7vsd8DAA!!kD+U6iGavEoHHkA{5r@q~D7I-p|LoO6vqG{Nu^V$O>^WWW zc_!S}3$^qHeolxOE4R603Pd0eR@!>vNM9Y&zYvIbhC1d{RCpcHIFs=_!nC8b0PT#A@<%{32Jvf1&8Qc zKbfBOcR((w@!_~TmVd<^v8=rHOt4Q@p#O>_SNy-tVL3YJ@Df$zz+Mra<-+H#ZNQfl zBGzYfE#Bmg@Ra9TVcafuUg0fUDha%=kg-!QwWSjPPXf=eA;tc>tOcu$Ji0uJ!yo=a zNIZW>yI)p1jlgxu8VP~94Jn+*O^#hY1Ax?bJOFZuz!fswoAS}hmm(w)S&)~pJ7 z$1tbuBXGaS*+{=D`cIwKd`)GScq`~aoc{DHBFZy+H@Gh`C@rPha6L5&uq^HL?b^j1 zn@yJIqp5+vAt;fL$0KG9Mf}>F&RqwD`vs0G(g;%Kz%( z6BDDgt*j9ni54`Mkp7PKlexCZ;V<(vmPL%0Fq$e|>|;@PvsV1@hI5Lw_8$_(BAus- zJhUx#?SQRaQgriesNG&t(|gb!*NOMk&3Ald)=UQMig5oz8sd)@l3UiQ5ijRU)QOUb z@MBC#U8Ub=+1)IgbRgK3vH-7QUO7Cm&_1*t2&6@GE)?3<01=sc^EMmX&WXNznMpo@ z^hp@UIp+iukr}3PXi=4QjLqwAiGs-{R9#=b5KYk;d6D30n!a#>H`+S2dLcY&Tenv7_la$?-}&laP?bSV69rLkhM;`D zHTV($L*d`PGRx5I@Lq5I$pk@feMvgI?SJTdSwdc=&rN$=o4hNL@rEtr zG@$LLc%!Sx0{PuQZmSz=AN<)S=rO(B@nY@z&+?)+6)0pQX=S%#zf!Zx=zjK4@njKJ zC+>ei=nR^`Yi+Zfx%nH}abbv;_SWuFqNE71KY_i|$`wb--0or{Ki25Jnw8g6(L@39 z_k1&cJz1^5;SvZqEbsd!*Nl{wT%8%rV)MPiaWw zqa|HbYm)yI4K)5R{f7dJBlPz`wGLqm(!YO3%!8Go!S5CGK*3s_#b@oxL}r@tzyRkH zrZdZU=KdnoN`ag29tbB#Uq|KSv3!j+=$T_IUNOE6n?JcSf6rDU>jKKD9CkBtP458M zIk;Hnd!VT(R*`!rS2z+!a%#v0iWMGPt=`y}IcHx@(8P)sfCadVY=eEU%+&dGtWouS zNFe1c%FXMwn)evbMXUjlPX5=cQfnTr%?=7wDXr&07Rd0s^(k^8X^*l-{gUd_n#f~m z^ieb^8J-G)V3L=VE_0z5{O80fEgfUR?V#C*L698z)$JnnN~t$m?C$Q@4mNnv$XH#1 z`kzngy7J*lDpz0x2Jj`xz})e5c8+kp_mt08`05q4ppcI46RZUsEAWvv+ewdcM1~&o zIy-fGVW7pO1-4P7LS~mNCujk@A3o#yXOGZlzD^ zqGkecDM=+H6foP>P(BFQIgMU}UCXqtSIY3<^pF2oAMx^Dp{ucVEkm-$J3PPDEZWG6 zGqKHAgQeW%mnYO-jFP+_r4qWG`IofHit%Y3a(7vwXhJQ1O}w!Ct64(I%kbNRWKTxq zywm#z!=pUD_bf%^8?uf>w;bhaS*A#~-)K&ncKL1J{x*DVN3lDS`@Q$G=I2;$(P`&% z9=E=lLz7_cdZ6%ltX<4}d2ibw z8qmWcZFs%!8;l2qqg8ImXfhFW<*}1`(Mxmg-v$lK;|_Mr+a}jPy;Kpk#Mcx44q08d z#J-jpI155sX#$nIJy+Pf-WUD5dM6uSA406wx8S04bNeBl zjbi!fi+DCmj}<_Ls;qHS(MLWm%)Bjew2!{PZ4)fFp*y9l#xba@UsJQ4RgcFNNv&IJ zc6}KVQY4zb_nP$Q%JVGqFjG(suL<9W42 z8Uw#udFP`RHei}dU6~8kyvfSRdOJG0e)kh7GLvd2ur*f!uuHsL+}B4?yYhkk+O|EV zw19`F1+T*&=gC4|RpyZUv(oOHF|VcA0H2n0Om4$r=!WC85gYPrlFx3t5T71 zI-0|$6b{TWZfteh8$&eA%EA!!!NmMvr}WbQ1sV$J3y#+>IQFKc@X{1!os_w(w_nU( zko5IPclKakw@OLo#JN4S-K=0w9SwdpvM3bS)K?J|a9+!7#~-hPuNF=((ldhwcB(KPBLsi{aB$pM2DbiXy%X`%uzx5$> zLTSXG^v~MNQ6ut$WS{G=Uq-Gh`dZc7vr>`sa`}&6>zLkG2wK+(qpb>AD(O@9ueWIq z;tpxIT__{CPzO>Kj%}1WK9I&YnXc{G>keHxYh2#-hebf=uMpWvk05QGh-aPvDZaE8;kt<+$6Ipnh=v; zquy_&Qix_Ahv@x_PJ9|i*e;8|evOz?Q^gf-1cO2KlKm0UJv)~B-Lq=y0#>qcHbIJB z_(}&~@UmqM$UzTonL<*r=#}i`{WrkamjLk8bri zxm3jBQh0Ls$?#3V;tDbTZG-AG@0cdDi-@KQSZFuKU=f|TWmpHFGQ;Viy{?3-p5^XL z8G+abeH&zX5Y9`Sw!%?9I)k6TYy|BO)G7a95?+uxp%FyXf*AtRlsSv8+5} zJaqjIS<|gSivhRE{-d0B{kOuB;y>L?PhZ77Z`W!NfNFVUpJ^e1Rid2(!iTNMAM_pq zr@tyEuW~wi&KZ7uyRYsD7#nNEz4L!LVJnq3GF}zAd~qu--nLs+Ak7P;5)xATVD1&9sShL->Gz!hW^uE5k_<9>(=jB7o$ff+TV&}-SasG)ZTaoe z{xBRjKRom6vH0Gi44nI}3K2l2IM#II+UP}&9ksb_Mm8|_PFBb%*rQTCtpyFYM3_8c zO4uAq?@@Qt(mr{tZYnCaK|?^^mMnPFpoeAS(uOist}zBK zg_V=jCj|HlEBYaTR`!%wZCmYxQhPqYWbVT$Ce7Hgb#T$)uv28`IvqQ7NdE|s{I{D? z6D*wvt>O|{viCC$k?4!&*v7Amf#!h{MyTma4UAE z!uoBHD1(rVl^0)O;D5`<(EiGMes)4yQd-!BB%0@OXVDvS5Ku%b)L)-waR;PE1%#fy zdR;!*N}2TUG|A2bT`N`xtxHW-uCS2ZJIOMNY;lXp?gzhctF*B8+pWRq)Y7Llp%mo; zV7j*^y)6(V9b#3LHy<=MWw~^Ba&B%0eEe9k)Q!$^dkN8&R%62n{d$>{{7#Uvawm0u z0BGe8bU9kKD6bGUD=HyhF<$$fPDz{dNQqlWXL#^ck^eP4!{^zen$Zb=)S55VM5)?u zG=}xp@2_$u$AHxcZ;XeEU?Ge`V0CXHJ!ta3T7_z@eqnQxGM5Z~$ioDPivwDa@Y7w{ z|1;7wc^YXiI#y$qVAhb*;t}M&lB}y@CBI`@_F7L{qPV17#J0SGQruu_?#EhXy~<>1 zb|FHT*pr*g$lpzNq{=&CDjXaMLc9MGZD@|ps&RCN8$j|__}23NK2N~ej@mm}Z1`2| z#3D##{{zrem!t`V5Hg70Z_NN8Rq=b)5xa%57_`WgSKDCbpE%gNr!DnRJCt|McsFsQ zoJ6P^HHuJIptyr%aP>D6=pX_X;!ua!-94go=2Jqw^Cr;omW_WK+{(OYX&W5!D~viR zabXgw)el$wI-XJ13w`&($|c1(>F#!QiRe&am$)s&CG~OrLki)FE-pGTDg*f*yIyYm&HH`YN=Bo73hzoE2>wTyE*kSVSk{Y;vN6l#TnMbx{m6`0d_^nqx1Rykx8yVX>t&u84)9&<)Nx$bKIQ&^(cjcr`2>R)X}}b$I^abh=D@? zjyAp7`1QvCoMB5K;v9-ww7jMg7AESvihm&yR?SsVnj&uH<8Iilj|^lv$b=Kv=fA1y zJhtg013j4--agI1#f_g-k(Ru_aBJDj|6ttjY9yF3jf;$MwAv`G)8-UH&zJ`See}v% z{r1J5_vQ!_q&jbGUZ85s9-yJEX+NQ*&TqdqcV>@9O^k=^n>Q)eKrQO>5kpqaLN5-3 z{mmJhMh&;ixic?2!s%$5|9{#-8sThXH{+eszsDC66{Tbx=k+bF`QUjaU|1c`0(vwZ zk@heHM5AB97_iit9S+#g4**Jt9^1~5A}l57%F3nXI7l%p1J-C}ukdBNpivClY~G6b zpMwr=|DP_P_;PgUDJ?;~;`6u#Q;~56`=Ch_jUoe5jg;(L0vz_>v%iuFC-0uH(}_sF z_9|SgC74SscC$uZpQActIft|jTFse8L|+&2Z)3J-ux=F;P|tesi&wRd#jyVdh<<+E z4g~OB%oz^dJx&H@oQtj~_dKHE*9l5nkNr$S|V0!unT1 zX?NQsWfBR}VO2a+8KwL)FJzC!E5V=SN=N%dW7?@Nm%K$Bp(vHZmyWCzMLit_tO~1+ zk4rTO<=V{nKG@Jhk|Ev`&9)87pylT21Y;|69uoP^>9Mg>OaR3bbH%GF>48hNP@wYN zsU-4UC{nxIT~o8A9@idCHpB%HP;pbqt|y?bsZ*x%O{^~e$s`L~4*FjDcX)@Z1MHxL6VOr5*o35Au{#f*x3^dllkZwl zbcJ{lzv9}?yG@BlS=4gt^o3TdxP&=RtdYO_v-e`ShRYoD**U9rL(^+hCLRwC2E21>X2zhSd5XuH>_#{azBcET0ziR*D*NAKIFQVyuGP6p{18KN)4nx(n< zEmlHR>tih7bh(d(6J|T#&$Ixaxqk+*jDiLHr&o0qoA-qT zrT=M^aT*52^dW)E4}%!L-9qH0!VtdI#)uek5j#@me~JrbJ1Ky|o;$et<;&8_ zo_PMjL;But*A6znYJmbgdI>P;`q$z^E6X&YHbXCH7BD1_rkIYMe6{t0I!7!I^a4Ow z9g#mHtZG{SLs;EgkJX3g<(KA45afjf*ix*97;5b@@19-{PgJ`*lKHn>MbHeV7S9+l z{$v&B2DNE?b zev6{0?}1GqE0rzY=)7sRDwQ{$UZq_|y3@Qs1w@GG{d5d<$^M=uhiIRsO*W#0`?H&F z1e)mM+#VkCgz+-|Lhyad>Wr`@ELpCcanlsU+i!5nTt_hwq8W|u@Fr#PthFAnpiWe_ zb$&cNt^YrrUlj~{Ea+GrMJ<&;*9vb@DtyRWC~&>bm&C0~1IIXY`!UiQ9y(sN7U|Uz zZ4D7v$M3h3aliacSJY`#j17HFDk{|Es$Y>2`3y{hobA6SNTC=;3%X^PCiAT+UNT{3 zatk^yXKg1_k=*?D;t{gcgJ6d2w)PD>i|%&nU-33P?3*O*8Yc2f9Gk#l-iw8I8BQ;| z$`HCtvBL@c*K@#aj{99eQmj2xK1Y{!Mpd1Xdv-RGTEI-_qf+qAJ1f;!L~pE)Keobs z2=R$0TARsT3b3K@N*?g^3GL|T=-ADxOeBhy>14y=vg4?!oY}R#A2Wn2lMOZwHX1zO z`l?bVq1qSb;d~LJUP#YE_e#edq#&=ydDvo%(??d}3P1d1Q6F7wxtC)U(6(|%pNWL0 zZFsG>^8Ep^mK}bPW$Ny(Z==QIqps|d?yMT zhd`>rWvE5xvwl57q#{``0R7hvgw+~WxKH{KPP(Uy?@jwI;FY&>7cf+$!j{MHlMmEL zGXb~faA$N$JJtO}#k{=%kmz{7XHLf>lbeoHCFuHtNZappI#YX7x+%kPQ=@1V(0mo~ zmSQ(fEG3|fv0+Y68BRy{!PCRrJ{9O`CRIqWnE=Y*IRa^}ClDaI{0G*m>n2W};EsN| zy4UbM+F)4Jb4gS6T7V~#C7iFj^T9|OvGEWqC2fKW@U_ar5to}+t`}BM+@I1hY0=C` z;czI@?QpoY8DTr*AzYS$t%`dS zxyF-7UAJyfQfX2|TSa5vj^1vQO-a4-7{(;In`MPQR_Y!SjZFIv)ubo=_ zOf#9K7>d$f&4>RK_v4qXw9P;-r_n#_oB^H;z-AFBsoE=Gv zQd9l5lpVpCry+2agO;=0yHA@9;j2@25Hw^ST4qZ;D7dv8lE`l^wZ6V4`Z^2B5SXD! z!SvhZge~(I_nr=L@X-xvuj{(&lq4;D#a0U?9>n_pP4BwmKpTJf?cVg$O^ab^^xf5s zr>*SWaO1iPqTA}{nzZu@rqv}mKhKKhw|Sx(?;!a^A14~Ui~b6@tsTd4w-0ZpjSxGV zG-%m*ZGRMT-o(4ZRk%6m5s z7w{2({GX|cIhd50Sk)AKXhB+WKE_kU1Fy>6ST7pk?I)A%_s+55gIq707vY-ASd3m=W<*u3xe=UR&@p{^P5%S8cj zU#>lb7NdIwDCj&@x-P#Tth)xhEBJPpy{9D#S}p@`%kl^3*qrP_v^`41ETn0~{q~4 z2yM@0to=SE_@5UbzOep4vhINab!P@*D}+MEp(pRj4R`H}5uHWT$9YK$jIyC_L*>-4}t#W55e92}eu z70vIb!#nii$BaWFo~p-m%72dVR(TgR0{pNePm}PA_bPkTqB}ww63y-{hpvAVmD|qy z;T(DkR{1p8@g7s~F}Hi(ggY<@iKXITS(Kf!`SMSPMTAadpcFWkjG_VF9N^ErYko@M zc`PA;d%6029FXF_?MRX7U*UC`lR*%A;H&Li?;RC~$^rGf_bO{=B;t2wjr>LvV@j1K zRHElQ#hR0&b1XY0mgdF0G*+AJx4XJInX|kV3>kFFUNt6?^XV~3Pd@?elx$ISnr?3= zzTDz+XKC!*OT!+NpS4c-A3bwe4Fo+IkB5o4+eJNjNt9dESREAjb0%lkj$)Sh)MiNJb( z^4|e5UNGPuJ}s5_wC$Fkj(vU5;(F0#< z0bWxDls0$44fM`ya8!Ke+d}JC5y0OP@d>;ft9+IFM~2@sQ?&)JMGY#{I$%<5(>P(b8ZXtcNOUul2wd4cVq{*>1h))btS`H zx}Ja526sc`}EGvJsze(OM8KDxJW6`ewx0BbJ zQzV4~=fibM?cH1(J#fd8OTHGZ84T20nGXzJ%%NuZdrg|cWSPhh@hh8)arZmDgNOToNe<=bm` zmvFxV-TY5%{qI?JmBjJUcIn(L_3)@yu0|4-JFoDg#w=&E$9+7Up>C4n-R>dUkjcloK2p)o-aQJ>v>9O}#$=6^RI@70y@@x|xr89Y`zV|-rU?+1wL zl^Xrbg9%U8C-Ta@K3hIB;wAsC_@wtHZL#6OZlj78iqKACL!_S?tVsb|sE|aP^{RI5 z@Q?~CUBwlNcT?ex?%gC6qGc0O z1UzSFXN1I~iC(&G`RX@~_kG&%cn%KNM|P0fNE*!M+qVfMU&6DqO`nvy%jS5TL$S&A z=6q6y*QG19G2s5u(ju_%GeO~1iG+)U;%#4OCS((Jch*X%i)OYiWGmwRrIAE+6%aun#9Mclr~W6I#BDu{U4z5HFn zYAf}Lu7YW?U3Jo%a*?MbbrO+GUoU3>(x5Y$7~#;ZD{;55z2#gg1@AF026p+xoGF_^~mT`0^ z(_haEwwiW&qtq?_l`!g!5J8RgUv0v6n33nk-33Cbuw$~lK7_c%uy=yrx6uiPH>%xM zeiI}vw`4EYr83`BZ_`e7(|^{)JcEN`@I;ov z3`T<%#5J09P6iK1A~1HRPh3~sv`ZM;V3j=hnAN$CyE|-8jx)2^42lA%8~`O1O0~&E zf6Jx+6LMwSA7#Q;^X7Hg$?lM~9oDT9GrgPw@Vt0b4{tvYvhCsav*=EFKJsUP73DZW z8bOK~MoYgHxv^WrwlwF<&**3fSeU+i5#EfTV!~I>wHxHjz!OXS4&MmH&-;hMO3uCh zXZ#PhFuzZ-)BV(#!LVj0rLgyHBT}oD^9yGejCROQ2wfI6~kt*hHB)>FHtBz0X zayP_D+kZ6Qye;}>b9vZz^Q=IfT9DL7wT79k#7dL6!du94KGl?S6hS7S;lQ7jp2-5V z6tdYn7|T3cEe&JFQlu0-`s2Ua-{#05=B-sY%dnxi@JH?wo5^+8vaopC?eXs!8O1(b zGVklhkUu@>{(SD|Nt25)8wxKl7JhtOilQ}sy1nXm0mU4J_0*T*S>i0bidJLDh#;pN z5(FgGq#N3{UaXi7b&!ee@NXzO>8LW@rmxbzFJG=MK(-sI2nhR}*;}UHz7-B=jd@|d z@N<{s+86#v24miP~)JVnyr@uX=QxSl~teaR8vKy`qg*%Q4(4;#+%LW`~t+T^+i1`j@F`k zLuVo)#VjE@Gp*;z0^ zmLK}`ymB)cU7m2{(M4U<7Z?1}_wvn@O;0Q*OI@psdf6~9b!Z42LOPR_*gw8%jeGox zsDuB!m|g-Sg!YCLT2`j>&DVo{M@=<}N1fVv&qu7tef<9p5k@@%CiDanNQ`sE^@+~s z8-n_OA3JXwWNW$&d?&Or2dh3HA;FqSHI*eUP`_z`nlJO57a0sQ(PW)11qD#Q*Je4n zQmT;rbp8(2PU`ue={lG_cX8AqcF=IvVl>Z<{3|OG$l4AuyPi(Dj!ES%anza{d^0jk zlMlK`%zkquTxnJ~OG|SXiPQ+d3TSAeGc;ZGe6G;hMIF?`PCtJ5+AhBt(gH4ampNph zM(&lYM!?4`jLof7w<$z?C69?m{_@}|_%rqt*cNTN=c(ZW(G-^uxR<*;rg>1+^W!eS_KEcY?&b9?UpHX*a_ zs^_}B2BNm6Hq}%soJEo-(AH9IFH_z0mS|F{kox3M0eX7UwbFKy^;xO6&~e`Nd-t)5 z0sn6XplY8f7v)u;8q=)Uc54@OZTdA1298#%Z91NyH{z_+OR6ECz4QLJ6aMW*Uhtz+&43WeQobQc0{ft3gPtomgn*tb z$b*$8+Ohv@tS3R^`!KfcZfyEC($eS4d={bqE|b4MzI>6(5xQ<%FOC)lOkZ6_kGwZ# z97$I+IQLf#1HRtY#f}{MdF<-7NFz`Ea=(?#pvTTUVn8-h2MzvT=>Jah*q1Kiv#kva zjL?ovj7>f4l2+911jY-{(J^d$l)mj4nd7n_sV4DrY@(9;^pWN$bs4>JE~tEc?!}8! zhflc(O8;ZboEUDB3W)s?HTKQ6*>88|S(O}FDcg>Erj8N4)Dl$I)k@gWt>9O2Au{TU zBkd@WgS&QWeYD5LSvc|1qt26}5Q^Ownr{e|7JBEWH+Ntc`FUIa$9!4f*Vs^*^G3K<`*} z7B?5|YwFE*vzf-3EvVc{iP+!6W}CY4*PWW1h{WY1M`n=n*|i`J2mY!MU!6F|mr-MP zyT9M!*W38SP9CzlmF#x{;teixZek#KnA~MNWL_st}uJ32_wmmnuR~2I|4KQSdjW5JTv# zl_<@(${#@d!i15@JLa?>W=KmTk7M@t`q5&3+Cc6Jq#r*A+jQHcqb=YkBo|E!E zLDKct&vF~P;>2fLqWq={yY*`Fw@yRf*;=-Y-p2tr!;ai7lY3kktH(y`HWte!}{XP8xCV0n%0-MU`q(`xx?DE@a9$X_K_!R}#T4?Y9>L}Kxne~H@=5-et&VR&D z`f_j4=f6ufRjlQubYUe|DR!%pL&w6d*>hNQeiVQpDz5q*>hn5G zK3Lp$Bm1yu!rt30QS18#|ByD4-DuH>z3NdioSW&NyS~zhhZoY)h^Zj(?}j3)BP&aw zzCjg0D@BSxBA!DLM8x_h-oXNLr<6B94`*#vrz6z4}HK~YJi@yXn$ksVtH^?O%o z1%(~f93~55{ZCtqXEyb&^66fphiLJZKghQbhqKE*?KInXGQJ{~{+@QAhhD5y{|Zog zy_ZrYO~=U$KAt{`_taf-)IgWGYi zap>pvgm*}dIR`Ukb__H$+aYsv#&7jxEi#eq*vF^{{|pZpt~q8>+l>q+QX@vX?K@)4 zA(o=VBa0(@LbR%MFp7}_eAPO8H7|wn9jF_X~-B{C_;5C#Mwe>7gSqRQd*Wj|X5 zB*Wgovv}Pk8p~a>N5D#5w}UVIwbwPh^-;`bNbw$Bc1hb z=N?w8!PCORU9$!Y!he|;FAeDIsFTpaT_)_;eJ0=4&U;$vIWH>w4qp#G3yY49c@h#d z+xd86JDJ*zKmXvIb1_`@njeIT8S=#^?ZIrR^jIZlwiSUl-xfGlae4)gDNcuDo@Y=Mi^r*mnv@=Y3Yv3d8c0m2?K-h+9_aI*Nv z*7V*^lidzaPE%Ymgh=CR$1W6&e&ksrSsFL)u-f_XUSF<6nfZ!8DDzl?6}X9|e;a)9 z9B%SH|Neu(&6zay;0sF>NBNF!iv;(>+=xf&Gi+ad@UN{8=%nuSGHBq2x@V$|VYn@5 zzU%bipr@8bx3GC;Jh+R|KYvwrzQ|^;qk!Y`vSx!T>0-4;MtS103Rz-y*_QZlQhpFq z8rY&Y6lZZ1&SkY8gdRbuP2%eu_L)O79wxS(tv`(eAK$eOds$X>-pP+HRNu4JP2; zoiRA;v)!K;8XWu?G2xvoqsa!<8y7bdlU4BHG&51I;1jCTyUn$-#r{N@VU^|Gg1bmW zWM76v18{MB;+s^R#Ek(Fx5IiYl}Ntna6iqFRqO5tY4@|v4&8nnjt>^k_Fcs4`g{&g zjP&XuYlOdnhGj^bx2Sa4)fn45wSDcfQ9R)ZJ?8c;K!XhucTVKlvS1s{3gXb69rZ2-dU@BBQJJ56 z>61Xd&L1JUCUkwiIID;|3QJ^q4!=&EMC*~))a4zxj0d$(ohW43#_jM!4rkL*L92Vx z0T$X82D_xmmCe#Fk}JQjsn=#m9ZhpI>MbA9pz4S;Y4tcmeV*(T-Bi2xw*S6y_Xh;Tc1!29%(yMIx%){h1M+Pl=vHjkfH0C zZf10TrH4>HB(eUB0f-08?@K4Q3FRvoBB2DDV@Exb^m)gdya^`I<7U0CVx78BUGW&Te17Mrh?p)619 zo)E~Gs!BZg?~gW$MhwECFgbDGO%DSar3GhOWIK$QVXZ~MS;R)HMpPB6=@h=ip=As? z26Ib>{q2z^j5V7zIu6F=I_$KH95yq@CWgdlR85P}cWy0ywewYe8*B~uX|f`**_Ts-~KkYlKMKDFK}`(55)bkXJgnfsL%GsS-L zWYu83nzJ_5!-fhZ+y_su=K#a)qb70#8pH41E5Ofnv9!_RbHZZ(ZoWKLSSV(!Rrh`e zM$o~GBC;Wr99ZW^&-HR|Xf&T&>it#YgVTkf zm}|y*()D>HjRf`D+g&&D(=QAVb!5>rm$wFV`Kf-|_Cq&WjgCurif9fBOK4vEwKi+h zI=|=v0gLXVUF9pjImHWSJ6o9)FYl;^*RYFv?Aqjgy?s*uS;-Nm-t1!SqPS>A{k!3Y z;#qjHKY7FbvKvv`M*sAK$%skkr}^gdx+aiEX-{N)4G~kV@=A_Xq#YTGqv|O>Dy~_; z(@iamxzzRhywdjDFu%JjSoyjy9AUD#de_(1R;QQb|VdCQCaLG zz9QY2*}-ny4tibQ9!?PdOcO)+>n5vu+f$P0Ybm})Zt#AmW-q)+aTbw3${BduD)EIi z$M)OycgG#Oihj(g*CHTm{iSWK#Ww~N436$tO1Olz&`>6y|I;ZhZnA{JOs2*OSy3>d z@Q_RGF9E-%iq(qFa$IZo$M??3q>y-Jdc$Ndj*uH%o9n-{1-0G~14sX><&C?R-;6Ry zCdTsK@_KCGv;JZFjx={>#bG1KP83{1@W3)*uvcJoV}8%_J;z*-)dV zmN@MLXV=R2r`;Ye{V2Xo0hm_13nl+(<|vgx{$x2y?Wj@t;#q8dqThV$us$5mQU4OK zSMytC6gxHd;&QOHE3sb}iUwhm?bD=qaz#J-Q?K#m-Ym?f{RTUf9c#+X{}|--doWBC zCwN@j)Oa>v^U4&12SoNWq5E95h6M=2%I7;f;bQKW*E77WuES}3>N4@Iuw>>{My*=& zVTsXacDU32fU$;T(1jCk%1XXcxz3H4nlE%pp3ldWCcj5ss7?(tA{R8Z5xa?R^O*h;0`{jK(wHSVEV&E6om zeWFL>ZrY}+?>ml^em~4+mwxd&OIA>+d!p8#=S}+=svr+iO`2*@*y#hU=Dk!`P8{youKE~J7@ zhJWhGH+!9IWwXt36-kXAF9ek_%8jvn}L|^z>`9W0>!( zV`V*ec^zfH2`?V177}ur*m~m7xy}>KGm~scC7LcOG8E)mA9L{(D?W53Y}eY_+-a9v zEZvlom*d`#vWK%*C~v`2v_)0QjOGnu9SNU7jq~uM=La(GT@G8E~bx+}l5E>8R4!KiM}@d12+l zA0Rp<#*1bUPv^G7gO7$;cUQY-EekWPo6RNSbjPE>Kn@xjF-*KGq{rUAn2%W2^=m(E zIXPpHL~KY6$kN{&2(6h-*s>6R{^@I_+kfFG5FtGG|MB+Ke^EBy`@2g^OE;o|NP~2m zNGnL!!V=OT-7H8-sDLbzJ_;y}G)pYqp>!{j63YV8uzc_J{XCyP;X6O@BJSm$GiT<^ z%ynI7CNsl4biUQdGF0YJl`Ll4B&JueB$|JghNwekR}xa{HM0fpylAi3V>vDUTg|l9w~Qn`RtYf)Ze-)h=`8n8i%_emVZrS!B^$xa$cd z|B&1zad5bAI~%&gfVXOz<~yh~HDyfjhQeIIDf#_MQ3PVuZ%vs`uz%Bce|uUdd;a@s zkiq3;?mgcAJ;!xFI$pmFB|7o9au6nDqW!vi=0gP9j5+^<8yVV*s!Mj;adLl;^|;Hn z^@g#S6>#UuC+v8c%b!pG;LZfF!(vKo8`8Ly zQ|_v+t!6xJYqa9)v(zE|#JBgv0cqVCXFjvkU{|*2ZX5CTYEJk3eV>)i+-S|#!p-P{ z4%hjN@!=h&cQu+HfeD)4{RTPOXSTd`U2uH&pMM(1eY7f|Hju`Pm6>W1&-#0oDTKVR z?>E6U5NXJHglKIbu|94zYuftP zlFg@4-lfv@xmJ}%&?I`S;;V4@b{CA>DX4x7?UOwDE`=X3Q2yva zK7C(K;{{tko7u7Ck_;)owMbzOR}u4njP6W+cw&U;6foa)^uVtQ-cyG#;YT;R2dR8- z>WHepMqZJTZgj0;YD)k9$7-4Ul=j1+Jz>BC!?$Z9@x3(W@ZNIG@tjQCfrj8X`{jxZ zYzlpk`WXf00Oeb{+=|epWBHcY8>V%bPJM8ifqe8p8e*ulL=|*iYe2*t$>-O6U9U*` zrZ0F{c1H#c9$2T&C-!9GmLynx_|r}fSxww`R$k*ipr|`6t4$bkv?TY}B8S&5g8_bi zHkP>;35KeQKdSEU@O-j(5dZ*3gAZ$KFh-4jdtD2Gz-$t;GN?764V%4;OB23)z8*ggO3a9{VM zPUgrcq~YDFEE)~DJ1?_KKyA%godm(5oXb;9I9uDsu5pI*&3a2>^SGL$wpmFsQ9=2> zOJtdxBwgno*}I~Wk=+naQMP;zq9O1qya5q*(Si*MO~w+w97WQ5isY9b=ODy6T@S*P z5aMi)Me`U-f9q{5&=MTt z=JrtAp7v5k zn3E~i)B4qZzfQ3w*MREI{ARv<2oKxj*>zOYy#J{+KlU0g_lC%#HKeRbthKdt$cf7x zlngc_*O`upckJNo9y7~=q_jKl*U;-(|H_pJxovorrNYPEnq(PWHUv?&3Ln96c!YKk z8eV>5Tsu!)Ep1OcK*12)&H+n^eU{bC1DK5-PvcR1`8%yi#zKPvr?Z6gwTJc zJrzbzrQ+xld&aF>F8sUJ_zw(~lCDA*=z+Ehx~r4&jFg&u)-5{Hd{l@x-;*?=_LC1` z^4__UU1i1EiL_tFri-T3rrczGAz~YSN1=6A2I|2J69k)pN6pp?Wno{4-CQ(ts~F0s zxyXk1=h~x<&u?lt)*fJD)-EW1-mp_32pU4-}%S1T>V(m(e&|( zquw$F&%GfN<~tv;1a?=qMm`w%Oi6xj==Aa?apTx)88+W<`}&Ril|E*Bm|?4~_^flz z!(1;UJ#{*%rP;X7ZuGaMz0jtwjIgUlDe-l{BFJqW8?=vkrJa1a;@B3-MuhSB0O4lU z$8EDB=zg6}Q0rqnd75A*&8i{R%@v{&Xi7%6V1#E zm1kLOF7UM$4{Z&6yGP2q%%s^1u@r0z%KDZxF^y2kQ&!w++_Z*Fq(S>s&0e22bAl#7 zHBMA`tJHzOCNAHCVHE$Q1)^d+HA=t)*7I=#s@f) ziIDBcWU4G_lTjWbaF7sG%OTV7=X}vVG}t?0#_jP${jJ$=l_ZJT+;&^8+09o5ZEb=R zuG5`;3A6RzElQlrP9I%3D6z`^u01W1KJzRi0!9HpX#WxD7;-%ZG!c0{Q(J@uF!EN~ za`8z!6%E4p#D^ASYMQs1aKRUjtrl{8v3K+kbr=y*mMgXw>4T?kD4ay)1D791EX?0{uAx(pQ%nqTy*0&7M8oa4R(6guw*Sb zmdiPY>Y{P~(;vvq(|{jePWv6E%Y|3f(=N8m{60OH^VQRMqMhE|f96hF1$$BJdGW+5aEn|8XMpMgrTS$iuG~G2bxtd=IjrdR%shD8Gx`fNcT1BX9-K1x&8xpEj^b4jkObp$*? z`|w|;uAYX2F#9X=X8!a>X~lu3ywRT-twkz!Nso()Iz3}NC~kd`)9+V4U!8vBF!`O< zsdoFA?I(+e`E>#kcZ6Y*f9XjD1>YjiI2qvV{Y2y=imDf!vUze`8QG!&kTJDdD^7qCk$X zLFu|xF%6mDeiVrZg|;6x_1-KHWd07@ZGBvC`W+usz3}inP@X=$%~v@aZmQ~?RByYo zT(Jd_oh(d{=M9qcnTctNPRdhjPXOpAV-47b-$RLrw+Y4>SL6S&&Hw%5%M(A%KRp<+(TIClivGB`h2WNR7b|Ps@3L02@!1VwfiqHk zJdMw4hy!!yCF3(HQ#{FH0T6e8oh2hQr}E-4I#ZcR7-&?Yk|&&}d$k5x*Zhi!s|%k4L|cus+b;ugUz| z{9jZ)Hr?|R1d|vEI${qaZZBdc%dgS6Kjv;I#jBgKJ;y-g$HS zHH^C0_NDQsZdLHKk?;Nd?8~t0eyOi>ZuOUC2nC+LR@kTFvaWxt17J9Tc*!lGm;bUv zTe>#juz~kb{lsYiAc0JE7J^4_8cvk_Sg?fQorfoRn!oC;AAT({T}&c7l>7OOq6)N0 zup0IVEn3cQ^o#xcAJ%jd8XW=;)U;X23vqGgjqNH^XtOEoHX*Q$7dH!;#Zd!x$p|U9eVm=jK&AWb$;~E1`jX{awVu{)5?H0wg z6s;CWMA%mES!EIAPdDMF`kB>&JNg>h${uGvWFmafKJ{LH9Nvi%u;FMVqT9%#YGm1X zTpv%M1U5-NR5WE^4y(6+c(|(p)Z-S~(V%GR%hpcG)j0OM#!UdCITg?I`=k*aSn8mA z^+RP4zuP8KwYY|c&=W1(dCn6AD=}%}Y_(C2dcY$}y8*6(I6~40vcl?1L!?0uE5$I( z=y9(y>P#_%<=(XflntZ|lHId3$&K@+XND*c-fNp#YsFyXM&K+}1F!%vWV+-R6Cj$O0iJVvT>gL<) z=;}@wq$}sW2W8D5Y8ch6qO)#hkG^?f$YcaG;!5~Pvwreb^W0(S1np8}xcH*p@q(^z zXV(sas#f}9Y<#FTe(3DoEwe@EPhM|h94|cFM9fqN5?z#Ss05;wZP**NY+;-Qmb-Gk zwK;3bgpDL-M8%#%#;Dq`MQJE-M@qZ1*%5*9)w2+ajktPckTCcoiH`$l?povH3AUG0 zC=C?xq-^MXCEzO_rq?}kX>&(q+B*$nUvg=ToTBJyGBG)I_GE|TLESTc`4)Yf$ zkmexYumNr~t#)dW_B?;*!l;%eQ=O@iUqP+2HR72EYWFcd6GrWe93|B=8Kx;bRv zRk{e)>`WmnmuULg(&(bQ4xC>VFDyA_5#3^MCr#ogvvU*WECTxgo~cg+D1$e8w(Hqh zq+`B``j*B(UH6l(`PMX_%~MU9>+?_1Sw2SwED6`vgxIZPA|z@t%HI{H4)BQ80@Hht z>)^+-!zw{!TG^#ge<5_%V%ek9C1c@(H)hYII-sdO_?%>M-8HqIaov&Rm*+y9|Mn%v zdL22I$6Y3RdAxNDO>{!(M|eW9k$r!WPZZvxx`#sq-#~lkGO@TN9^P6LyE+!LC29=* zyal!dxk&h5N!n{&K@0*|1n7U6@5E!?NT5V>W%3)_N)QR1;s+e=Wuw{g{Lydq;LU%d z(1RP>3v8xA7j5kvrPs*G2N_wD7D6s>YrtxP>JDquIn>T2(tw^HV|auA6V%v;A8l=E zS>s~Qhj_tJyj1OU{87KipsWjL?q74yz1o-XWunO5*fXKm)At6s1U0qhF^I6uYnojE z*qzUdpe(n0@68hS0QFMyt*oS9ApHql<@Bt_x*312h-i56Zm$6R^b6%em)w?7B;U#G z9E)-#x7*i8Z>1`|Rf&VG!|bzsnAargWs>)@Tj?6-3A}Flrgyj2{k0>!(BCFY)pFzK z5+;r*m1>$5&%$&mW01|4l7`I;-yZ`uJk3s>bVA$p)s)mgOTOxFjqh%a`SVXDshdBV zVf{xBa&Op5q1qj6a_%r^D!OG!ey?k6u8B<#mn$XO{oC*wb7U{$V2^+bUqMz3nWh1F z1{yx7FUs~kk2sR6tMZ*ez-_UN*ZS^>hH_4CUQGnv=KZR$IDW;au*xb-cnnpy0A->G zJ0$jn^7Dle=pE{d%SA`M0Xu(apNv;)idoOMS1PKL9=RA}{H&DAZ(8$mFwo8UbhBD( zGxge`NuechNpa5c!dQvNrOD3!km|jjTCkZaGxnvr`bpGBNz1^a!Xg|C?H7L%C?p07 zNsxfZOx`s_Hso{(!l%EMaPY=#)sSz5_0kjR1uXrh==vHqtspSo5_V+;ssAe&6=$XSW9IgX;KK!kclKlJBArarxQ+^KPHVp zTzK!hdJJ+cd?VP;>9uWCKb>Z_A5;Mv9w!3MLf``{VpC*E36G=nS1)8R@(8Ui@mH+L zvKgDb6lY!padJB^HA^N2f)WcXT*z?EEEz-!t8$pfGiCCZGjrgjQX8{CX@sDrfy?Ha zO@`QgTyZ8uj^G;`kaDBPvn-&H$7~1f(^=`diGpd%lj(iD@%FeF-$793iz{*VmcJJ& z%)kAD;x-mXA5e7C>g zK+RM7)Vjwc{e|>tg)!6 zKf1!FVTR#n(>kY9Ej7%aO~eS7Q1IfxwR}x@?eQKf;@-wiMzUCj*OP> zEO+tFt9N&N^`|fUX2HPW?R4%tYo$iMj&sGGyIBhUuBQL`SJm$huaHIK28o)Qz0zKF z=z|ASuh6eV=AF^&<>e1VT<6cSTOjERV_+QUu6(y%nD)t0OpEdhP^mk|@Zo4(XYlqq z)l3(1CKkc%{@hU6ZIxs0{>11P$}nWvq4&e@y6I+I6iHAiRt?GprD*=hw|Y6&;iaxO zMe}ZaH)ULT1?A1oO5%fU9uRM3;~h@+kpsx2WR+VQ)+tMDylDAU8XdUuNFgF5bN}E% zGUL^mYB2B=f9`|psDy-_WECk+mO}k4eYbSDhMsQmx({ZXZD26X(ds*Qk!-gFJWwp- z1yO$s*5*0iatp{+i|c&+RWmZ$*oaBCv6f>d{GW#TCcNBM%o$NVNFQYA7|N z9UEk6(Pr~&ZS1p(Z$U7r5!qba^q32?J5zI-;@5=Jh==;?esbv9({%PITDS9!e+xIrd3J629bMX`oRf#hpRr^hK-lP6hIP@z~BU+A=i2Z1Esv3UR;_MM<(5$8e~V4nC=|I#9?~<%8kT9nQ!(s33B9j=rz+LqOoJgJ0OMKWg|(^V`uMm zKPh+V)~0{wY%8FDa^@suHQ#ta&a7-d{lno$5$>To9XVjkt(=}B@LVOdDR50w_tItd zEa6rin}~Th+3Rty#B~DSUx6+LpXb~SPSj@@o=&BC2k@VQGv}$iuGD|R_(NbQE@>~MhKLvKx$HZr=){WMPL9DKZ z1_dY|(k*s>ZtOitFnrCTt1yvlYQjBn-3nuD=}7k%boJ-c&Ya!bDt>&)SUkhL+f*C6 zqvU?iw#Q8(x@@Wr<_Jh<@loK02(f$jjFh4C;=-{q33Z6yOrUQ|VI0{)z7nQ|w2nZA z0YEvxA}~lkWtOKD_E!0iVb7*(W*>S38J@CbUWi91-GtL=Bgu^IqG!z$&*XKJH@)h-a^ut+%HA~NyzlMwqS~eBhtjYm@1S z2$ZUx>wGYv$hI9Sj~|dXs&Dyh#lS!FCMX9f_|4t~#GQK!BbIC02^Ob5BfNMCP7vQM zNq5gK3)@*MMc?g>b9+)IF@|9~M>WJxGJqBK?iPbTa+?8R1{u^rwqoGXA~E<#Tj}wz zb>E$!-S(+zkB)Rtsr(@fy+Ud@Q#B#tE> zY4@H#u*qbRBlM$q8OOgXI$7^}Hy>9Pd3vGLt#{=kU*8{o`1lr9B6}A&k}Jx!DX7jz zY>iXBOahxSsua~*r=>n=4_e!DNjeQ^X?4y`TeznHKN$-=a^RZqp*Wd|4#6Ak|F}=2 zlCkC4@y|lT#`8ZBTJ3GcVLCF_`*VsC{}?uDVx`Cb8h$H@(0wPZ)@@OWrHeP(?*>K- z*(PRO*gO^Q2A;$CNfr00i(}<^*?g0eoO%-d5!_qKa5Y32#uaV-bE0cLiQoRMQXOJb zp8FbI3MGL>D`BRu{H|qOfrTIf>STx9=e35UNQi>_O@?N)t)-q7#T0xY7^)8xZ5>l7 zd@_?8s1-!bdc3|1o|E%~6i8uZ@?Sp+kjfwEysK$<0%*f{gWi=|o&_FBa!uCI{>2$? zUCAnhEc}!#kfeGCn z_7c~CV4}t)Y1UF&zUXtcE8iaFT55B zkKW@nn~UlNaVGNJtfP3ARMk3b3IBj{6j?TZ83$DtOYuo0fjM&6uZgaCYFyUtiH*oW zi~b@~Boi+4602{-MxS8jLS>-mFEiyl6OW^CQZ5tkr*t5a(LfF9+5K-39EW=-%901< z4F77vAau!o-v-zSxmf;I8s}aVkOOBWZoCDZsOL&1LJ}@YC$S}d8=YaL3oBX4R3;Tf zITNNK_VPkKX%5nxsOF;h9iCGi7`ymP)XYbFShU-qAS-sN03*E5DC@yJ??J1OM+cfX z6YXNx{NTB%n1ZvYPt2UJTz}=BfN!sCQQM`$Dr3w2=VB6GNvnHNl*rBFYfvy5leTT=l=8&DOX zoQwiW-VX^U!3&0BratFqw-AOvqQ}9H9<`RoWiz5}{{wjbQ%e*5EVdORP-2($nE72< zU*-j!mCA|FZgia6zAdse{rN8@JNX~N6@J%hZtn4L2=1UNp`POODde}ekLqK{bb94AFx)27b`{lt}37>eS z!X}Kb`BQj>`(c+=PW(p&jM3aTXUhykie`&d%iv{jYn(J__6pxY-h~S*jFG=3?~+4r z0;v)BRpBi{-L8T7kY??}KFWp57LtspNMj|-6W|c)zZrsVIY7di6kdU+7WwP`Z6I2)Z6IN(aXfVDHBqcuudxsNe*eIr-db4@rwmhO z-rqX>r{a%Mz1a0kYZP_d3^z~rHYyKT{`P;&hA0!jDg)r8lvscEKPoniyE!0jaC8rj zswyFjbaIah{grw$m1t9D#}BHLlR@c^TQc4@=bQ_Zwbly20ACP6QV>ljYJ z21cjz`L)qeFR%!rigGsx zj06bgSdcJC>acu!5lNB2e%uq&)Bm7}y<6|M#TB@jzz2C&MacWMa=5|Gl?f3k3M~E; z@h~IL`-0BStVMCxiT6p2-OjR2>m$$4`*Z9s>KqShdOum!)mllV3lL=zPQaRZ zEitiFhelWAE)#*OgaXQhx#u(jA?^mux_9@oo_s#=ghFoG>Nz0xPsspiBl3qQ6A zyIU1Wl8P`T!1u2oWmBOW?rBx%uKBPqO7eG7?d~nZihN!N+)pGZ^+|U&OQUEci}y}k zY$ar*yR0hpM9rcmhxX1<_qaQCmd}4JqD*a?T1|QEveL&lT_}Upx?1;;@JUhd93MP^ z<&T;q;n%p+GjiF<5E8SLQcDuFEj0IF@lVolDp8lrPPNKs!8J`=urj0?I8wy;4}KMo zFYh3{x4?7J(T^>hV3(M41|Kmlc^}fs_paOG_x3|$Z~OT=uTSa8n&e)+aIZeLKbWx$ z%R_7r^oQ|;XL%kYsZGMdBxq(}=QFZ~o){wc!naj7J zV(!desqS?Ws+tlUz zkYkLX?9sJN1%ISv^PBg+;L7!LWm_ zJlP{-!QBvvOgsH~%#v-)_rE3uVk1JhYOv*^E8G!Exht;V_@n(HTQvplPb1|$pR9g0 zcUN9)^k^wWA*0_r?-)P==rlj zHJ?_hBbYCR5uThI_A}0jJeBsiiDh%pP|xfP!jWe#|FUTm14Oh?R?V!XV%*6yNZq1C z4xbFm2!7<_%lqh+Sx~8l=d8N%2q4LuObS`NQxs4n`-6Xe>%L~#D;8du)Hn^)hicuA zL#Jfi@FdWDVvf}7gImC`mE!>9f-oKkR<@$>A1@R|Z!?R(BJ^wbz7XN+;)*B3*>!ZK zWIr7jj8F=MvuGnB?y8KQ^Kbb3L3ZuP&q~Gk?bqLO?QJ*>is-;w>0Rdg??-T}=Rj5p z2H{oq15x}Vf9Tu;RfHO?N5IJPc?A$?mol^X)ORd?--C*NT?ty&9+e*1%d&sIov$s7 zxK6gPIfJ9P+{UTA1TSzAyjCgaa2SKOp^osfNJYuH^#O%|neRc0M^MjZnR4)GQaUAgdgP~0?YEPmN;+DCJ6DGp;bwvI8)ecz>y5(zxtnBfv*lL>mZDW zU;w7*`KP5GSEm91p-nHH+(nqw0_WkQ_zQISF6d}>BFHGhr=7Q7DaZd_8`=+Mys|(2 z;8i`mV$JTGuu!RFv5Ya~Ve+)^7B!R)W+5W4gquDI{+kJjZ%EvGE`mBWXlN?p`g6Az zwTSzkGecyL?O^wKdp>TuG)`I^+DT*UM-xE{y{mq|OZdu-oB06ks5|VL; z;CJVu-(N8mItjr+t4p9zmW6n*o%~LliluV=G?NbKyM)75>skBkm%;s}fg~6gN{_sb zRd)Eb;)dgS!;LKDBAk6FgAS9>+hF^XlQA<72qb?Cpbh6NjIB&&IUm7B@lW{}nAbo} z0fj=dk2A(_%}~TjTu?}pKk^tpUeCNsYNuCKE7p2^99HI8|D@I&A-Ko{gug4I{BwtG zKPaUgU4=WE7y5vz%XrhVwkxQ{c%I!>E#tC5ki>IsjCA1mD-Bk3g#4i1$7ew~>07$s zfBt*_snO!WjiEM7s?l5``{5K3QzMZPobRavxam@K4Y&ZlV4kyXfg0A3H@xritGgo9 zv)ZyPhgM)P!^bzXbSO z{GVo%p=ZjOwp{^PO%<-fNmFzS0dxt!@9y#tEl=46{|h?OAx#B`%AiY!dsu~R%0W5E z8&O-f8W<#lPxSt-woOn{m(}-lJ%STMs5(QYSC#| zC+n{RT0?7vY;jRMY2}j}^g5@^`m*F3wZO$MGz;ym!rZMoV zo~ugVMJwGG#$4SklJHE=5A4ymo(`!!R~d*2gC>SuTMLU5h|(7;F4`@;twNx=?+R&AOeOFw12bJdymjynCPqp4%8F3IM!Ri19?icf)kT7J1kUz|Z(Q zoK(YF=DN9_58v~RC**uJO9%h$k@==WTOgNwgyIhM7YH)U76n18T;xB|&y{`)83VDS zeW8?6wL5zmcy%qlJjL9h0neqE>>}^(L3@oqOC??j4C#HN&ZNww@@j)TZDl96BanuI z^NZ(*;^WX$f$&w7E}G%Eg{NYK3RyY~`e^rKms;>ysL0Xs1BmlF-BCVEc^AUSC76LoZqO%Y1%A1c~KGtQ{j3* z;^tu~Pu?H4`}TYkuYu$F^5jaJe^jpKr3}&2#A6$v3STz(nZagy)6u){2)1ej)5jf6 zl4OQgNk8oP-tdw4y)B5EVK`AntsfPU4-mvX1}G;~UOH!T1!_;;W?;>Qq%oSP_S#SX zl#4ALv@(h`m+TppfT=qVwzR-f8lA3?ZOZD?WEpFIK0bF^O~Of-*l>9la!?VPgzr$Y zsU!JnmuzM7ZZFe3iM^GppR8V6?+SbX{7Lr@ea!W1ET?i`3^B`eXd*$4S|ZVpJrIjUh>rbUfLL)*dzMkn7Xq_LqFUZ3f2bZM z9!g;EUK~}p+G2G$U z?Zv|cKc0gm+$HX;M(}r1r`7pADRPj`X<3V!rb-mKaDA>Z{ABTT>X!x$Qm!uKJj@e* zTSefw9$@20Q`~xDZwYcMP`nIl+AT2}IdKsb5Jz4wS6Nb<+BwySU!syw(Wubgg*Kzr zup34$V+|?{P^NN@qKGqMtOi0Xt{#>d(=;4suEa-d1 ziO#2*muC<|*lqDrRQM;0SWFN|3VMIqz15GzFA+se=+gElDbn4zK^eAwKv^C0QU7iNhre#pjro~-ifi(nUy}nr7}sFB`*X68FZX_Y zR!!@G;W265st!H^=~iEl2XelTXXcrJGZT}OhnRqXl97z@Eaj?QJIi`LC?eI^TE*r0 zo7of2fo*~MS-xUKmAo0>E!lD{umX>3sn`n6N)nxrA{dqs>vh4G!YIFC|VVt6+Ute%LPB z83MdGsn1YLC*yVGH32v5lef+DnqUqH1DSnkx+huOQJGk07=jje57f&k0;Y z+2a=VUt~U%Y)UJqB_?Zkg}Dr~Cmx3qhG!R5>{A3+2#zhOa0oJ+veik2@68ZMl&d(f zG8Pxb&RZ*AXWmSdWsry84qLBy{58BjLj^0v&|g||?T>G_JOTNy@iy1IMMj(Wvus&- zYS!22R9_h;0kx47m2VNRjLK^t5bhq!3d+b6p2ur@aaEJrq=(yP8OYkXWuz^h(y|ZF z+CTZKE%t)zJoDm#`D8|gpjnH(OwE`3w~N2LzEb_d7UuR!RGM#8Y<(3f2m~YkhQ1?( z=2OMVB-!f6^*?Vv^l^MqAZM5rY+Yt|=wz<*=`2GX2rT=bAN;XhM%nO%~B}>s;=&MGe6cPT@pKmqYD+OoRgZdjg^y^3>_`iA1)o;fwZQq{QL$ zYukBOuiCBaUrSiELlY^TIf-1`#M4@pkfRaX=i#$VXlL#}mXy!pRQTVt8;RblRn+E2 zpMgIdvh{7bhL)pirI)8$Aw#&(n{Kdm0Y2d_#$y6x7w7Olz!_;VPerxcXU5AKY)(+k zC2W)Av!`PVeDquk=dYiysxxt=ko--;;wh#fa)0Q!eG*hQ@HG7hS6Ra8oKDg$PfI=l zw@tOsI%)VMyBA%MrLQ&RE{v_(ZC3{oCMVi1MimXuP;PA3q*=Gl6>AdVUd_V785Nr<;m(f#(`StRs0|w=R=`qwU-=z14wLPW~i5hUxf+O7C0)o25zI zxp8A>!LUIoMc)9Xod->Si&I%%o)S8%cW5av=OtPGb5zxC>si|FSYx+pqjT=xMzV1P z&S}_@o7y?E;0u_!x+Y<8CyUI6FjV#A7%K$_`D^7GBXF&ojRF2nT@%2SGf_Z;u|zfs z=7_S_O;!dolq-c_Qo#=0FX5-LD30ukMC;pPuXLqLscPO@^821^{nMiKcjZwyQ|Zz# z&zHbz(&AUK660HFoX0bn$olF5GQWGC>QVD&ycJR%_Oz7>=$mhaf1{3Nnw^F$y_b>o zem!sxd8it%tEG9@}Yl~kWbQEU#XE><%%R~L*1!tke z!Kl(Vsf{3c%iTy>SMAK#smj=^J02v{t-ucj6*iqn!?)Fby$egYwHD5%*Cg0)l``&kLCJ%1R z!>3i%TtaY#Y?%I4w2Pvk-&V`*5L$zrdo$cHpX%eP+9$G4_;uue4&OC1U;J)mLEU}6 z99~OhtPSy6IA(D$x8B`TkKAT3l~CM)+R`@;4^r$02zqs^KRwY%REQjJO)ywH8*qwM z(yQUAi7^rI4V3)Ae_@}p{C8R8ZMI7_=*AK{g#H*y_T$Ro#V2P6S7zx(tw|}ZtNUHM zrFffU8Ph1t_~vUFGCOIHeK$793EzKTiFkaH84H^C*jTdb8mhfu2WD(% zBtJO6_o7?0F^`GovW-PpWs9Sd?cKQM;r_(Y{FX!XT}2wQ-Ao=z(ZHlMLvR}d<}=60 zbs6wUS8#~{ym&Ov2rE7zXZ7aWX<4K_Tp&gX9U$v&kiTBqiQBQMEmo5)ws|D)8>ndT z>sRfabv(24*sx+bV=_nFf2{my{BG*-9&{%|5`Cc;Ks~p&wa{OKxj4)bL*Q3Eq%;K} z%#@_`5XA2BOsHL7@D^E1*x2w%P;I=qXS*{ApNJ!L0;B|HMb2uJMO`>R~4Yla=r{6^dl+yMxfNNp>V`h^XYnETt$Gvl`14)&TKhn7 zxk6tBj`!^i(+?^>usc*E5}I6YQHQ@~Fc>vo(HI;GmSQ6|r_!Z>LeeyWJn& z0-G?}SamQ3S`HUQ?YE$&=_==XNU1l3+n;&r^l|M4gP`B+&v^?t5&h?0(gXt`v`}s- zGK*^NUAtIQ?RQK1{9SHzooMjFEt(T~k#O8nBgVl})#iT7fB{Xh6Rw#d>dmcBv!?qJ13=A>d4#{Hk%gr~@$Gfu)9!+NQT@JzW z3|uos%NzT7Z>R^V@hL!0-_fSA*2!Yu412gPG;E@Z`88vYYA~6Ii19yv&WXvhpZw|~ zJ@aaZRE6Y~$M>rnm5eajP&9BsT)~`)?o`I7oa6%*Z_Jqv=IaN#Ag*LaH7hV9gH@kg zAB0#LqyhS-(HjLB9xdNCb3-@DjnFbj3HcmyVvX}Fa2?^{Zr1SGSQRI<@RLhoME_2r|Or(ALed zuJ8!k6hluy2e?Xxp{iF!`D_RD6sNAAdI`SGs1L#3-DX#cG&l7uzfRR+w|Puzus-2N zc0};-7UuRYV>X`th2%bp{bIrA?d01#O@K`89bCS3oA=dVkDg=M%*iOnZg52q<-5rX zJVqn?1Wt-R6D&V^`Sa8J+JqSyC6TQGJA<2}M|IBIY-*rdu1^xQO^MdEDT~C#y&Z$Q@`dJS(UUlyiyQRVIuR)uA*Z)w! zkKe@$6|Pb*aJDH$Td-#+eoV7_bYd2=cjp6~++YHxj=-gXlpA*L+YG4Sy%U@I`U9oo zq6{uG87cWyUnmH;No3@k)~}fR^V($=d2{LhKF@&1_`R+@BE}H)yDf0+%GL$Y&Hpks zuBTw;`c>_xX{Q%C(L|G< zKW&==)duH2nEu`lTuq~}zrwlmW_8sAxOwrr1c||^&t*QF#pOwnEh?%}0e`L+Jrxm8 zSVq#y6Jl)0@w>%~DBJd^S3SWts;ma>UTRgzeKzt2+T460Bo>3MxM{NM`LOA+X@)_i zJyzw96;#)aMg%LLhHv0k62{*qw@%h-kZxnmI`x?INxDCmC} zY@}{UVd|5dKH$ zv`86dd+X*fQaV}^bSM|%chN-Q|0TkGy;rEWyx%{>EK?p_NxYZcCpNUPSbu`X>~yC* zRo`UVtq06~+KN9V8DHpG)zsAHfn1p2UfGC-RG>oPYU-LRAKw*>ZOvDVo2!)g4XXks z>?{A5=~n)A4jKIB+hmq>l}D^~?_RdXQ}06kwU5sWyj&-XTZL3~8`tss|I>{Bs>Cc) z!a80bauL%y&pKH`yIcQS@~h`;hs3$JQl(?wenEF2K9}!(%YO|@WHGJV8BMYCW2rGY zuu6n+xBgL^2Yac)d52@uOl=+QOV-^}yb-wnv^ex$-sfJn-m7tlC}tDMA$%sFnk@m8n+TDp8mcff>!O>W4-n z&RpdzMu|i}7d!#}aQvyD)`e7F(n8w#onLsoDR?DyF~X-3HIF#V%*7c1<}=R=8K zqpgrj-qmOJ#>CER?@j{(g(jr?z}p4ew9;9xLkYLw{o7}y`14TG>0?A>1#~`}G_Ioq zt{IV9!BlCZ~xMKG; z@P3{vJ#KM#y5y6P@o7yFy*LL-JNG+@dTK{iwN@;#mf#jBOPo-c7>dj_#{#v5QYr3u zAR|x#N;f3Rz5b#8H?>U~SeS4Kki87s9RxoO+HMU$TeQA^l4V2|82}t8<+ZJv>Nr(B ze*Hu!Y0ZcEtuEEpO6)BtsohdD z_DXFU62$o4dA;B7&*S&=S04`^ckk=EuXC<*p67X9-ZNrNc#yqPRLZ{Uj%x?UP&h1`JFLmh-Ei*dxG~ z$>H>{7S73+9cz8aM5GDk@RKWshph_|j9xUiLnT94l6pszW_Tf7A!1fCHFEqpEoz+0 z8r`{g6!`FnE|l}}md{Mgzm~#d_+r(nVRwFxj!|@`@mgackE$DK%hqM3-jv{b;y&7T z_hv6DxbISl;O(V^`)Mi?`N8feq+0>Epr=pDklH& zCoNCFDBQ7|v$0O|ro+zofS+)=NZa`xzEl zALyoVG|3A`=Hpc4T76OVA0|!-w&End6wF4CPK;8L~R7V zk2g|axkyQ4diG(Ly&yt6eT9@cB1h*AB|r<6`kL!$I?M^r=jx3 zpXgMP+35BDyVEppYd0()mk+|CmHt+7%3s@g_;U0uC~=ZhBSGR^mVVcO*Grw`oDDxc zGcLTiccoY)UjJEyf>1@Usy0JrVs1lWhV7%+RP7v8b_X?%(P{x6i_H%r&Oi3%;P>9n24 zi|z!g^m*dLUQJQK7-byH=H2w{hTg0p`0*O&t5NBf&N(*nUj8+K%=AE@kUfdPmNu~> zmC);xMwN`s5?t_OUX_PV84M>&$=TyBWL+AOtzx=57BoDLvoV;*ts<>)C5 z017A3{zG>)R zX$`I9c3^r)@pO?xV)k8GKp-JiQb|#$wy1yk5iUdG?i)4nJJ$j=RiC`i8o(V{y6teY zB>5hztOaQH<(yk_N4z${X|ll?b5?!GZTyhL5iKk*s@>k}T6F=vvB2w26^nrj`6lBEOD(@IJwY!e%8x?2!mi8C0k+ zN)LL`FQXw+@3L&~PA3<0RDWl=Q(z)p5}jgT4cS?!w-p|%@QO@xm#v3KFE2@`;SM$t z(#3#uLuqMcIthcur)lp0?51KjuW%e9ckneKGpLxa?khmh9ycR#+hS-?^U3}tSK~L# zGg`Mf#Pr%)+YLFm_U9ad5C8m2Exn(pQ(SK+bMTMOvCGIOR;5~LGKqYI>Wc$JYm!?g zj6f?>yK#&~1nfY1nCblj%jtb@&AJbeV#cD~vo@IY{KQ+ETg@)s{R@@ne?Ur4Gom|T zg~t#7Dv5p*RhyI4x&U3JadUCyYg7jn!p7@1kY_eY#s3^Xaz^3k*F~m`{=9Wz!9E@! z^h`2x z{>pyJFmG1}lXl4;-GCTSX#rB^qPpR`Yn&~P2U`Nu6t8ZE_QU0I&?BNgC4Hmiq<_hc zqs_m32Y2Un^5@SxKN5*G3bs4P8)Jv;|1s4#o-?gd6p>DGy|$F1ewQ|Rx6}~*0Xy|S zu)K{3bVpf0k8fV^l1NgZ(A|D-rPk=|Ig#$l+@}mO$E6ax*Il!j!6OWQuJpKw1XxT> z)K|y>eM{-JL$8kR8%PC@U>APe>Wz2(>jI0#y9STaFoR4(Xy~5<$To?_Pt>X`#6MFR zj)fGzriEY+8*ISqLhCt9Rm6%yKDDP$ulW> z`v9WSs5L#%0BMBlHbkAKb@Yr9x|E$L`#m?dqMG5$?{CEOFL%)b*oBmnd@-$kiyVi} zAWySx&?9w~sE^j%p@{~;OQ6|id%e#Z?X_@@PN8LY{hLpgKoc&gd+3hlX^tU;I!cAf z^an&kGqYEyDyw9tQaJ99YWt9$ej=u^tV4yOE?Q_CAiYgL>A#rVc!=LhA~(#EADUOLe-v$NDL+^c z#Jg%$_RpzVNf@cb+{k1gw``w@Lv%SmaM@?y>!2Qw?(n3dOV9tI871t8>J87Cxfz$z zKQN&qBKtQxR1|E5sXyTrk_dbRmwQ=9yn`>ANT_3ddMuBGcF6^wBi0RAw^ zf8oLB(e4x)i9Rr4n3RSep(6$k!sr0qhIv;8;E^0NByqh{AHtw(A@XavANvNM)= z8yl;D!KsGp(7@sipO$C^m1^vi595)%8MS!G-6h|wrhfuI{ixJLxn-XR zV-?8Ov|G28J5{_|%l;bhzSFkJ2ok(~K9MK@bvTPl8nFWZ92ftxa6;xnB`qr@m@|I& zH((kdt%48D7#SNj#8D<_Pv}{Gwlc;fMm-7G)XZZotUGrTpDH zmxk$>=u8GHAe6HuHH?V62v?H?g&v&y_h+l|A>I*R4*Vax_Cac=J^9(wW9U-Tb72vyZ-SYl>c2 zw`SB%ISF9SW^MxcTZ4qg43XTBZINPrq97=ruwanLwNT0UJU&#R0?+*L9}4<#066!O z2iHA3Rte%!RjVr*`umdKV(kf$)k*X+sA~?APPgB=wqLFE9YF%dGe>mwZJPRBc||PB z`K0=m$>^lnv;y*9?BlMziXZI!@Xk(IrOQ9=L=a+e&R?9Nf6q&w?n;38T%*}OjcX(n z>DEBc|EHL~vR%bC`_TkJZB~*wyFjF$WA--q&l&!^-i(upu0j#R?JC+ubPK9YBu;Q9 zgq@Ythl}pB(}}coL2Y+#lK2PwiGyocUIQDbCW>u22BH-W3FD=}ojO;~mPv4dL(s%1 zmGpZNIc_a$%u$Z=&WQ;J_f1Nf(jTo7_5AdM%}g3_n@LR?WhQ8^zXBNWI^RR^i@Pj; zVqIOyWF7r9tc&Nr+tQYzzXkt0Q-&C;GEECFtnwW>KYy(5J=5{Q)w6Ey=>8oezqYMe z|JyD7la$G9c=O+gZ~%LXVj5i&SJFD#B=oq68k-(V*)dU7<0K2uGy3WKQI9i5odegO zb4N>7n8J@!k*)}+rab#@jx~j7#Y3`^89tV^ff7e)c`)|eqw$oChO%MC2`Adlfk%R&8j^*T8C#sd#yeM*XEALWBDYK zWq}RgF-IV(Jlab*`}6SYUD=90LU(LpE*Rd=Qaim5;8|H7Z@S$m$c|TOf*Qq2Lr(Dc z&wC!XuXG+N;KSyJ$^4~2=phl1_l!!?iM78b_a6Og$3M8cC}(VSxR%~`L4mJG>nd;0 zh?jv^ObygYtc+3dyq~bOq@T`Z`l7ux&gsvzGx351-s0aer=(N*;?lJ)NUnpvinQ4O zxB!T4k}9}pe+|-vxspIzzKh2nQVK?LC z0XTDW;7b#IPcq4tOBh8JDmkfj<%4J7_1RC^Q~ zZNuU?_chxhFQ}dCd9)Gj+CI`*?$`qhJYknNL_aGQXb(gO@Sc$OMTL4q=_}ZKqDdLk zKXO)%#L2%zv`1ec&jIMjg)y~SM%HpADL2-CRp%EIL>mzK$Mcl@kgc4-{iD1MyQlxy z9&E;!6i?K?uv660eUR~teRCwQDm!YqNy*C3IA!4mDVrL>q%=G3(c{vw)M_5fHv@XV z`;G}Fk-woXqGNQF`E>D?M$zv+0|;#<*e5#HNyEx%KvwSpwrE@gXnkty^EO0vY+kU{ zn=QFSvb(b%OB!kTx6au%`=e$}!!*pVzj4GgrDzxv{<55r!XdI4OV)$^?$S;8^!vId z3k%0W+@9-1(&=EivnVjZB>12FvQe+a@jBLNd^wDa2!I;^ZzZd8#)5?^_XilIkvC-* zzemPoHc>ODi=J$N#bw)bcAi4fN|qXqA{3-fg&D;zr^B z{ly-oAwZuV1_UWblqyaH<;l_n1s&i5oEu5*`~MZFJ5#hVv0f0;GTFFbO%r^& zBjBrW80UY3V$lc*C>43K+tmcAb7n14_o18pSk__^u@a*+J+_B;DqHHN<}9D?{@=qY zX7~{`BodR`z*NBOPwu?z1|&cWyWe6pY_AQ?vXB-Gv*28AtjJ`?N6oz_%-EFwjaLY9 zUXuiFDr%($0?a(4{z%!za}-1!P7BEADc%FGkUZYVz1GBd;_dYxWnaW$JQmb1>grI+ zl&njec*pYAn5Yfj*Y61ZXMUB%AMc6gwG#2DiLlVgpL$Xk7yI(Bxv~E-F8Rhc$XQq* z+MD*DXy$(u?z6!i$-a(=zwEHMj1sG_@M+O2S_#>mxmNEZ*7!qchySi)fgQ8>@_(Ce z+b8#?U!VM4tT5OUe`VnGM62|XWoN#2ZG`d1a1FYIut;h@r0o9x;rhj{Kvq#&x44Vq z6U8O;(8ulmc?q|jF}om_p`b0L$O{lQQbDHwn;BNzz593uKCuT7=mCR{y48o%_*p3iTWbQ zw0dM^m3Wx<-z2{LXh+G`lJkDv%TpHrUgw|xe^oeYxx!y0o;99a^pmomK1w6|9~}NH z8&KfUcI|%cvXd8M#BIg?XI9VSdlGgmRw?oL8EV)+Vv6I)M+?_7hMP2%E ziD^XyGT^^hJ_2|K#c<_0r+MvG>Wa1g;g{ywXNyf0sDe$H7rc=AtXEZMTzfb~ryGXC zWXO;6ebWpku4pAEny=}<^KV+U?)*>P;gs(gjpB-#O0ufn+&kaneah#2ec;`qmA59z zlG~LOt}b&&89#5a1fo6lAa>sF^%y^xv?+eZ-+A8ZU%+{cV5vJCoSvxviB&pfNL}p3^CZAUPkT zf$}6mfqwx%%ISYhzHEJ>@F(Y_s)XzotFzDRic={k8aXQNzh5pCS$CgG?pEs%&bcKL#2Lu5gMz-OHZ&OumXLQ4@ zvIlo^jQ+oMD@W)_r#qzKs&$Isoob(cc8g^ZxquB@`I=B@+UR>o zXBIFK$>|i~?dWB>i}Xoh{7eYI$1V>&t{FY=p# z9GZ3i?0)Z5zp>>y{95Ngxw_xQpInz#nyay*8uA^;5g$C|Af4WVHJUB-RUF9Y ze!QWdDfzn6?0>;aGd-rNVGYtMGM`)x7_P0DpKY6U& zb09jB!qJ=f-wKiJ4*(aj(2LiGe@zfDt36G%`)rO=?3_D?7qAFa5$4@P&2}^~@71k*C-lI+O$bG9 zw)3CJ(g5)+2eut7Sx?J#a`Urf68Rjdn`GtSQ9C9Svd5p zAPzGQ4soX4CL;CA1@8lvRo;r4n9WuVc+~x-ch?j?cckV-`1QW$iTl)()la`}*rm%m zsKB@27XjDTU19#M>WI=;(|781-~n!>Hb^ca<^joPQhthtsfl@yh~Sy73^OuwlwlcN ze{TY(PB<-DUuP$Et;{AhO)Kv5SyryYm`Ha>^=Ey28Gkwp^Uv3?nCMiGIEKul*6}O| za{ck^g@dVBhCkTy*cxb7is>Z5)>$Ye2911ZriLpw6AsVQUKb-@=KoZh9BCGbVZ-;* zPD(-f{YnXSHy~K`aZ&AG$6IRO_o{nnnXbJ6GxRckBnXPZ=Y>1 zo#Lf}yLK$Ime6N}y5q6Ed!U9BUNm?&1SyXyloZqu3Kjn|=X09C;Ni)$&+UAfM0ZCi zKxqx|V4uFMJ|8&nSnPd0`buQxlMQUdtEVqU?c4p0zb0l|`asqA$l|#M(6m^J{dBJ| z54~2S@9R__HB_*86wyMxWh4P2znG~>Sr#TE^4i$KB zxSBu8pwo$CV2y;_UH4Z>ze2-ml$XR{|M3?c09-N>9?S*@G#lBdf;DS|Yej%h;hW*h zp~JpQ-wj~wS#Mj*oiA9XCbiNWsVuF>=+tAC z6O3OPrS?n%>3G1DRhhhg$b_2RxCZ7W>(iH}gac(C{wI>b)1#oo_M`}26!gFw8$dqb zfiUiV9E;dwOlpfdpL!h|U$&T;>MpYUu?;4#k%NnedCP1lX0X{+}#l-Kz>sQYkv>QSizFwj*1YJ)_og z6<_vWz5@JG5sJ@YISEsT4xl1JIKwvLUJ~y=471GXVVQM~o8hxk;LE`}R>UVN{7276 zbb%S)!sz0`-c}zpb`u8iQzV`q4_{m$z?E@~_$Z*wqCB9?4;LyDno_JP@98X*S(u6m z-n<9pNIzK7AAz(n`4vHhN~R{si&bY?SIcnS^t)~4CK^ma1b0v?K7u(a_ZZ0lu=vW` z@b!VcIk~o+^6j%B3jF(h>zA!Y=3roCuE1NED>oKIxPX3j-Vr}Z7($+CUB4HL@qEzKgys{d{TII&*SClS6=g%PDMS!ZgkCaF*x_vAAy3^{Ldz+_X5)aELdx_iQ6y zs?LKk>#HTmh3s^{A2lxXF)8f*bC6-3jUYfCEz=Y2)x$Hkaa73DFk3Q{M(?!F2436o z7$C*o6rU|K?qpm0Mb9}MUJ&So-E#racBFJ&{TbXu5ZvnuwTrqOKecm10Zsx{V+A1U z0a8VBGe0n`b}btaE5)(X;Si3&!V5nKyvsU0nBrf>FE5uJswC+F(D(KMk}CvDLOD-w>UoG7m)-e=9fsU_T-rHY!WhW$nd zi<4Qh-fbbAJ?_Kk{>36gw#|`RpBI8`8Tzk*+PyH2!+d3=dVK08>6q%OpCjAEuzQ}H zCgupYHXzV2&s1-6+~2&mL8@eeRl#5qv^|XQAKqJStF6tvA9tGCTp183*M#Ud7axl* z`7`o-xzHdeZ_c%$88zpTzll?Ei`fwFHGC-gz>Gn?e&Z%6$nA#KbB5W9d4(9RVk5kJ z9;xDKSzrAdtfa>V^TW+U_Pt7Rfd1~-(_eQi%KDcPuaQ~9()9S;Sk*jdWkzR|A2ob# z{586RfdhWd=A&EHSN`S*KUWhzeOIG_WJ2!X!oJH~gaFt(TMQT5e#q`+Uw9iG3!|nk z%yM$H_Q;vYZO4uqi1lXyr&aV;PraYJ&P_)%^nYjyYioHnL?1$lcqfl~XAeGRFMj@R zMj$UZ{!+^D@X*PnZe@|;oR}Fm?sekV!YSo{W{mU_^L00RTYvRNNx{5l9(S%SyBqTC zDw>?~(PF8$Jtw>A|X>tJD7UqIz zJ6_2?A@MS+jGG;}v*=~}aZ?Rf_{?duNV2de!^R{P(B6b>5f2z!E(ZsFYPCZyZ)6XP z|NQ8X*me@a_G0w`;dLG^1e}*C=(RzWT9mzh#(g=9$opyL>hWO$#(rtUSK7+1Qpbw5 zMyY!H0gSvyKl@K{l7SoeopAR+bxH9Q@G zR|FF$Ih$?6I_^wOEOpJOe06tU*ALAEni6BTL~g99`w~iGoe;sA3f}(v)4-vy$n20o zW_Q~P!UbpmB(Qw~yMZmR zNx}#S()Tii)5&75LurIOpLAXq1-EP12Y(2`ls>LVZ$jbXBqChB#nYGU*;w_gUqJP6 zVG|5H>J?6yHD<6;9XK9#Fx-ApQn(ClgiORZ#B*4E{zz|i@q#?VF?H{mKLIE8L)v9` zQs!0^`;6|s;LI_4X*%91bLRc6n2D*BqAZGMYID_NS^cev_I+-kv2e1{S#frYF1{AA zj2GrF+dom4lpm&&pJE~QpjscT7;DK5{kdjCrrG`SGqZ=-Fa_nEKS7)hAyejB`OXij zp|p5kl*San>^Zb065F+@7lV8>=3;-0>Ql~f3VX*;Eof)eSo1hicnQ-CQVhW#BM~>1 zZ(l`Es^*tMj^~P>kShauj*>FUkY+v+G(rNdJ*By0YBu6MjvGnCHpy`{!2w_&>m$~& zXA0%%^f?Bdx4NTu6u0>|f@B#oIg_uZW<*nsB7^yCN@WEn|HaP-7yIk{`nm;0A_y`7 z#C@{OO3V*~w*5Kmx>Hy4a-3`zvOWBb{k6QqbD&&j3P1>f8xTiTg2Du4XK+hQVr@&8 z>F24&^F?1h4qU_;Nej)h(L87RGo(J5XX?4PY3$@BtT}+jW8X+l5@;^7v3hXQouf%a zpP!Bs?DszF7sy{$LpM>oF@p}^{ zgp~c!af%3r_kUSQE8EnI9Q@wMJUt>+4vx7^&wruEOnuwAIJi__wN8=$yZ4(H%57OR zSJ-!KRW46e=%yvHR=MJoutXm`?W0tG=Zd>3GijtNFPE$1VL{F}>Rw>INdRT;_LZTd zr3|W;_y;xT`+rRXiOa1#_+L8}i{@+!p{^(YVgbZ|i<2_c5- zD&ix=yGXNdf^2zpeg=V1e_3eC9uWl%QK^vav*2enT#xhn{G$(q?cS~5D4s60W(SnI zGa8zNYc=9=4Ja(gX9J~#=HbpNtFyo|gS9Jfe;%!-;jHs!3Kc3+UGEc7igEomy&AS@ zyIui)rYMOv8f6Bv)@iqv)!fFaVM89mPowlfA)(c7G-O`LrM@D*Z5oozqw3e#jW9Z( zze`K4(?dk#d-=nP1#PeaJO8IB;fR)LWDvuw6P9nYnv=pUS$5J#)g~t$_+{qi1y^>l zE?AjoDf^iCFiM=-?`}+Fi)HSS4v(2&5gC6qJP{8U%(Vdw>)rGFr@R)Itm~zS`~+R)P4$+gZ7cj`s|O#ZR-+2sN)mId*Aco5jL{gI(5c!;R(MOz+(-GXd? z6GH)c_G%3yYg}wv9D^(;D8o4`KA$EAbMEUe+Zfjn#}^E-2<+-hEBdQEwfr2g0%p?U zEChOO))@;2U&ixtab*)EO+}hPPfj( z*6GBUN^zjBngB2CJ`hHZ8#&Nj!Ik^UgOos=uu((*^~vyxY2S`g3E<}FiWkYRkWx_g zZZm<6D0a2CmqKcv?C}mXH9=P`2{~uGM4g;BrfTx7^^T$eHb>!;F03^-&R-K@ zRW}!3ri<5Z29W@7AvK_-y?x*Vk6Qnxr5T1O>>bIC$OB4EL#4SE=koDiEf=663b%R* zMCHI~$@*#^M|f}Y8vV?PEz#2|P5Gfr5I4A4^l7A{loF6f7~#H@ zMH^i5#vjkhavE>sy*?TIeVQP#9;x6*2)f*R!j3Lpga)#F7DXZVGZwutn!x=giF5ew z#lP(AZ23TI;ZgWpI+Krr-;>M6TGFI^+os=m)=P@pA)TC%$q^aIUJ zNP3*}`cJ)k;yqiBJ_?QQPO zux0i*vK9((x31$FIRZ1M>p!PX!;Vo@W-!X*nCgSLQj7hR7_7C5y+DxLF3y*f&I6xT z(!YAOWU8ShBG7udA#HvYJJ-GzbxPd2`eJqD&(AMrdtM47Id9WDdCMBj^OH*+k5)#F zopjwv_+4t1U_;a|fc4yd4R!>7(<;L^=4$7KFMV`fQ#ZeOBx(pe+v29{TH=2cXN>gT zRR4`HA?qErHI^Yx)FRe)nwuWWNWhEeW1nm* zVe_N)V;%$bCa-w`c-|>M%)b0}wc>PP%OQ9iByalM;?0LAFOxy6kAFiWuk5hgOSss1 zDZ%9f<1eX^$1W~^FYVv|kicz1Bmaf@`8(vh!Bj~((~0sX^b3U+{mrc2EZ2#V@vP&< zQcuPHUN|8q!mUMhG$5Zc>BPtUun<4I z50O=P^(+BJ9`SPNeW&-mld&|lt4qJXcf8E&WV@nd2=!4-k19@bMd%y$g^wY!x)jgg zoD3`tSls(Xc)34LH)X)CaxL^;!T@b{$QF!@y6{iapGI5p_2_#sMrL09+C}P&BGxuG zT{#RUDUs#w1Q>SHR-8(bd`oZn--%3DuD(sp7RRe-%}u5rM@Vbt{{Y@0C)OlO-4&Fp zU0Je+a&d9dY%p|lj6(3~nr#_0Sjp<)6ewOM2WiBa{2IdSuNGRqs{gzxi}8P-`k-6e zu~I=-rflYA1+`fu5-*6B8$&cVMOTF9^gnezUR?)f^z^w8t7IMY=($qYkLw82MQlSZ zR^){TO}$lUh+f`a9a z3hsFLmSM%(&cWeoC2S`3N%I6Evo$h2H2RVf;XT1ge|w_5O0`=~u6ksJdOD<5zcQ6R zGwKUsI-!R%iqMqX*X+%)QF(=p@CuiOWL%zO?UiG{aQ>~*=^yMF1w7)``c>fjN>@|L zNaBy$`*lwv*Y}q4-+*l@RyyX(%TrdD-T^PjGdv&7$t`Yye2={htzDbpNG34RGToRQ zy^l>f*0BaH(uH9ip}c5X2<>YtZ4Z_jQs_WdAi9qJCCe^{dclwl4UJgVotxJl+_$H> zgN5o~*y-vu^G@~9ifsOBk9d){kYxoWQz>dpwzbuXs1J&3OS8n-~Ql9xd*kP>yQEVV!FFo`)ys7chT#=T^ATfD3;G6 z2mbUvi)z{*o#$JhjPN6WGi}&xCz4TACsK7u_I~7srq(q(v#DL)lQUl?c;y)$v+m;V zcZJCLG5P8Gv7*r&$qIW#O)0olkLll5!e%FmU!F|;e$-Ku5GwaN1J)I0`I~Akj=C~0 zRuRMv{d!G3b@k8JI6{}crygx)9q=XU0TQqtWm3S~RdLC(OmbuS&l%#80Z{FcZYUiI zH>O_Pcg?$r{b*z$(0@#ttWQ@;$AfwJ7rw5tk+C+rZ-FpIDsA^>u|x3D=IuhSO&GS- zrZL{2=I;$JqC?q&y;>4q)c_BFVKWG<~VzK5yC^9>LDiD*KKXXmcCy+{MZ=2loBkmKAAtxw{QeoT|3oxBt$kZ})>xS=n#!#^_7B4TP z=BG!U0e>5X#F7o*p@N~8C$HVi97*2TMc<-wQmzGU{oX7bH5bx%{f%^FzaPH#vkIoY zSxb7AiYpJ?nre(V-58tM1^!ZUm`9ey9_fe$6=(br#U@|wxTnSERp(t{DjE@L%ztJoso@s{uptJG432no2dJHCt|i& z4i<>A3a#mXyZ{p^-47HcANL(NV;`@(>Br@wcdT2dxINc?ih2(1@S&fsI>`PM7o4BK z$(D|afktR%=)=4td+!5x{9D0SSK-)QVa4n*IeS`r&2YbpJv`Yy=)6MUEi0c^&$;I} zfG;CyEhX(Y)f_K28bID zlv-|cmF}eIFTRHk0jW>BCNX&Cf&EaTrB9 z{`md+!&mghjAnsTr&`-7Gz<4J`3*wpf5c25UhGt4JYme?gZBEblZhW`V2rc~hJG>; zer}s)8!RJJEkm<)5ZcFEnmsgwsr$3bI$H8g+d;XmgeJVcninND_96BHyfK(>yCqby z>z@EoicILM_dZ!;@UV7V)MR+Wd|tG)&#?`|(Ye#(qgR-lW!iJcs_VwIh>OlLgtxS} zu$LqQ^PWF5S{U?b(>fMwT089N_ep)tRec_~6>6851fEQy*YGyJB}Xo-BlT4ODfKY5 z-r$~ypD+nGP;&E;WW8b|(lWL_vW$bI#lFv0v>Y^$at5rmT0Fg$A{`p3#S3AbOp*z+ zi<5rX?Lg*5)Blt!ey)DD33F1s`P8EThJf-Ri0G$Qmhwot(v4r(aS4$DhXR)Lu?YR| znrrvZZNqf*$)~h*$4MJBjnQuJE49&S;;GAqSnW_5-$e9`+qpdQ2Zr>Adv0gcm2$iA zl8r^*v|VIwEzeQD-?$-+tTOeN@h!4qN}jlE+AS2Z}FD=~l=vX-;ddYY%5N z_I2u=N?Uf8wDGJpi!hXSq|qY=_bT=WxwTj3^9ohbatPo|O+3>oiXh;l{P!4m5A(;> zCNV!tEzg9QH^6`VIB62cn*F3wC7*&Vcx!z&&~p9W`{q(NDnI$W~3 zI3NQlVhmaGlrR3Uc@E0mEZ}4OogWrx%@xIT#ATwGd*&03#_WplRj#4{@7sQ5&I;_0 z8XQO2Ov>4DJe5#gRDM9m`U6x*)%Ko*$ktVz{L~B-FJNvG#n^Azt#XP2(5Yu6te1` z->H`>x*MMgNapE`j)fL~h$`^(5+NP1{HEJJzx~BiTmds+A2CV_gQ$pFix9UfjlXzk zk@RK{g_dDkHE9uf_3}ZdbiM3c03F51Xnua)Lg}3LerM6e7iMQdz&1>yty6|cKtC(1#gNx`tzQxk*WoRqzH>G$+FluWv5iaK!n=*PT zY(6-im9r$F1f3={s@d5`52RvGEj!Cv(~_p6EyWw;e-3o&1vWRvN5=ODY_yNx zukYO(D+rwku56c!Iu7G9|641bo)q#nc5juT;lung4F$k;SS$M&M#d5 z%Kcb#NHObY_}}eos_5nu>K!4$VhsurNq@q!7YutwX`&xXaIlIpo{F1%EE?!lv!^Xr zo4pP0trXgqZWXBc_BPamadN))R9NTE$8W(<-J~fWR*6mxj8w6bG~`u(pLO)Aunu33 z12bIq0HVXP!+xdNq`n7Z@_UM}aCGjDUUK_kZFG~;=-sA{qI0}%5iedyB$2CVY@Bpj z)_B0bY*q<-O3uSeP-0j(Gp^X2h~YioT>L$7P?Fn|!JoBRza};m5!}C5G4OF8;hVGB z8ECOQNVCw5Nf+PT`syBPmXw4eir$T`(o6Uq222%tVYvQoT6eP!w)*5N)|m|DZLMPgih_ZU65HW4%UTrfVe^`9|%zv{`pY71MGpk zC>~MpXamGZvw0DQ+s+RSpva^{Kt=tmm5*OVz|Z$f6}5OgbmQ@So3Ct{Pt3T&QF8$@ zKaz`%IAij>DY{T;cM1Z!YM~|Xpd__jaC&0D7&_$wMZDbU=cPS4)X{hi4FtOXDeUjg zW5;rnHzppe#T+|Mb}hW8KgrWgBJ1SFxaHNi;J2hI>6-xiFz~j!=&+}scKc{M;v-mk2Dr@f}%j#F3r-aSI#sj(I>Z(mp65L)j|J}hI$P~Od{?0U;bkZ1B{g&7&m!5yd@NUp!KC4*H5yn~G^^p6yX?*=*RVv?M^@Po=P`ROY=fIZ) z&QU+FOMLq6Xyc=C2<170rO#$qy1}-*SUPP=UG)^PvSRIIEmWot2-ZEm5uS3>xlM)d z#pb%eghL#6-?DaIbh_#@#-5OnQ0350Rn32kd~7yb&))t@kGL(x_8~zv^^IkFWX^N9 zxpKBfO0booA&#UGWf(@8z)W>*T}tC!40GFaZp>FcfV43e%dB$3lj=a`(Vog91C`1R z;&xD0o&1$ZND++_Yu~L`Fs!%;d7ypb%qKc08bs@%EYr90ubYj4P{Tt5beK&(Xb;D* zC05ls!KrD!O&{K(NM8**uF7wlFtU%2w93&S1bvmgmds9yuwR-89vEtRI&x|Y+?AP6 zxsSuA5ahiKPM?|2J0TW{K$s|cUui`z$}gX3=fnjwMwCiSzh4)&(ZfJ-~inP62rQkiLHDM*In%Ni-z5i_nx@mNxh(MAm^$- zO${4mkd zN)VPMs!U#W=BvR#%JLajU^}-46gpmhr zHtmI@#^&Z@;5Iu1;)K{WQJCXnY^cYo)-2m7sbP%L+#iIvynRzM+T(l&HUPY{|7>B$ zq$sIqvr*)kLM216#T?X>?t251KkT$wbapIC>Brc848!zwZaN*#UB4-(q+>B4gAtG3 zQvv2#eJ#z*%hjGH5#^PPM1NLz*22DGf=euFJtz2X818KypTGK*O3~MQD*yg&!rlhk zo>gvarWuX7OGd|O{@UKJi~J^`{{-leF5R_FjBMT-Yc7bRKvD{Ef5ssxg9eI>S8J<> zFtKUpx@)i=qrsfT0fA@p^4f%vO2U`(-ez(DMyK~|Pf4NUTi;aVE#Fr1b?;w~P_Tv@ zZwOYJ)n%aQHv~=ja%+o**x8(oJLf2_xe6k96u%Z-M9TFI<$aS`<55xwmVHd;*hz=@ zTPp*w%ImK(1vA3CY6GK4F+{@}X1#iUVeK#Gy;U>fA^tTSg=VaJfPvq9`_@m|PrsFi z{{3_wtAC5Q%dmY7FMN+=q;}S%y5CQSq`sYEyGfP>AFyxhLjnrw&tPJcC-bm@T~90( zkosDir!jHn)h)AQd2u20n+)e_-iLnU??HYIwY|Ge7qu!#;k;g!UM!#D%=$o=HL0v4 z%9cqS6k0Z&W3^Ogj&w-&Co_zh>o=N1b$I7@j?aWfF4v}26Z?xk; zmaLw@Jo1kwIdz^DDzxhqbB^-nG(Nj;SKM8}>Sz9jaPmwVfu~tOjw17&`Ko=U>?t8- zPY{{g_Ny&iMI$~a%hNjEF==d35WLtd)ae7qbfQKF?AX5OaEv>{Zn*h9IWQpmr3PB> za|^w#^ReMTd&rw$Rp^HlTyDlTJ7Lk}Fc=gMZ{+YYtEUM2w!QkIrp%j2u>rzt^Io>^ z6sZBcWnLNmW^j|3SAV)o;PAn8a(mR)W_}>c_C5B6VEmaySWCsuSR2%L?%3h()2bNe zngXmt>4p#_F(%fsGpRlNMopUw$CE6A?3hlFk{mfg$8yW3jMkj4#$_g`tUmc(P(QG@ znjIXg;~UdL_Y0F&{KJE6%Qbuy(s=74CYB?7x{ zqEo|m1@&Q3ledh2%TsWQQlTjmYdf2*=ZyHbnV=k14d3xADF(jQZ2k}xvRHB9sxz2- zh}R^u1J;%Gjl<T0k|H55{-fLk6q7$XGIj@*7IOgg?QI1sTb5)6{O8?;vu$`7-N3+ZSY z@NXox|Mm*nFp;lkXq1v{ak5LU$!r zH@B!f`2=X{p`p3ZWr3nU9&+;EW26l=pb2j@zEHk3oheRPy}jP#%__A(30MtS=Xvb( z|GK*JcqrE|F7Cb34Zq{;ug5fXk#SsNMKG*M(r*(%M#wOlP2>ma+D z+_Epj$d(v$F?SeK7&FFw-!k|2`TU+gXFlgW&pFTcInR6E@8_Hc>MOF`2+va9^OWv8 z2`w`~qJk4DfUCi74smB@_Z~AhA*q`Q>!qr-yUqp#iG+#j1YE3q`9X@ZQhG+oC(R>% zyL65v;Coj;+2xM1ud?V*O(8BWf*L+HZfG(_t14SW+?S01TQ9mp>yBzKyu8GcN$Ns^)z#sLx2 z1*acQx#KoWXkD$PP@E>JtRCM`m%%jOrr~92t?a=r5{aa6-%uX#fJmD)`&EEC{z^)B zmAP{R^r^v*whpdi%GgPaBz-6XjZ%PBS=_!^1r>Ig&>SgsZKuK&OAQ|j*uBX*g{k^s zZSXKBSy;Vent+Fs{(Ic@Y~$NotS2MkO)`$R=(0bANDWR(X_@M{+RNCT9A%BM-J-Hz z6aHd|rI&RqL%mbr^{Q}9$+CmmIf*k#vy1VVL{t*?^Xf@W7rA97?rnZ@>DPAIk=x-f z7vO#idS!(*LZjV88O+0F&o1`yx7&5MNI9u>(bnxRu~V!V-@P1}WVI3D)dOLN?~NV1 z`hK7yY9k5Ahq$lxY24)>cNOVv4|sZ5YdXgopPqhVvxXn?ML7YRTfZH>75vxq7=r8xum>+5kTQOG>LsH7H6P zIDf~1BIw=Jc?kG1**rg;>>kPEX|SLxF!itXA%XKR%gW~2^=Ce?qvkT&AV7I65S@xM zQ*!osKvMSSQa<}Ab^HW=;21G?b0fuMI6?e zWP-U1kotV@GG+d3=x�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%0DH0g8QJG$>HHYF>2W9p{;O1SREOQ$?- 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 diff --git a/eo-flow/requirements-dev.txt b/eo-flow/requirements-dev.txt deleted file mode 100644 index 9fe6bf0..0000000 --- a/eo-flow/requirements-dev.txt +++ /dev/null @@ -1,4 +0,0 @@ -pytest>=4.0.0 -pytest-cov -codecov -pylint \ No newline at end of file diff --git a/eo-flow/requirements.txt b/eo-flow/requirements.txt deleted file mode 100644 index 19556b1..0000000 --- a/eo-flow/requirements.txt +++ /dev/null @@ -1,8 +0,0 @@ -eo-learn-core -munch -tensorflow>=2.1.0 -tensorflow-addons -numpy -marshmallow -matplotlib -h5py diff --git a/eo-flow/setup.py b/eo-flow/setup.py deleted file mode 100644 index ea60fe7..0000000 --- a/eo-flow/setup.py +++ /dev/null @@ -1,29 +0,0 @@ -import os -from setuptools import setup, find_packages - - -def parse_requirements(file): - return sorted( - ( - { - line.partition('#')[0].strip() - for line in open(os.path.join(os.path.dirname(__file__), file)) - } - - set('') - ) - ) - - -setup( - name='eo-flow', - python_requires='>=3.7', - version='1.2.0', - description='Tensorflow wrapper built for prototyping and deploying earth observation deep models.', - author='Sinergise EO research team', - author_email='eoresearch@sinergise.com', - packages=find_packages(), - install_requires=parse_requirements('requirements.txt'), - extras_require={ - 'DEV': parse_requirements('requirements-dev.txt') - } -) diff --git a/eo-flow/tests/test_layers.py b/eo-flow/tests/test_layers.py deleted file mode 100644 index 3ee19e2..0000000 --- a/eo-flow/tests/test_layers.py +++ /dev/null @@ -1,47 +0,0 @@ -import unittest - -import numpy as np -import tensorflow as tf -from eoflow.models.layers import ResConv2D, PyramidPoolingModule - - -class TestLayers(unittest.TestCase): - def test_res_conv_layer(self): - input_shape = (4, 28, 28, 3) - - x = tf.ones(input_shape) - - for npar in range(1, 4): - y = ResConv2D(3, kernel_size=[npar]*npar, num_parallel=npar, padding='SAME')(x) - self.assertEqual(y.shape, input_shape) - - y = ResConv2D(3, kernel_size=[npar]*npar, dilation=[npar]*npar, num_parallel=npar, padding='SAME')(x) - self.assertEqual(y.shape, input_shape) - - y = ResConv2D(3, dilation=[npar]*npar, num_parallel=npar, padding='SAME')(x) - self.assertEqual(y.shape, input_shape) - - with self.assertRaises(ValueError): - ResConv2D(filters=3, kernel_size=[3, 3], padding='SAME', num_parallel=3) - ResConv2D(filters=3, dilation=[3, 3], padding='SAME', num_parallel=3) - - def test_ppm_layer(self): - batch_size, height, width, nchannels = 1, 64, 64, 1 - input_shape = (batch_size, height, width, nchannels) - filters = 4 - bins = (1, 2, 4, 8) - - x = np.arange(np.prod(input_shape)).reshape(input_shape).astype(np.float32) - - ppm = PyramidPoolingModule(filters=filters, bins=bins, interpolation='nearest') - - y = ppm(x) - - self.assertEqual(y.shape, (batch_size, height, width, filters+nchannels)) - np.testing.assert_array_equal(y[..., 0], x[..., 0]) - for nbin, bin_size in enumerate(bins): - self.assertLessEqual(np.unique(y[..., nbin+1]).size, bin_size**2) - - -if __name__ == '__main__': - unittest.main() diff --git a/eo-flow/tests/test_losses.py b/eo-flow/tests/test_losses.py deleted file mode 100644 index 415c34d..0000000 --- a/eo-flow/tests/test_losses.py +++ /dev/null @@ -1,115 +0,0 @@ -import unittest -import numpy as np - -from eoflow.models.losses import CategoricalCrossEntropy, CategoricalFocalLoss -from eoflow.models.losses import JaccardDistanceLoss, TanimotoDistanceLoss - - -class TestLosses(unittest.TestCase): - def test_shapes(self): - for loss_fn in [CategoricalFocalLoss(from_logits=True), CategoricalCrossEntropy(from_logits=True)]: - - ones_1 = np.ones((1, 1024, 2)) - ones_2 = np.ones((1, 32, 32, 2)) - - val1 = loss_fn(ones_1, 1-ones_1).numpy() - val2 = loss_fn(ones_2, 1-ones_2).numpy() - - # Values should be scalars - self.assertEqual(val1.shape, ()) - self.assertEqual(val2.shape, ()) - - # Loss values should be equal as they represent the same data, just in different shapes - self.assertAlmostEqual(val1, val2, 10) - - def test_focal_loss_values(self): - ones = np.ones((32, 32)) - zeros = np.zeros((32, 32)) - mixed = np.concatenate([ones[:16], zeros[:16]]) - - # Predict everything as class 1 - y_pred = np.stack([zeros, ones], axis=-1) - - y_true1 = np.stack([ones, zeros], axis=-1) # All class 0 - y_true2 = np.stack([zeros, ones], axis=-1) # All class 1 - y_true3 = np.stack([mixed, 1-mixed], axis=-1) # Half class 1, half class 0 - - for loss_fn in [CategoricalFocalLoss(from_logits=False), - CategoricalFocalLoss(from_logits=False, class_weights=np.array([0, 1]))]: - - # Compute loss values for different labels - val1 = loss_fn(y_true1, y_pred).numpy() # Should be biggest (all are wrong) - val2 = loss_fn(y_true2, y_pred).numpy() # Should be 0 (all are correct) - val3 = loss_fn(y_true3, y_pred).numpy() # Should be in between (half are correct) - - self.assertAlmostEqual(val2, 0.0, 10) - - self.assertGreaterEqual(val3, val2) - self.assertGreaterEqual(val1, val3) - - def test_jaccard_loss(self): - loss_fn = JaccardDistanceLoss(from_logits=False, smooth=1) - - y_true = np.zeros([1, 32, 32, 3]) - y_true[:, :16, :16, 0] = np.ones((1, 16, 16)) - y_true[:, 16:, :16, 1] = np.ones((1, 16, 16)) - y_true[:, :, 16:, 2] = np.ones((1, 32, 16)) - - y_pred = np.zeros([1, 32, 32, 3]) - y_pred[..., 0] = 1 - - val_1 = loss_fn(y_true, y_true).numpy() - val_2 = loss_fn(y_true, y_pred).numpy() - y_pred[..., 0] = 0 - y_pred[..., 1] = 1 - val_3 = loss_fn(y_true, y_pred).numpy() - y_pred[..., 1] = 0 - y_pred[..., 2] = 1 - val_4 = loss_fn(y_true, y_pred).numpy() - - self.assertEqual(val_1, 0.0) - self.assertAlmostEqual(val_2, 2.743428, 5) - self.assertAlmostEqual(val_3, 2.743428, 5) - self.assertAlmostEqual(val_4, 2.491730, 5) - - loss_fn = JaccardDistanceLoss(from_logits=False, smooth=1, class_weights=np.array([0, 1, 1])) - - val_1 = loss_fn(y_true, y_true).numpy() - val_2 = loss_fn(y_true, y_pred).numpy() - y_pred[..., 0] = 0 - y_pred[..., 1] = 1 - val_3 = loss_fn(y_true, y_pred).numpy() - y_pred[..., 1] = 0 - y_pred[..., 2] = 1 - val_4 = loss_fn(y_true, y_pred).numpy() - - self.assertEqual(val_1, 0.0) - self.assertAlmostEqual(val_2, 1.495621, 5) - self.assertAlmostEqual(val_3, 1.248781, 5) - self.assertAlmostEqual(val_4, 1.495621, 5) - - def test_tanimoto_loss(self): - - y_true = np.zeros([1, 32, 32, 2], dtype=np.float32) - y_true[:, 16:, :16, 1] = np.ones((1, 16, 16)) - y_true[..., 0] = np.ones([1, 32, 32]) - y_true[..., 1] - - y_pred = np.zeros([1, 32, 32, 2], dtype=np.float32) - y_pred[..., 0] = 1 - - self.assertEqual(TanimotoDistanceLoss(from_logits=False)(y_true, y_true).numpy(), 0.0) - self.assertEqual(TanimotoDistanceLoss(from_logits=False)(y_pred, y_pred).numpy(), 0.0) - self.assertAlmostEqual(TanimotoDistanceLoss(from_logits=False)(y_true, y_pred).numpy(), 1.25, 5) - self.assertAlmostEqual(TanimotoDistanceLoss(from_logits=False, normalise=True)(y_true, y_pred).numpy(), - 1.2460148, 5) - self.assertAlmostEqual(TanimotoDistanceLoss(from_logits=False, class_weights=np.array([1, 0]))(y_true, - y_pred).numpy(), - 0.25, 5) - - y_true = np.zeros([1, 32, 32, 2], dtype=np.float32) - y_true[..., 0] = np.ones([1, 32, 32]) - y_true[..., 1] - self.assertEqual(TanimotoDistanceLoss(from_logits=False, normalise=True)(y_true, y_pred).numpy(), 0.) - - -if __name__ == '__main__': - unittest.main() \ No newline at end of file diff --git a/eo-flow/tests/test_metrics.py b/eo-flow/tests/test_metrics.py deleted file mode 100644 index d7c4413..0000000 --- a/eo-flow/tests/test_metrics.py +++ /dev/null @@ -1,239 +0,0 @@ -import unittest -import numpy as np - -from eoflow.models.metrics import MeanIoU, MCCMetric -from eoflow.models.metrics import GeometricMetrics -from scipy import ndimage - -class TestMeanIoU(unittest.TestCase): - def test_not_initialized(self): - metric = MeanIoU() - - y_true = np.zeros((1, 32, 32, 3)) - y_pred = np.zeros((1, 32, 32, 3)) - - # Errors should be raised (because not initialized) - self.assertRaises(ValueError, metric.update_state, y_true, y_pred) - self.assertRaises(ValueError, metric.result) - self.assertRaises(ValueError, metric.reset_states) - self.assertRaises(ValueError, metric.get_config) - - metric.init_from_config() - - # Test that errors are not raised - metric.update_state(y_true, y_pred) - metric.result() - metric.reset_states() - metric.get_config() - - def test_iou_results(self): - metric = MeanIoU() - metric.init_from_config({'n_classes': 3}) - - ones = np.ones((32, 32)) - zeros = np.zeros((32, 32)) - mixed = np.concatenate([ones[:16], zeros[:16]]) - - # Predict everything as class 1 - y_pred = np.stack([zeros, ones], axis=-1) - - y_true1 = np.stack([ones, zeros], axis=-1) # All class 0 - y_true2 = np.stack([zeros, ones], axis=-1) # All class 1 - y_true3 = np.stack([mixed, 1 - mixed], axis=-1) # Half class 1, half class 0 - - # Check each one seperately - metric.update_state(y_true1, y_pred) - self.assertAlmostEqual(metric.result().numpy(), 0.0, 10) - - metric.reset_states() - metric.update_state(y_true2, y_pred) - self.assertAlmostEqual(metric.result().numpy(), 1.0, 10) - - metric.reset_states() - metric.update_state(y_true3, y_pred) - self.assertAlmostEqual(metric.result().numpy(), 0.25, 10) # Class 1 IoU: 0.5, Class 2 IoU: 0.0 - - # Check aggregation - metric.reset_states() - metric.update_state(y_true1, y_pred) - metric.update_state(y_true2, y_pred) - metric.update_state(y_true3, y_pred) - self.assertAlmostEqual(metric.result().numpy(), 0.25, 10) # Class 1 IoU: 0.5, Class 2 IoU: 0.0 - - -class TestMCC(unittest.TestCase): - def test_not_initialized(self): - metric = MCCMetric() - - y_true = np.zeros((1, 32, 32, 3)) - y_pred = np.zeros((1, 32, 32, 3)) - - # Errors should be raised (because not initialized) - self.assertRaises(ValueError, metric.update_state, y_true, y_pred) - self.assertRaises(ValueError, metric.result) - self.assertRaises(ValueError, metric.reset_states) - self.assertRaises(ValueError, metric.get_config) - - metric.init_from_config({'n_classes': 3}) - - # Test that errors are not raised - metric.update_state(y_true, y_pred) - metric.result() - metric.reset_states() - metric.get_config() - - def test_wrong_n_classes(self): - metric = MCCMetric() - - n_classes = 3 - y_true = np.zeros((1, 32, 32, n_classes)) - y_pred = np.zeros((1, 32, 32, n_classes)) - - metric.init_from_config({'n_classes': 1}) - - # Test that errors are raised - with self.assertRaises(Exception) as context: - metric.update_state(y_true, y_pred) - self.assertTrue((f'Input to reshape is a tensor with {np.prod(y_true.shape)} values, ' - f'but the requested shape has {np.prod(y_true.shape[:-1])}') in str(context.exception)) - - def test_mcc_results_binary_symmetry(self): - metric = MCCMetric() - metric.init_from_config({'n_classes': 2}) - - y_pred = np.random.randint(0, 2, (32, 32, 1)) - y_pred = np.concatenate((y_pred, 1-y_pred), axis=-1) - - y_true = np.random.randint(0, 2, (32, 32, 1)) - y_true = np.concatenate((y_true, 1 - y_true), axis=-1) - - metric.update_state(y_true, y_pred) - results = metric.result().numpy() - self.assertAlmostEqual(results[0], results[1], 7) - - def test_mcc_single_vs_binary(self): - metric_single = MCCMetric() - metric_single.init_from_config({'n_classes': 1}) - - y_pred = np.random.randint(0, 2, (32, 32, 1)) - y_true = np.random.randint(0, 2, (32, 32, 1)) - metric_single.update_state(y_true, y_pred) - result_single = metric_single.result().numpy()[0] - - metric_binary = MCCMetric() - metric_binary.init_from_config({'n_classes': 2}) - - y_pred = np.concatenate((y_pred, 1-y_pred), axis=-1) - y_true = np.concatenate((y_true, 1 - y_true), axis=-1) - metric_binary.update_state(y_true, y_pred) - result_binary = metric_binary.result().numpy()[0] - - self.assertAlmostEqual(result_single, result_binary, 7) - - def test_mcc_results(self): - # test is from an example of MCC in sklearn.metrics matthews_corrcoef - y_true = np.array([1, 1, 1, 0])[..., np.newaxis] - y_pred = np.array([1, 0, 1, 1])[..., np.newaxis] - metric = MCCMetric() - metric.init_from_config({'n_classes': 1}) - metric.update_state(y_true, y_pred) - self.assertAlmostEqual(metric.result().numpy()[0], -0.3333333, 7) - - def test_mcc_threshold(self): - y_true = np.array([1, 1, 1, 0])[..., np.newaxis] - y_pred = np.array([0.9, 0.6, 0.61, 0.7])[..., np.newaxis] - metric = MCCMetric() - metric.init_from_config({'n_classes': 1, 'mcc_threshold': 0.6}) - metric.update_state(y_true, y_pred) - self.assertAlmostEqual(metric.result().numpy()[0], -0.3333333, 7) - - -class TestGeometricMetric(unittest.TestCase): - - def detect_edges(self, im, thr=0): - sx = ndimage.sobel(im, axis=0, mode='constant') - sy = ndimage.sobel(im, axis=1, mode='constant') - sob = np.hypot(sx, sy) - return sob > thr - - def test_equal_geometries(self): - - metric = GeometricMetrics(edge_func=self.detect_edges) - - y_true = np.zeros((2, 32, 32)) - y_pred = np.zeros((2, 32, 32)) - - y_true[0, 10:20, 10:20] = 1 - y_pred[0, 10:20, 10:20] = 1 - - y_true[1, 0:10, 0:10] = 1 - y_pred[1, 0:10, 0:10] = 1 - - y_true[1, 15:20, 15:20] = 1 - y_pred[1, 15:20, 15:20] = 1 - - metric.update_state(y_true, y_pred) - overseg_err, underseg_err, border_err, fragmentation_err = metric.result() - - self.assertEqual(overseg_err, 0., "For equal geometries oversegmentation should be 0!") - self.assertEqual(underseg_err, 0., "For equal geometries undersegmentation should be 0!") - self.assertEqual(fragmentation_err, 0., "For equal geometries fragmentation error should be 0!") - self.assertEqual(border_err, 0., "For equal geometries border error should be 0!") - - def test_empty_geometries(self): - - metric = GeometricMetrics(edge_func=self.detect_edges) - - y_true = np.ones((1, 32, 32)) - y_pred = np.zeros((1, 32, 32)) - - metric.update_state(y_true, y_pred) - overseg_err, underseg_err, border_err, fragmentation_err = metric.result() - - self.assertEqual(overseg_err, 1., "For empty geometries oversegmentation should be 1!") - self.assertEqual(underseg_err, 1., "For empty geometries undersegmentation should be 1!") - self.assertEqual(fragmentation_err, 0., "For empty geometries fragmentation error should be 0!") - self.assertEqual(border_err, 1., "For empty geometries border error should be 1!") - - def test_quarter(self): - metric = GeometricMetrics(edge_func=self.detect_edges) - - # A quarter of measurement covers a quarter of reference - y_true = np.zeros((1, 200, 200)) - y_pred = np.zeros((1, 200, 200)) - - y_true[0, :100, :100] = 1 - y_pred[0, 50:150, 50:150] = 1 - - metric.update_state(y_true, y_pred) - overseg_err, underseg_err, border_err, fragmentation_err = metric.result() - - self.assertEqual(overseg_err, 0.75) - self.assertEqual(underseg_err, 0.75) - self.assertEqual(fragmentation_err, 0.) - self.assertAlmostEqual(border_err, 0.9949494949494949) - - def test_multiple(self): - metric = GeometricMetrics(edge_func=self.detect_edges) - - # A quarter of measurement covers a quarter of reference - y_true = np.zeros((1, 200, 200)) - y_pred = np.zeros((1, 200, 200)) - - y_true[0, 10:20, 20:120] = 1 - y_true[0, 30:40, 20:120] = 1 - y_true[0, 50:60, 20:120] = 1 - - y_pred[0, 15:33, 20:120] = 1 - y_pred[0, 36:65, 20:120] = 1 - - metric.update_state(y_true, y_pred) - - overseg_err, underseg_err, border_err, fragmentation_err = metric.result() - self.assertEqual(overseg_err, 0.3666666666666667) - self.assertEqual(underseg_err, 0.7464878671775222) - self.assertEqual(fragmentation_err, 0.000333667000333667) - self.assertAlmostEqual(border_err, 0.9413580246913581) - -if __name__ == '__main__': - unittest.main() From f25c39c660be897c2b8c4aa71e8c32d7e5e5997f Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 3 Feb 2022 12:27:15 +0100 Subject: [PATCH 04/21] add eo-crops --- eo-crops | 1 - 1 file changed, 1 deletion(-) delete mode 160000 eo-crops diff --git a/eo-crops b/eo-crops deleted file mode 160000 index faed907..0000000 --- a/eo-crops +++ /dev/null @@ -1 +0,0 @@ -Subproject commit faed90720f1bb622cf9520f51b4edf31e0b47c1e From 8c1f59a9a0695306f61354745fb6f35b6ea206ff Mon Sep 17 00:00:00 2001 From: "johann.desloires" Date: Thu, 3 Feb 2022 12:28:07 +0100 Subject: [PATCH 05/21] add eo-crops --- eo-crops/environment.yml | 14 + eo-crops/eocrops/__init__.py | 1 + eo-crops/eocrops/input/__init__.py | 1 + eo-crops/eocrops/input/sentinel1.py | 100 ++ eo-crops/eocrops/input/sentinel2.py | 154 +++ eo-crops/eocrops/input/utils_sh.py | 141 +++ eo-crops/eocrops/input/vhrs.py | 487 +++++++++ eo-crops/eocrops/tasks/__init__.py | 1 + eo-crops/eocrops/tasks/cmd_otb.py | 213 ++++ eo-crops/eocrops/tasks/preprocessing.py | 195 ++++ eo-crops/eocrops/tasks/vegetation_indices.py | 340 ++++++ eo-crops/eocrops/utils/__init__.py | 0 eo-crops/eocrops/utils/utils.py | 81 ++ eo-crops/examples/Sentinel data.ipynb | 446 ++++++++ eo-crops/examples/VHRS data.ipynb | 1019 ++++++++++++++++++ eo-crops/examples/layers/POLYGON.dbf | Bin 0 -> 34 bytes eo-crops/examples/layers/POLYGON.prj | 1 + eo-crops/examples/layers/POLYGON.shp | Bin 0 -> 332 bytes eo-crops/examples/layers/POLYGON.shx | Bin 0 -> 108 bytes eo-crops/readme.MD | 35 + eo-crops/requirements.txt | 8 + eo-crops/setup.py | 21 + 22 files changed, 3258 insertions(+) create mode 100644 eo-crops/environment.yml create mode 100644 eo-crops/eocrops/__init__.py create mode 100644 eo-crops/eocrops/input/__init__.py create mode 100644 eo-crops/eocrops/input/sentinel1.py create mode 100644 eo-crops/eocrops/input/sentinel2.py create mode 100644 eo-crops/eocrops/input/utils_sh.py create mode 100644 eo-crops/eocrops/input/vhrs.py create mode 100644 eo-crops/eocrops/tasks/__init__.py create mode 100644 eo-crops/eocrops/tasks/cmd_otb.py create mode 100644 eo-crops/eocrops/tasks/preprocessing.py create mode 100644 eo-crops/eocrops/tasks/vegetation_indices.py create mode 100644 eo-crops/eocrops/utils/__init__.py create mode 100644 eo-crops/eocrops/utils/utils.py create mode 100644 eo-crops/examples/Sentinel data.ipynb create mode 100644 eo-crops/examples/VHRS data.ipynb create mode 100644 eo-crops/examples/layers/POLYGON.dbf create mode 100644 eo-crops/examples/layers/POLYGON.prj create mode 100644 eo-crops/examples/layers/POLYGON.shp create mode 100644 eo-crops/examples/layers/POLYGON.shx create mode 100644 eo-crops/readme.MD create mode 100644 eo-crops/requirements.txt create mode 100644 eo-crops/setup.py diff --git a/eo-crops/environment.yml b/eo-crops/environment.yml new file mode 100644 index 0000000..7f21f1b --- /dev/null +++ b/eo-crops/environment.yml @@ -0,0 +1,14 @@ +name: eo-crops +channels: + - conda-forge +dependencies: + - python=3.7 + - pip + - gdal + - pip : + - eo-learn>=0.10.1 + - sentinelhub>=3.4.2 + - -r requirements.txt + + + diff --git a/eo-crops/eocrops/__init__.py b/eo-crops/eocrops/__init__.py new file mode 100644 index 0000000..b9863c0 --- /dev/null +++ b/eo-crops/eocrops/__init__.py @@ -0,0 +1 @@ +name = 'eoflow' diff --git a/eo-crops/eocrops/input/__init__.py b/eo-crops/eocrops/input/__init__.py new file mode 100644 index 0000000..b9863c0 --- /dev/null +++ b/eo-crops/eocrops/input/__init__.py @@ -0,0 +1 @@ +name = 'eoflow' diff --git a/eo-crops/eocrops/input/sentinel1.py b/eo-crops/eocrops/input/sentinel1.py new file mode 100644 index 0000000..867b0d6 --- /dev/null +++ b/eo-crops/eocrops/input/sentinel1.py @@ -0,0 +1,100 @@ +import eolearn +from sentinelhub import DataCollection +from eolearn.core import SaveTask, FeatureType +from eolearn.io import SentinelHubInputTask, SentinelHubDemTask +import datetime +from eolearn.core import OverwritePermission +import eocrops.tasks.preprocessing as preprocessing +import eocrops.utils.utils as utils +import os + +import multiprocessing + +import eocrops.input.utils_sh as utils_sh + + + +def workflow_instructions_S1IW(config, time_stamp, + path_out=None, + polygon=None, + backCoeff='GAMMA0_TERRAIN', + orbit_direction = 'ASC', + speckle_lee_window = 3, + n_threads=multiprocessing.cpu_count()-1): + ''' Define the request of image from sentinelhb API by defining the bbox of the field, the time period and the output desired (evalscript) + Sentinel-1 IW GRD product, available from 2014 with <12 days revisit and 20 meters resolution, resampled at 10 meters + Inputs : + - coverage_predicate (float) : upper bound of fraction of pixels contaminated by clouds. Images with higher cloud percentage will be removed + - time_stamp (Tuple of two elements) : first and last date to download the picture (e.g ('2017-01-01', '2017-12-31') for a 2017 + - path_out (string) : Path to save the EOPatch locally OR your AWS path if the values from s3Bucket are not None + - config (sentinelhub.SHConfig) : configuration object for sentinelhub API + - polygon (geopandas.GeoDataFrame) : input shapefile read as GeoDataFrame with one or multiple observations, each representing one field ID + - interpolation (dictionary) : interpolate missing pixels (clouds) and recalibrate time series into fixed time stamp (e.g 16 days) + - n_threads (int) : number of threads to download satellite images + - backCoeff (str) : Backscatter coefficient during calibration process ('GAMMA0_TERRAIN', 'BETA0', 'SIGMA0_ELLIPSOID' or 'GAMMA0_ELLIPSOID') + ''' + + if backCoeff not in ['GAMMA0_TERRAIN', 'BETA0', 'SIGMA0_ELLIPSOID', 'GAMMA0_ELLIPSOID'] : + raise ValueError( + "Backscatter coefficient can only be 'GAMMA0_TERRAIN', 'BETA0', 'SIGMA0_ELLIPSOID' or 'GAMMA0_ELLIPSOID'") + if orbit_direction not in ['ASC', 'DES', 'BOTH'] : + raise ValueError( + "orbit can only be 'ASC', 'DES' or 'BOTH") + + # Request format to download Sentinel-1 IW GRD products + time_difference = datetime.timedelta(hours=2) + + if orbit_direction == 'ASC': + data_collection = DataCollection.SENTINEL1_IW_ASC + elif orbit_direction == 'DESC': + data_collection = DataCollection.SENTINEL1_IW_DES + else: + data_collection = DataCollection.SENTINEL1_IW + + + input_task = SentinelHubInputTask( + data_collection=data_collection, + bands=['VV', 'VH'], + bands_feature=(FeatureType.DATA, 'BANDS-S1-IW'), + additional_data=[(FeatureType.MASK, 'dataMask', 'IS_DATA'), + (FeatureType.DATA, 'localIncidenceAngle')], + resolution=10, + time_difference=time_difference, + config=config, + max_threads=n_threads, + aux_request_args={'dataFilter' : {'acquisitionMode' : 'IW'}, + 'processing' : {'backCoeff' : backCoeff, + "speckleFilter" : { + "type" : "LEE", + "windowSizeX" : speckle_lee_window, + "windowSizeY" : speckle_lee_window + }, + 'orthorectify' : True, + 'demInstance' : 'COPERNICUS', + 'mosaicking' : 'ORBIT'} + }, + ) + + + add_polygon_mask = preprocessing.PolygonMask(polygon) + field_bbox = utils.get_bounding_box(polygon) + + add_dem = SentinelHubDemTask('DEM', resolution=10, config=config) + + if path_out is None: + save = utils_sh.EmptyTask() + else: + if not os.path.isdir(path_out) : + os.makedirs(path_out) + save = SaveTask(path_out, overwrite_permission=OverwritePermission.OVERWRITE_PATCH) + + workflow = eolearn.core.LinearWorkflow(input_task, + add_dem, + add_polygon_mask, + save) + + result = workflow.execute({ + input_task : {'bbox' : field_bbox, 'time_interval' : time_stamp} + }) + return result.eopatch() + diff --git a/eo-crops/eocrops/input/sentinel2.py b/eo-crops/eocrops/input/sentinel2.py new file mode 100644 index 0000000..ec59ec5 --- /dev/null +++ b/eo-crops/eocrops/input/sentinel2.py @@ -0,0 +1,154 @@ +import eolearn.core +import eolearn.io +import eolearn.mask +import eolearn.features +import eolearn + +from sentinelhub import DataCollection +from eolearn.core import SaveTask, FeatureType +from eolearn.io import SentinelHubDemTask, SentinelHubEvalscriptTask +import datetime + +from eolearn.core import OverwritePermission + +import eocrops.tasks.preprocessing as preprocessing +import os +from eocrops.utils import utils as utils +import multiprocessing + + +import eocrops.tasks.vegetation_indices as vegetation_indices +import eocrops.input.utils_sh as utils_sh + + +def workflow_instructions_S2L2A(config, + time_stamp, + coverage_predicate, + path_out=None, + polygon=None, + interpolation=None, + n_threads=multiprocessing.cpu_count()-1): + ''' Define the request of image from sentinelhb API by defining the bbox of the field, the time period and the output desired (evalscript) + Sentinel-2 L2a product, available from 2017 with 5 days revisit and 10 meters resolution + Inputs : + - coverage_predicate (float) : upper bound of fraction of pixels contaminated by clouds. Images with higher cloud percentage will be removed + - time_stamp (Tuple of two elements) : first and last date to download the picture (e.g ('2017-01-01', '2017-12-31') for a 2017 + - path_out (string) : Path to save the EOPatch locally OR your AWS path if the values from s3Bucket are not None + - config (sentinelhub.SHConfig) : configuration object for sentinelhub API + - polygon (geopandas.GeoDataFrame) : input shapefile read as GeoDataFrame with one or multiple observations, each representing one field ID + - interpolation (dictionary) : interpolate missing pixels (clouds) if True and recalibrate time series into fixed time stamp (e.g 16 days if 'period_length' = 16) + - n_threads (int) : number of threads to download satellite images + ''' + + if interpolation is None : + interpolation = {'interpolate' : False, 'period_length' : None} + + # Request format to download Landsat8 L2A products + time_difference = datetime.timedelta(hours=2) + + # Request format to download L8 products + evalscript = """ + function setup() { + return { + input: [{ + bands: ['B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B11', 'B12', + 'viewZenithMean','sunZenithAngles','viewAzimuthMean', 'sunAzimuthAngles', 'CLM', "dataMask"], + units: ["REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", + "DEGREES", "DEGREES","DEGREES","DEGREES","DN","DN"] + }], + output: [ + { id:"BANDS", bands:10, sampleType: SampleType.FLOAT32 }, + { id:"ILLUMINATION", bands:4, sampleType: SampleType.FLOAT32 }, + { id:"CLM", bands:1, sampleType: SampleType.UINT8 }, + { id:"IS_DATA", bands:1, sampleType: SampleType.UINT8 } + ] + } + } + function evaluatePixel(sample) { + return { + BANDS: [sample.B02, sample.B03, sample.B04, sample.B05, sample.B06, sample.B07, sample.B08,sample.B8A, + sample.B11, sample.B12], + ILLUMINATION : [sample.viewZenithMean,sample.sunZenithAngles,sample.viewAzimuthMean, sample.sunAzimuthAngles], + CLM : [sample.CLM], + IS_DATA : [sample.dataMask] + + }; + } + """ + + input_task = SentinelHubEvalscriptTask( + features=[(FeatureType.DATA, 'BANDS', 'BANDS-S2-L2A'), + (FeatureType.DATA, 'ILLUMINATION', 'ILLUMINATION'), + (FeatureType.MASK, 'IS_DATA'), + (FeatureType.MASK, 'CLM')], + data_collection=DataCollection.SENTINEL2_L2A, + evalscript=evalscript, + resolution=10, + maxcc=coverage_predicate, + time_difference=time_difference, + config=config, + max_threads=n_threads + ) + + add_dem = SentinelHubDemTask('DEM', resolution=10, config=config) + + add_polygon_mask = preprocessing.PolygonMask(polygon) + field_bbox = utils.get_bounding_box(polygon) + + cloud_mask = utils_sh.CloudMaskS2L2A() + + add_coverage = utils_sh.AddValidDataCoverage() + + add_valid_mask = eolearn.mask.AddValidDataMaskTask(predicate=utils_sh.calculate_valid_data_mask) + + remove_cloudy_scenes = eolearn.features.SimpleFilterTask((eolearn.core.FeatureType.MASK, 'VALID_DATA'), + # name of output mask + utils_sh.ValidDataCoveragePredicate(coverage_predicate)) + + vis = vegetation_indices.VegetationIndicesS2('BANDS-S2-L2A', + mask_data=bool(1-interpolation['interpolate'])) + + norm = vegetation_indices.EuclideanNorm('ECNorm', 'BANDS-S2-L2A') + + if path_out is None: + save = utils_sh.EmptyTask() + else: + if not os.path.isdir(path_out) : + os.makedirs(path_out) + save = SaveTask(path_out, overwrite_permission=OverwritePermission.OVERWRITE_PATCH) + + if 'period_length' in interpolation.keys(): + if interpolation['period_length'] is not None: + resampled_range = (time_stamp[0], time_stamp[1], interpolation['period_length']) + else: + resampled_range = None + + copy_features = [(FeatureType.MASK, 'CLM'), + (FeatureType.DATA_TIMELESS, 'DEM'), + (FeatureType.MASK_TIMELESS, 'MASK')] + + + if interpolation['interpolate'] : + # Interpolate pixels cloudy + linear_interp = preprocessing.InterpolateFeatures(resampled_range = resampled_range, + copy_features=copy_features) + + else : + linear_interp = utils_sh.EmptyTask() + + workflow = eolearn.core.LinearWorkflow(input_task, + cloud_mask, add_valid_mask, + add_coverage, remove_cloudy_scenes, + add_dem, + add_polygon_mask, + vis, norm, + linear_interp, + save) + + result = workflow.execute({ + input_task : {'bbox' : field_bbox, 'time_interval' : time_stamp} + }) + return result.eopatch() + + + diff --git a/eo-crops/eocrops/input/utils_sh.py b/eo-crops/eocrops/input/utils_sh.py new file mode 100644 index 0000000..7b8a100 --- /dev/null +++ b/eo-crops/eocrops/input/utils_sh.py @@ -0,0 +1,141 @@ +import eolearn +from eolearn.core import EOTask, FeatureType +from sentinelhub import SHConfig +import numpy as np + + +def config_sentinelhub_cred(api, client_id, client_secret): + """ + Configure properly Sentinelhub credential fetching information from the configuration tool python class. + :return: + SHConfig + """ + + config = SHConfig() + + if client_id and client_secret and api: + config.instance_id = api + config.sh_client_id = client_id + config.sh_client_secret = client_secret + + return config + + +def calculate_valid_data_mask(eopatch) : + ''' Define which pixel will be masked from eo-patch + Inputs : + - eopatch : patch downloaded from eo-learn packages (eopatch object with arrays) + ''' + return np.logical_and(eopatch.mask['IS_DATA'].astype(np.bool), + np.logical_not(eopatch.mask['CLM'].astype(np.bool))) + + +def calculate_coverage(array) : + ''' Share of pixels not contaminated by clouds + Inputs : + - array : array from an eopatch object that contains information about cloud coverage (e.g Sentinel-2 L1C) + ''' + return 1.0-np.count_nonzero(array)/np.size(array) + + +class AddValidDataCoverage(EOTask) : + ''' Share of pixels not contaminated by clouds + Inputs : + - EOTask : workflow as EOTask object + ''' + + def execute(self, eopatch) : + valid_data = eopatch.get_feature(eolearn.core.FeatureType.MASK, 'VALID_DATA') + time, height, width, channels = valid_data.shape + + coverage = np.apply_along_axis(calculate_coverage, 1, valid_data.reshape((time, height*width*channels))) + + eopatch.add_feature(eolearn.core.FeatureType.SCALAR, 'COVERAGE', coverage[:, np.newaxis]) + + return eopatch + + +class SentinelHubValidData : + """ + Combine Sen2Cor's classification map with `IS_DATA` to define a `VALID_DATA_SH` mask + The sentinel_hub's cloud mask is asumed to be found in eopatch.mask['CLM'] + """ + + def __call__(self, eopatch) : + return np.logical_and(eopatch.mask['IS_DATA'].astype(np.bool), + np.logical_not(eopatch.mask['CLM'].astype(np.bool))) + +class CloudMaskS2L2A(EOTask) : + """ + The tasks recognize clouds from Sentinel Scene Layers (SCL) obtained from Sen2Corr + """ + def execute(self, eopatch) : + eopatch.add_feature(FeatureType.MASK, "VALID_DATA", (eopatch.mask['IS_DATA']).astype(bool)) + return eopatch + + + +class CloudMaskFromCLM(EOTask) : + """ + The tasks recognize clouds from Sentinel Scene Layers (SCL) obtained from Sen2Corr + NDI = (A-B)/(A+B). + """ + + def execute(self, eopatch) : + + CLM = eopatch.get_feature(FeatureType.MASK, 'CLM') + cloudy_f = list(CLM.flatten()) + + def return_na(x) : + if x in [1] : # [3, 4] : + return True + else : + return False + + g = np.array(list(map(lambda x : return_na(x), cloudy_f))) + g = g.reshape(CLM.shape[0], CLM.shape[1], CLM.shape[2]) + eopatch.add_feature(FeatureType.MASK, "IS_DATA", (1-g[..., np.newaxis]).astype(bool)) + eopatch.add_feature(FeatureType.MASK, "CLM", g[..., np.newaxis]) + eopatch.add_feature(FeatureType.MASK, "VALID_DATA", (1-g[..., np.newaxis]).astype(bool)) + + return eopatch + + +class CountValid(EOTask) : + """ + The task counts number of valid observations in time-series and stores the results in the timeless mask. + """ + + def __init__(self, count_what, feature_name) : + self.what = count_what + self.name = feature_name + + def execute(self, eopatch) : + eopatch.add_feature(FeatureType.MASK_TIMELESS, self.name, np.count_nonzero(eopatch.mask[self.what], axis=0)) + + return eopatch + + +class ValidDataCoveragePredicate : + ''' Keep an image only if below % of non contaminated pixels + Inputs : + - threshold (float) : upper bound of percentage of pixel predicted as cloudy + ''' + + def __init__(self, threshold) : + self.threshold = threshold + + def __call__(self, array) : + return calculate_coverage(array)1 : + bbox = self.geodataframe.geometry.total_bounds + polygon_mask = sentinelhub.BBox(bbox=[(bbox[0], bbox[1]), (bbox[2], bbox[3])], crs=self.geodataframe.crs) + self.geodataframe['MASK'] = polygon_mask.geometry + else : + self.geodataframe['MASK'] = self.geodataframe['geometry'] + + self.geodataframe['polygon_bool'] = True + + rasterization_task = VectorToRasterTask(self.geodataframe, (FeatureType.DATA_TIMELESS, "FIELD_ID"), + values_column="FIELD_ID", raster_shape=(FeatureType.MASK, 'IS_DATA'), + raster_dtype=np.uint16) + eopatch = rasterization_task.execute(eopatch) + + rasterization_task = VectorToRasterTask(self.geodataframe, + (FeatureType.MASK_TIMELESS, "MASK"), + values_column="polygon_bool", raster_shape=(FeatureType.MASK, 'IS_DATA'), + raster_dtype=np.uint16) + eopatch = rasterization_task.execute(eopatch) + + eopatch.mask_timeless['MASK'] = eopatch.mask_timeless['MASK'].astype(bool) + + return eopatch + + +class MaskPixels(EOTask): + def __init__(self, features, fname = 'MASK') : + ''' + Parameters + ---------- + feature (list): of features in data and/or data_timeless + fname (str): name of the mask + ''' + self.features = features + self.fname = fname + + @staticmethod + def _filter_array(patch, ftype, fname, mask) : + ivs = patch[ftype][fname] + + arr0 = np.ma.array(ivs, + dtype=np.float32, + mask=(1-mask).astype(bool), + fill_value=np.nan) + + arr0 = arr0.filled() + patch[ftype][fname] = arr0 + + return patch + + def execute(self, patch, erosion = 0): + copy_patch = copy.deepcopy(patch) + times = len(patch.timestamp) + if erosion: + erode = ErosionTask(mask_feature=(FeatureType.MASK_TIMELESS, self.fname), + disk_radius=erosion) + erode.execute(copy_patch) + + crop_mask = copy_patch["mask_timeless"][self.fname] + # Filter the pixels of each features + for index in self.features : + if index in list(patch.data.keys()) : + ftype = 'data' + shape = patch[ftype][index].shape[-1] + mask = crop_mask.reshape(1, crop_mask.shape[0], crop_mask.shape[1], 1) + mask = [mask for k in range(times)] + mask = np.concatenate(mask, axis=0) + mask = [mask for k in range(shape)] + mask = np.concatenate(mask, axis=-1) + else : + ftype = 'data_timeless' + mask = crop_mask + patch = self._filter_array(patch, ftype, index, mask) + + return patch + + + +class InterpolateFeatures(EOTask): + def __init__(self, resampled_range, algorithm = 'linear', copy_features = None, + features = None): + self.resampled_range = resampled_range + self.algorithm = algorithm + self.features = features + self.copy_features = copy_features + if self.features is None : + self.features = ['BANDS-S2-L2A', 'fapar', 'LAI', 'Cab', 'NDVI', 'EVI2', 'CVI', 'NDWI', 'GNDVI', 'GVMI', + 'SLAVI', 'NDDI', 'VSDI', 'ECNorm'] + + def _interpolate_feature(self, eopatch, feature, mask_feature): + + kwargs = dict(mask_feature=mask_feature, + copy_features=self.copy_features, + resample_range=self.resampled_range, + feature = [(FeatureType.DATA, feature)], + bounds_error=False) + + if self.algorithm=='linear' : + interp = LinearInterpolationTask( + parallel=True, + **kwargs + ) + elif self.algorithm=='cubic' : + interp = CubicInterpolationTask( + **kwargs + ) + eopatch = interp.execute(eopatch) + return eopatch + + + def execute(self, eopatch): + + '''Gap filling after data extraction, very useful if did not include it in the data extraction workflow''' + + dico = {} + mask_feature = None + if 'VALID_DATA' in list(eopatch.mask.keys()): + mask_feature = (FeatureType.MASK, 'VALID_DATA') + + for feature in self.features : + new_eopatch = copy.deepcopy(eopatch) + new_eopatch = self._interpolate_feature(new_eopatch, feature, mask_feature) + dico[feature] = new_eopatch.data[feature] + + eopatch['data'] = dico + t, h, w, _ = eopatch.data[feature].shape + eopatch.timestamp = new_eopatch.timestamp + eopatch['mask']['IS_DATA'] = np.zeros((t, h, w, 1))+1 + eopatch['mask']['VALID_DATA'] = (np.zeros((t, h, w, 1))+1).astype(bool) + if "CLM" in eopatch.mask.keys(): + eopatch.remove_feature(FeatureType.MASK, "CLM") + + return eopatch + + +def get_time_series_profile(patch, variable, mask_name, function = np.mean): + crop_mask = patch['mask_timeless'][mask_name].squeeze() + var = patch['data'][variable] + shape = var.shape[-1] + times = len(patch.timestamp) + # Transform mask from 3D to 4D + mask = crop_mask.reshape(1, crop_mask.shape[0], crop_mask.shape[1], 1) + mask = [mask for k in range(times)] + mask = np.concatenate(mask, axis=0) + ####################### + mask = [mask for k in range(shape)] + mask = np.concatenate(mask, axis=-1) + ######################## + a = np.ma.array(var, mask=(1-(mask==1)).astype(bool)) + ts_mean = np.ma.apply_over_axes(function, a, [1, 2]) + ts_mean = ts_mean.reshape(ts_mean.shape[0], ts_mean.shape[-1]) + ts_mean = ts_mean.data + return {variable: ts_mean[:, n].flatten() for n in range(shape)} + + diff --git a/eo-crops/eocrops/tasks/vegetation_indices.py b/eo-crops/eocrops/tasks/vegetation_indices.py new file mode 100644 index 0000000..cf6bb60 --- /dev/null +++ b/eo-crops/eocrops/tasks/vegetation_indices.py @@ -0,0 +1,340 @@ +import math +from eolearn.core import FeatureType, EOTask +import numpy as np + + + +class VegetationIndicesVHRS(EOTask): + def __init__(self, feature_name) : + self.feature_name = feature_name + + def calcul_ratio_vegetation_indices(self): + self.NDVI = (self.B4 - self.B3)/(self.B4 + self.B3) + self.NDWI = (self.B2 - self.B4)/(self.B2 + self.B4) + #self.MSAVI2 = (2*self.B4 + 1 - ((2*self.B4 +1)^2)**0.5 - 8*(self.B4 - self.B3))/2 + self.VARI = (self.B2 - self.B3)/(self.B2 + self.B3 - self.B1) + + def execute(self, eopatch, **kwargs): + arr0 = eopatch.data[self.feature_name] + + # Raw data + self.B1 = arr0[..., 0] + self.B2 = arr0[..., 1] + self.B3 = arr0[..., 2] + self.B4 = arr0[..., 3] + #VIS + self.calcul_ratio_vegetation_indices() + eopatch.add_feature(FeatureType.DATA, "NDVI", self.NDVI[..., np.newaxis]) + eopatch.add_feature(FeatureType.DATA, "NDWI", self.NDWI[..., np.newaxis]) + eopatch.add_feature(FeatureType.DATA, "VARI", self.VARI[..., np.newaxis]) + + return eopatch + + + +class BiophysicalIndices: + def __init__(self,B03, B04,B05, B06, B07,B8A,B11, B12, viewZenithMean, sunZenithAngles, viewAzimuthMean,sunAzimuthAngles): + '''EOPatch should contains only 10 and 20m bands + illumination properties, as in eocrops.input.sentinel2''' + self.B03 = B03 + self.B04 = B04 + self.B05 = B05 + self.B06 = B06 + self.B07 = B07 + self.B8A = B8A + self.B11 = B11 + self.B12 = B12 + self.viewZenithMean = viewZenithMean + self.sunZenithAngles = sunZenithAngles + self.viewAzimuthMean = viewAzimuthMean + self.sunAzimuthAngles = sunAzimuthAngles + + @staticmethod + def _normalize(unnormalized, mini, maxi) : + '''Normalize input Neural Network''' + return 2*(unnormalized-mini)/(maxi-mini)-1 + + @staticmethod + def _denormalize(normalized, mini, maxi) : + '''Denormalize output Neural Network''' + return 0.5*(normalized+1)*(maxi-mini)+mini + + @staticmethod + def _funccos(t): + return np.vectorize(lambda t : math.cos(t)) + + @staticmethod + def _neuron(cste, w_b03, w_b04, w_b05, w_b06, w_b07, w_b8A, w_b11, w_b12, w_viewZen_norm, w_sunZen_norm, + w_relAzim_norm, b03_norm, b04_norm, b05_norm, b06_norm, b07_norm, b8a_norm, b11_norm, b12_norm, + viewZen_norm, sunZen_norm, relAzim_norm) : + + def tansig(input_neuron) : + '''Activation function neural network''' + funcexp = np.vectorize(lambda t : math.exp(t)) + return 2/(1+funcexp(-2*input_neuron))-1 + + '''Define the neuron, which is a linear combination of the metadata of sentinel2 images''' + + var_sum = cste+w_b03*b03_norm+w_b04*b04_norm+w_b05*b05_norm+w_b06*b06_norm + var_sum += w_b07*b07_norm+w_b8A*b8a_norm+w_b11*b11_norm+w_b12*b12_norm + var_sum += w_viewZen_norm*viewZen_norm+w_sunZen_norm*sunZen_norm+w_relAzim_norm*relAzim_norm + + return tansig(var_sum) + + @staticmethod + def _layer2(cste, w_n1, neuron1, w_n2, neuron2, w_n3, neuron3, w_n4, neuron4, w_n5, neuron5) : + '''Define the second layer, which is a linear combination of the neurons => input of the activation function''' + return cste+w_n1*neuron1+w_n2*neuron2+w_n3*neuron3+w_n4*neuron4+w_n5*neuron5 + + def apply_normalize(self) : + self.b03_norm = self._normalize(self.B03, 0, 0.253061520471542) + self.b04_norm = self._normalize(self.B04, 0, 0.290393577911328) + self.b05_norm = self._normalize(self.B05, 0, 0.305398915248555) + self.b06_norm = self._normalize(self.B06, 0.006637972542253, 0.608900395797889) + self.b07_norm = self._normalize(self.B07, 0.013972727018939, 0.753827384322927) + self.b8a_norm = self._normalize(self.B8A, 0.026690138082061, 0.782011770669178) + self.b11_norm = self._normalize(self.B11, 0.016388074192258, 0.493761397883092) + self.b12_norm = self._normalize(self.B12, 0, 0.493025984460231) + + degToRad = math.pi/180 + funccos = np.vectorize(lambda t : math.cos(t)) + + self.viewZen_norm = self._normalize(funccos(self.viewZenithMean*degToRad), 0.918595400582046, 1) + self.sunZen_norm = self._normalize(funccos(self.sunZenithAngles*degToRad), 0.342022871159208, 0.936206429175402) + self.relAzim_norm = funccos((self.sunAzimuthAngles-self.viewAzimuthMean)*degToRad) + + + def get_LAI(self) : + '''Define biophysical vegetation index Leaf Area Index, computed from a trained neural network which has as input the metadata of sentinel2 images''' + + n1 = self._neuron(4.96238030555279, - 0.023406878966470, + 0.921655164636366, + 0.135576544080099, - 1.938331472397950, - 3.342495816122680, + 0.902277648009576, 0.205363538258614, - 0.040607844721716, + -0.083196409727092, 0.260029270773809, 0.284761567218845, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n2 = self._neuron(1.416008443981500, - 0.132555480856684, - 0.139574837333540, + - 1.014606016898920, - 1.330890038649270, 0.031730624503341, + - 1.433583541317050, - 0.959637898574699, + 1.133115706551000, + 0.216603876541632, 0.410652303762839, 0.064760155543506, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n3 = self._neuron(1.075897047213310, 0.086015977724868, 0.616648776881434, + 0.678003876446556, 0.141102398644968, - 0.096682206883546, + - 1.128832638862200, 0.302189102741375, 0.434494937299725, + - 0.021903699490589, - 0.228492476802263, - 0.039460537589826, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n4 = self._neuron(1.533988264655420, - 0.109366593670404, - 0.071046262972729, + + 0.064582411478320, 2.906325236823160, - 0.673873108979163, + - 3.838051868280840, 1.695979344531530, 0.046950296081713, + - 0.049709652688365, 0.021829545430994, 0.057483827104091, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n5 = self._neuron(3.024115930757230, - 0.089939416159969, 0.175395483106147, + - 0.081847329172620, 2.219895367487790, 1.713873975136850, + 0.713069186099534, 0.138970813499201, - 0.060771761518025, + 0.124263341255473, 0.210086140404351, - 0.183878138700341, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + l2 = self._layer2(1.096963107077220, -1.500135489728730, n1, -0.096283269121503, n2, - 0.194935930577094, n3, + - 0.352305895755591, n4, 0.075107415847473, n5) + + return self._denormalize(l2, 0.000319182538301, 14.4675094548151) + + def get_Cab(self) : + '''Define biochemical vegetation index Chloro a+b, computed from a trained neural network which has as input the metadata of sentinel2 images''' + + n1 = self._neuron(4.242299670155190, 0.400396555256580, 0.607936279259404, + 0.137468650780226, - 2.955866573461640, - 3.186746687729570, + 2.206800751246430, - 0.313784336139636, + 0.256063547510639, + -0.071613219805105, 0.510113504210111, 0.142813982138661, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n2 = self._neuron(- 0.259569088225796, - 0.250781102414872, 0.439086302920381, + - 1.160590937522300, - 1.861935250269610, 0.981359868451638, + 1.634230834254840, - 0.872527934645577, 0.448240475035072, + 0.037078083501217, 0.030044189670404, 0.005956686619403, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n3 = self._neuron(3.130392627338360, 0.552080132568747, - 0.502919673166901, + 6.105041924966230, - 1.294386119140800, - 1.059956388352800, + - 1.394092902418820, 0.324752732710706, - 1.758871822827680, + - 0.036663679860328, - 0.183105291400739, - 0.038145312117381, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n4 = self._neuron(0.774423577181620, 0.211591184882422, - 0.248788896074327, + 0.887151598039092, 1.143675895571410, - 0.753968830338323, + - 1.185456953076760, 0.541897860471577, - 0.252685834607768, + - 0.023414901078143, - 0.046022503549557, - 0.006570284080657, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n5 = self._neuron(2.584276648534610, 0.254790234231378, - 0.724968611431065, + 0.731872806026834, 2.303453821021270, - 0.849907966921912, + - 6.425315500537270, 2.238844558459030, - 0.199937574297990, + 0.097303331714567, 0.334528254938326, 0.113075306591838, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + l2 = self._layer2(0.463426463933822, - 0.352760040599190, n1, - 0.603407399151276, n2, 0.135099379384275, n3, + - 1.735673123851930, n4, - 0.147546813318256, n5) + + return self._denormalize(l2, 0.007426692959872, 873.908222110306)/10 + + def get_FAPAR(self) : + '''Define biophysical vegetation index Fraction of Absorbed Photosynthetically Active Radiation, computed from a trained neural network which has as input the metadata of sentinel2 images''' + n1 = self._neuron(- 0.887068364040280, 0.268714454733421, - 0.205473108029835, + 0.281765694196018, 1.337443412255980, 0.390319212938497, + - 3.612714342203350, 0.222530960987244, 0.821790549667255, + - 0.093664567310731, 0.019290146147447, 0.037364446377188, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n2 = self._neuron(0.320126471197199, - 0.248998054599707, - 0.571461305473124, + - 0.369957603466673, 0.246031694650909, 0.332536215252841, + 0.438269896208887, 0.819000551890450, - 0.934931499059310, + 0.082716247651866, - 0.286978634108328, - 0.035890968351662, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n3 = self._neuron(0.610523702500117, - 0.164063575315880, - 0.126303285737763, + - 0.253670784366822, - 0.321162835049381, 0.067082287973580, + 2.029832288655260, - 0.023141228827722, - 0.553176625657559, + 0.059285451897783, - 0.034334454541432, - 0.031776704097009, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n4 = self._neuron(- 0.379156190833946, 0.130240753003835, 0.236781035723321, + 0.131811664093253, - 0.250181799267664, - 0.011364149953286, + - 1.857573214633520, - 0.146860751013916, 0.528008831372352, + - 0.046230769098303, - 0.034509608392235, 0.031884395036004, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + n5 = self._neuron(1.353023396690570, - 0.029929946166941, 0.795804414040809, + 0.348025317624568, 0.943567007518504, - 0.276341670431501, + - 2.946594180142590, 0.289483073507500, 1.044006950440180, + - 0.000413031960419, 0.403331114840215, 0.068427130526696, + self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm, + self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm, + self.viewZen_norm, self.sunZen_norm, self.relAzim_norm) + + l2 = self._layer2(- 0.336431283973339, 2.126038811064490, n1, - 0.632044932794919, n2, 5.598995787206250, n3, + 1.770444140578970, n4, - 0.267879583604849, n5) + + return self._denormalize(l2, 0.000153013463222, 0.977135096979553) + + + + +class VegetationIndicesS2(EOTask) : + '''Define a class of vegetation indices, which are computed from the metadata of sentinel2 images extracted''' + + def __init__(self, feature_name, mask_data=True) : + self.feature_name = feature_name + self.mask_data = mask_data + + def get_vegetation_indices(self) : + '''Define vegetation indices which are simply ratio of spectral bands''' + self.NDVI = (self.B8A-self.B04)/(self.B8A+self.B04) + self.NDWI = (self.B8A-self.B11)/(self.B8A+self.B11) + self.GNDVI = (self.B8A-self.B03)/(self.B8A+self.B03) + + biopysicial_parameters = BiophysicalIndices(self.B03, self.B04, self.B05, self.B06, self.B07, self.B8A, self.B11, self.B12, + self.viewZenithMean, self.sunZenithAngles, self.viewAzimuthMean, self.sunAzimuthAngles) + # Normalized bands + biopysicial_parameters.apply_normalize() + + self.fapar = biopysicial_parameters.get_FAPAR() + self.LAI = biopysicial_parameters.get_LAI() + self.Cab = biopysicial_parameters.get_Cab() + + + def execute(self, eopatch) : + '''Add those vegeation indices to the eo-patch for futur use''' + + bands_array = eopatch.data[self.feature_name] + illumination_array = eopatch.data['ILLUMINATION'] + + valid_data_mask = eopatch.mask['VALID_DATA'] if self.mask_data else eopatch.mask['IS_DATA'] + + if 'polygon_mask' in list(eopatch.mask_timeless.keys()) : + + bands_array = np.ma.array(bands_array, + dtype=np.float32, + mask=np.logical_or(~valid_data_mask.astype(np.bool), np.isnan(bands_array)), + fill_value=np.nan) + bands_array = bands_array.filled() + + # Raw data + self.B02 = bands_array[..., 0] + self.B03 = bands_array[..., 1] + self.B04 = bands_array[..., 2] + self.B05 = bands_array[..., 3] + self.B06 = bands_array[..., 4] + self.B07 = bands_array[..., 5] + self.B08 = bands_array[..., 6] + self.B8A = bands_array[..., 7] + self.B11 = bands_array[..., 8] + self.B12 = bands_array[..., 9] + self.viewZenithMean = illumination_array[..., 0] + self.sunZenithAngles = illumination_array[..., 1] + self.viewAzimuthMean = illumination_array[..., 2] + self.sunAzimuthAngles = illumination_array[..., 3] + + self.get_vegetation_indices() + eopatch.add_feature(FeatureType.DATA, "fapar", self.fapar[..., np.newaxis]) + eopatch.add_feature(FeatureType.DATA, "LAI", self.LAI[..., np.newaxis]) + eopatch.add_feature(FeatureType.DATA, "Cab", self.Cab[..., np.newaxis]) + eopatch.add_feature(FeatureType.DATA, "NDVI", self.NDVI[..., np.newaxis]) + eopatch.add_feature(FeatureType.DATA, "NDWI", self.EVI2[..., np.newaxis]) + eopatch.remove_feature(FeatureType.DATA, "ILLUMINATION") + + return eopatch + + + + +class EuclideanNorm(EOTask) : + """ + The tasks calculates Euclidian Norm of all bands within an array: + norm = sqrt(sum_i Bi**2), + where Bi are the individual bands within user-specified feature array. + """ + + def __init__(self, feature_name, in_feature_name) : + self.feature_name = feature_name + self.in_feature_name = in_feature_name + + def execute(self, eopatch) : + arr = eopatch.data[self.in_feature_name] + norm = np.sqrt(np.sum(arr**2, axis=-1)) + + eopatch.add_feature(FeatureType.DATA, self.feature_name, norm[..., np.newaxis]) + return eopatch + + + + diff --git a/eo-crops/eocrops/utils/__init__.py b/eo-crops/eocrops/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/eo-crops/eocrops/utils/utils.py b/eo-crops/eocrops/utils/utils.py new file mode 100644 index 0000000..ddb954c --- /dev/null +++ b/eo-crops/eocrops/utils/utils.py @@ -0,0 +1,81 @@ +import sentinelhub +from sentinelhub import CRS +import math +from shapely.geometry import * + +import rasterio +import warnings + +import numpy as np + + + +def MetaInfos(saving_path, N) : + with rasterio.open(saving_path) as src0 : + meta = src0.meta + meta['nodata'] = np.nan + meta['dtype'] = 'float32' + + meta.update(count=N) + meta.update(nodata=np.nan) + + return meta + + +def WriteTiff(array, saving_path, meta, dim=1) : + with rasterio.open(saving_path, 'w', **meta) as dst : + if dim>1 : + for id in range(dim) : + dst.write_band(id+1, array[:, :, id].astype(np.float32)) + else : + dst.write_band(1, array.astype(np.float32)) + + +def check_crs(reference_file_) : + reference_file = reference_file_.copy() + reference_file_crs = reference_file.crs + if reference_file_crs is None : + reference_file.set_crs(epsg=4326, inplace=True) + warnings.warn('Your input GeoDataFrame should have a CRS! By default, it will set to WGS84') + elif str(reference_file_crs).split(':')[-1]!='4326' : + reference_file.to_crs(epsg=4326, inplace=True) + + xmin, ymin, xmax, ymax = reference_file.geometry.iloc[0].bounds + utm_crs = str(CRS.get_utm_from_wgs84(xmin, ymin)) + reference_file.to_crs(utm_crs, inplace=True) + + return reference_file + + +def get_bounding_box(shapefile): + ''' Get the bounding box of a given polygon for sentinelhub request + Inputs : + - polygon (geometry object) : polygon of a field + ''' + shapefile = check_crs(shapefile) + xmin, ymin, xmax, ymax = shapefile.geometry.total_bounds + return sentinelhub.BBox( + bbox=[(xmin, ymin), (xmax, ymax)], crs=str(shapefile.crs) + ) + + +def create_polygon_bbox(longitude, latitude, distance) : + + + r_earth = 6378 + dx = distance/1000 + dy = distance/1000 + + ic_x = (dx/r_earth)*(180/math.pi)/math.cos(latitude*math.pi/180) + ic_y = (dy/r_earth)*(180/math.pi) + + + return box(longitude-ic_x, + latitude-ic_y, + longitude+ic_x, + latitude+ic_y) + + + + + diff --git a/eo-crops/examples/Sentinel data.ipynb b/eo-crops/examples/Sentinel data.ipynb new file mode 100644 index 0000000..53c23d3 --- /dev/null +++ b/eo-crops/examples/Sentinel data.ipynb @@ -0,0 +1,446 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5ca6a8c8-2b6b-4734-8c5e-b0c2bd4b03cb", + "metadata": {}, + "source": [ + "# Sentinel" + ] + }, + { + "cell_type": "markdown", + "id": "7e8ef3e1-fac8-4e7d-b619-1d529d2da6d2", + "metadata": {}, + "source": [ + "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and predfin. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n", + "\n", + "The workflow for agriculture purposes is as follows :\n", + "\n", + "1) Read shapefile that represent you field (boundaries or microplots)\n", + "\n", + "2) Extract Sentinel-2 data and compute averaged NDVI time series to get a summary of the season vegetation dynamic.\n", + "\n", + "2) Extract Sentinel-1 data and apply multitemporal speckle filtering" + ] + }, + { + "cell_type": "markdown", + "id": "18f4338d-47d3-4680-8949-48dce4d1ec42", + "metadata": {}, + "source": [ + "## Set your working environment" + ] + }, + { + "cell_type": "markdown", + "id": "5ff84548-45ed-4c18-8c26-66c38b4c2f89", + "metadata": {}, + "source": [ + "### Import the packages" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "id": "9f951ed2-adb4-422a-b4c1-e0a0151cc0f9", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import geopandas as gpd\n", + "from scipy.signal import savgol_filter\n", + "\n", + "import os\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from eolearn.core import FeatureType\n", + "\n", + "from eocrops.input import utils_sh as utils_sh\n", + "from eocrops.input import sentinel1 as sentinel1\n", + "from eocrops.input import sentinel2 as sentinel2\n", + "from eocrops.tasks import cmd_otb as cmd_otb\n", + "from eocrops.tasks import preprocessing as preprocessing\n" + ] + }, + { + "cell_type": "markdown", + "id": "7325554a-5b71-4c54-89ce-9b087ba054c0", + "metadata": {}, + "source": [ + "### Read your vector file" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "id": "c525df92-c794-4867-b2f1-1021dee5c076", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/s999379/git-repo/eo-crops\n" + ] + } + ], + "source": [ + "dir_path = os.path.dirname(os.getcwd())\n", + "print(dir_path)\n", + "#read microplot data\n", + "shapefile_input = gpd.read_file(os.path.join(dir_path, './examples/layers/POLYGON.shp'))" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "id": "579eb42f-4c25-44f6-aea1-af65cc077887", + "metadata": {}, + "outputs": [], + "source": [ + "api =''\n", + "client_id =''\n", + "client_secret =''\n", + "config = utils_sh.config_sentinelhub_cred(api, client_id, client_secret)\n", + "#Provide here your planet API key \n", + "config.planet_key = ''" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "0a33c406-7066-49eb-b693-45e931395bba", + "metadata": {}, + "outputs": [], + "source": [ + "kwargs = dict(polygon=shapefile_input,\n", + " time_stamp=time_period,\n", + " config=config)" + ] + }, + { + "cell_type": "markdown", + "id": "4f173e0b-e236-4882-bff9-c16f25e76407", + "metadata": {}, + "source": [ + "## Extract S2 data" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "id": "1c34d76b-ab4b-4ed8-989c-7ba450df5337", + "metadata": {}, + "outputs": [], + "source": [ + "patch = sentinel2.workflow_instructions_S2L2A(**kwargs,\n", + " path_out = None, #you can specify here a path to save the EOPatch object\n", + " coverage_predicate=0.5,\n", + " interpolation={'interpolate' : True,\n", + " 'period_length' : 8}) # you can add period_length in the dictionary to resample\n" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "7ac5fbd7-bd82-489c-847f-08012095c0aa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "