diff --git a/.github/ISSUE_TEMPLATE/epic.yaml b/.github/ISSUE_TEMPLATE/epic.yaml new file mode 100644 index 0000000000..23c3bf51d3 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/epic.yaml @@ -0,0 +1,39 @@ +name: 🎯 Epic +description: A large body of work that can be broken down into smaller stories +title: "🎯 [EPIC] " +labels: ["epic"] +assignees: [] +body: + - type: markdown + attributes: + value: "## 🎯 Epic Description" + - type: textarea + id: description + attributes: + label: Describe the epic + description: Provide a clear and concise description of what this epic encompasses + validations: + required: true + - type: textarea + id: goals + attributes: + label: Goals + description: What are the main goals of this epic? + validations: + required: true + - type: textarea + id: tasks + attributes: + label: Tasks + description: Break down the epic into smaller tasks. Add or remove tasks as needed. + value: | + - [ ] Task 1: + - [ ] Task 2: + - [ ] Task 3: + - [ ] Task 4: + - [ ] Task 5: + validations: + required: true + - type: markdown + attributes: + value: "Remember to create separate issues for each task and link them to this epic." diff --git a/.github/ISSUE_TEMPLATE/task.yaml b/.github/ISSUE_TEMPLATE/task.yaml index 9369e33c96..065712d1dc 100644 --- a/.github/ISSUE_TEMPLATE/task.yaml +++ b/.github/ISSUE_TEMPLATE/task.yaml @@ -1,35 +1,65 @@ -name: Tasks -description: This is used to capture tasks being implemented/to implement such as features, maintenance, refactor, etc. -title: "[Task]: " -labels: ["Task"] +name: 📋 Task +description: A specific piece of work to be completed +title: "📋 [TASK] " +labels: ["task"] +assignees: [] body: - type: markdown attributes: - value: | - We encourage our users to submit feature requests in our [Discussion forum](https://github.com/openvinotoolkit/anomalib/discussions/categories/ideas-feature-requests). You can use this template for consistency. - + value: "## 📋 Task Description" - type: textarea - id: motivation + id: description attributes: - label: What is the motivation for this task? - description: A clear and concise description of what the problem is. - placeholder: | - 1. I'm always frustrated when [...]. It would be better if we could [...] - 2. I would like to have [...] model/dataset to be supported in Anomalib. + label: Describe the task + description: Provide a clear and concise description of the task to be completed validations: required: true - type: textarea - id: solution + id: acceptance-criteria attributes: - label: Describe the solution you'd like - description: A clear and concise description of what you want to happen. Add screenshots or code-blocks if necessary. - placeholder: | - I would like to have [...] to do this we would need to [...] - Here is what I would like to see [...] + label: Acceptance Criteria + description: List the specific criteria that must be met for this task to be considered complete + validations: + required: true + - type: dropdown + id: priority + attributes: + label: Priority + options: + - Low + - Medium + - High + validations: + required: true + - type: input + id: epic-link + attributes: + label: Related Epic + description: If this task is part of an epic, provide the epic's issue number (e.g., #123) + validations: + required: false + - type: input + id: estimated-time + attributes: + label: Estimated Time + description: Provide an estimate of how long this task will take (e.g., 2h, 1d) + validations: + required: false + - type: dropdown + id: status + attributes: + label: Current Status + options: + - Not Started + - In Progress + - Blocked + - Ready for Review validations: required: true - type: textarea - id: additional-context + id: additional-info attributes: - label: Additional context - description: Add any other context or screenshots about the feature request here. + label: Additional Information + description: Any other relevant details or context for this task + validations: + required: false diff --git a/.github/ISSUE_TEMPLATE/user_story.yaml b/.github/ISSUE_TEMPLATE/user_story.yaml new file mode 100644 index 0000000000..c32d1e45ea --- /dev/null +++ b/.github/ISSUE_TEMPLATE/user_story.yaml @@ -0,0 +1,69 @@ +name: 📖 User Story +description: A small, self-contained unit of development work describing a feature from an end-user perspective +title: "📖 [STORY] " +labels: ["user-story"] +assignees: [] +body: + - type: markdown + attributes: + value: "## 📖 User Story Description" + - type: textarea + id: user-story + attributes: + label: User Story + description: As a [type of user], I want [an action] so that [a benefit/a value] + placeholder: As a computer vision researcher, I want to implement a new anomaly detection algorithm so that I can improve detection accuracy for industrial defect scenarios. + validations: + required: true + - type: textarea + id: acceptance-criteria + attributes: + label: Acceptance Criteria + description: List the acceptance criteria for this user story + placeholder: | + 1. The new algorithm is implemented and integrated into the anomalib framework + 2. Unit tests are written and pass for the new implementation + 3. Performance benchmarks show improvement over existing methods on specified datasets + 4. Documentation is updated to include usage instructions and theory behind the new algorithm + 5. An example notebook is provided demonstrating the algorithm's application + validations: + required: true + - type: input + id: story-points + attributes: + label: Story Points + description: Estimate the complexity of this story (e.g., 1, 2, 3, 5, 8, 13) + validations: + required: true + - type: input + id: epic-link + attributes: + label: Related Epic + description: If this story is part of an epic, provide the epic's issue number (e.g., #123) + validations: + required: false + - type: dropdown + id: model-category + attributes: + label: Category + description: Select the category this story primarily relates to + options: + - Data + - Anomaly Detection Algorithms + - Pre-processing + - Post-processing + - Evaluation Metrics + - Visualization + - Performance Optimization + - API/Interface + - Documentation + - Others + validations: + required: true + - type: textarea + id: additional-context + attributes: + label: Additional Context + description: Add any other context, background, or relevant research papers about the user story here + validations: + required: false diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index e430544a18..cbed44683d 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -15,7 +15,7 @@ repos: # Ruff version. - repo: https://github.com/charliermarsh/ruff-pre-commit - rev: "v0.5.1" + rev: "v0.6.2" hooks: # Run the linter. - id: ruff @@ -27,7 +27,7 @@ repos: # python static type checking - repo: https://github.com/pre-commit/mirrors-mypy - rev: "v1.10.1" + rev: "v1.11.2" hooks: - id: mypy additional_dependencies: [types-PyYAML, types-setuptools] @@ -43,7 +43,7 @@ repos: # notebooks. - repo: https://github.com/nbQA-dev/nbQA - rev: 1.8.5 + rev: 1.8.7 hooks: - id: nbqa-ruff # Ignore unsorted imports. This is because jupyter notebooks can import diff --git a/CHANGELOG.md b/CHANGELOG.md index fc80fa3e7e..dedec2f441 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,62 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). ### New Contributors +## [v1.2.0] + +### Added + +- 🚀 Add ensembling methods for tiling to Anomalib by @blaz-r in https://github.com/openvinotoolkit/anomalib/pull/1226 +- 📚 optimization/quantization added into 500 series by @paularamo in https://github.com/openvinotoolkit/anomalib/pull/2197 +- 🚀 Add PIMO by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2329 +- 📚 Add PIMO tutorial advanced i (fixed) by @jpcbertoldo in https://github.com/openvinotoolkit/anomalib/pull/2336 +- 🚀 Add VLM based Anomaly Model by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2344 +- 📚 Add PIMO tutorials/02 advanced ii by @jpcbertoldo in https://github.com/openvinotoolkit/anomalib/pull/2347 +- 📚 Add PIMO tutorials/03 advanced iii by @jpcbertoldo in https://github.com/openvinotoolkit/anomalib/pull/2348 +- 📚 Add PIMO tutorials/04 advanced iv by @jpcbertoldo in https://github.com/openvinotoolkit/anomalib/pull/2352 +- 🚀 Add datumaro annotation dataloader by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2377 +- 📚 Add training from a checkpoint example by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2389 + +### Changed + +- 🔨 Refactor folder3d to avoid complex-structure (C901) issue by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2185 +- Update open-clip-torch requirement from <2.26.1,>=2.23.0 to >=2.23.0,<2.26.2 by @dependabot in https://github.com/openvinotoolkit/anomalib/pull/2189 +- Update sphinx requirement by @dependabot in https://github.com/openvinotoolkit/anomalib/pull/2235 +- Refactor Lightning's `trainer.model` to `trainer.lightning_module` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2255 +- Revert "Update open-clip-torch requirement from <2.26.1,>=2.23.0 to >=2.23.0,<2.26.2" by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2270 +- Update ruff configuration by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2269 +- Update timm requirement by @dependabot in https://github.com/openvinotoolkit/anomalib/pull/2274 +- Refactor BaseThreshold to Threshold by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2278 +- 🔨 Lint: Update Ruff Config - Add Missing Copyright Headers by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2281 +- Reduce rich methods by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2283 +- Enable Ruff Rules: PLW1514 and PLR6201 by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2284 +- Update nncf export by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2286 +- Linting: Enable `PLR6301`, # could be a function, class method or static method by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2288 +- 🐞 Update `setuptools` requirement for PEP 660 support by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2320 +- 🔨 Update the issue templates by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2363 +- 🐞 Defer OpenVINO import to avoid unnecessary warnings by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2385 +- 🔨 Make single GPU benchmarking 5x more efficient by @mzweilin in https://github.com/openvinotoolkit/anomalib/pull/2390 +- 🐞 Export the flattened config in benchmark CSV. by @mzweilin in https://github.com/openvinotoolkit/anomalib/pull/2391 +- 🔨 Export experiment duration in seconds in CSV. by @mzweilin in https://github.com/openvinotoolkit/anomalib/pull/2392 +- 🐞 Fix installation package issues by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2395 + +### Deprecated + +- 🔨 Deprecate try import and replace it with Lightning's package_available by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2373 + +### Fixed + +- Add check before loading metrics data from checkpoint by @blaz-r in https://github.com/openvinotoolkit/anomalib/pull/2323 +- Fix transforms for draem, dsr and rkde by @blaz-r in https://github.com/openvinotoolkit/anomalib/pull/2324 +- Makes batch size dynamic by @Marcus1506 in https://github.com/openvinotoolkit/anomalib/pull/2339 + +## New Contributors + +- @Marcus1506 made their first contribution in https://github.com/openvinotoolkit/anomalib/pull/2339 + +**Full Changelog**: https://github.com/openvinotoolkit/anomalib/compare/v1.1.1...v1.2.0 + +### New Contributors + **Full Changelog**: ## [v1.1.1] diff --git a/configs/data/datumaro.yaml b/configs/data/datumaro.yaml new file mode 100644 index 0000000000..31867f34fa --- /dev/null +++ b/configs/data/datumaro.yaml @@ -0,0 +1,15 @@ +class_path: anomalib.data.Datumaro +init_args: + root: "datasets/datumaro" + train_batch_size: 32 + eval_batch_size: 32 + num_workers: 8 + image_size: null + transform: null + train_transform: null + eval_transform: null + test_split_mode: FROM_DIR + test_split_ratio: 0.2 + val_split_mode: FROM_TEST + val_split_ratio: 0.5 + seed: null diff --git a/configs/data/shanghaitec.yaml b/configs/data/shanghaitech.yaml similarity index 100% rename from configs/data/shanghaitec.yaml rename to configs/data/shanghaitech.yaml diff --git a/docs/source/conf.py b/docs/source/conf.py index 4f3932351e..16e79a59af 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -7,6 +7,9 @@ https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information """ +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + from __future__ import annotations import sys diff --git a/docs/source/images/tiled_ensemble/ensemble_flow.png b/docs/source/images/tiled_ensemble/ensemble_flow.png new file mode 100644 index 0000000000..7a5a81fa79 Binary files /dev/null and b/docs/source/images/tiled_ensemble/ensemble_flow.png differ diff --git a/docs/source/markdown/get_started/anomalib.md b/docs/source/markdown/get_started/anomalib.md index 37af563b3e..4580c7fae5 100644 --- a/docs/source/markdown/get_started/anomalib.md +++ b/docs/source/markdown/get_started/anomalib.md @@ -17,7 +17,7 @@ The installer can be installed using the following commands: :::{tab-item} API :sync: label-1 -```{literalinclude} ../../snippets/install/pypi.txt +```{literalinclude} /snippets/install/pypi.txt :language: bash ``` @@ -26,7 +26,7 @@ The installer can be installed using the following commands: :::{tab-item} Source :sync: label-2 -```{literalinclude} ../../snippets/install/source.txt +```{literalinclude} /snippets/install/source.txt :language: bash ``` @@ -42,7 +42,7 @@ The next section demonstrates how to install the full package using the CLI inst :::::{dropdown} Installing the Full Package After installing anomalib, you can install the full package using the following commands: -```{literalinclude} ../../snippets/install/anomalib_help.txt +```{literalinclude} /snippets/install/anomalib_help.txt :language: bash ``` @@ -50,14 +50,14 @@ As can be seen above, the only available sub-command is `install` at the moment. The `install` sub-command has options to install either the full package or the specific components of the package. -```{literalinclude} ../../snippets/install/anomalib_install_help.txt +```{literalinclude} /snippets/install/anomalib_install_help.txt :language: bash ``` By default the `install` sub-command installs the full package. If you want to install only the specific components of the package, you can use the `--option` flag. -```{literalinclude} ../../snippets/install/anomalib_install.txt +```{literalinclude} /snippets/install/anomalib_install.txt :language: bash ``` @@ -66,13 +66,15 @@ After following these steps, your environment will be ready to use anomalib! ## {octicon}`mortar-board` Training -Anomalib supports both API and CLI-based training. The API is more flexible and allows for more customization, while the CLI training utilizes command line interfaces, and might be easier for those who would like to use anomalib off-the-shelf. +Anomalib supports both API and CLI-based training. The API is more flexible +and allows for more customization, while the CLI training utilizes command line +interfaces, and might be easier for those who would like to use anomalib off-the-shelf. ::::{tab-set} :::{tab-item} API -```{literalinclude} ../../snippets/train/api/default.txt +```{literalinclude} /snippets/train/api/default.txt :language: python ``` @@ -80,7 +82,7 @@ Anomalib supports both API and CLI-based training. The API is more flexible and :::{tab-item} CLI -```{literalinclude} ../../snippets/train/cli/default.txt +```{literalinclude} /snippets/train/cli/default.txt :language: bash ``` @@ -100,7 +102,7 @@ Anomalib includes multiple inferencing scripts, including Torch, Lightning, Grad :::{tab-item} API :sync: label-1 -```{literalinclude} ../../snippets/inference/api/lightning.txt +```{literalinclude} /snippets/inference/api/lightning.txt :language: python ``` @@ -109,7 +111,7 @@ Anomalib includes multiple inferencing scripts, including Torch, Lightning, Grad :::{tab-item} CLI :sync: label-2 -```{literalinclude} ../../snippets/inference/cli/lightning.txt +```{literalinclude} /snippets/inference/cli/lightning.txt :language: bash ``` @@ -201,7 +203,7 @@ Anomalib supports hyper-parameter optimization using [wandb](https://wandb.ai/) :::{tab-item} CLI -```{literalinclude} ../../snippets/pipelines/hpo/cli.txt +```{literalinclude} /snippets/pipelines/hpo/cli.txt :language: bash ``` @@ -209,7 +211,7 @@ Anomalib supports hyper-parameter optimization using [wandb](https://wandb.ai/) :::{tab-item} API -```{literalinclude} ../../snippets/pipelines/hpo/api.txt +```{literalinclude} /snippets/pipelines/hpo/api.txt :language: bash ``` @@ -233,7 +235,7 @@ To run a training experiment with experiment tracking, you will need the followi By using the configuration file above, you can run the experiment with the following command: -```{literalinclude} ../../snippets/logging/cli.txt +```{literalinclude} /snippets/logging/cli.txt :language: bash ``` @@ -241,7 +243,7 @@ By using the configuration file above, you can run the experiment with the follo :::{tab-item} API -```{literalinclude} ../../snippets/logging/api.txt +```{literalinclude} /snippets/logging/api.txt :language: bash ``` diff --git a/docs/source/markdown/guides/how_to/pipelines/custom_pipeline.md b/docs/source/markdown/guides/how_to/pipelines/custom_pipeline.md new file mode 100644 index 0000000000..ed3d66f81d --- /dev/null +++ b/docs/source/markdown/guides/how_to/pipelines/custom_pipeline.md @@ -0,0 +1,254 @@ +# Pipelines + +This guide demonstrates how to create a [Pipeline](../../reference/pipelines/index.md) for your custom task. + +A pipeline is made up of runners. These runners are responsible for running a single type of job. A job is the smallest unit of work that is independent, such as, training a model or statistical comparison of the outputs of two models. Each job should be designed to be independent of other jobs so that they are agnostic to the runner that is running them. This ensures that the job can be run in parallel or serially without any changes to the job itself. The runner does not directly instantiate a job but rather has a job generator that generates the job based on the configuration. This generator is responsible for parsing the config and generating the job. + +## Birds Eye View + +In this guide we are going to create a dummy significant parameter search pipeline. The pipeline will have two jobs. The first job trains a model and computes the metric. The second job computes the significance of the parameters to the final score using shapely values. The final output of the pipeline is a plot that shows the contribution of each parameter to the final score. This will help teach you how to create a pipeline, a job, a job generator, and how to expose it to the `anomalib` CLI. The pipeline is going to be named `experiment`. So by the end of this you will be able to generate significance plot using + +```{literalinclude} ../../../../snippets/pipelines/dummy/anomalib_cli.txt +:language: bash +``` + +The final directory structure will look as follows: + +```{literalinclude} ../../../../snippets/pipelines/dummy/src_dir_structure.txt + +``` + +```{literalinclude} ../../../../snippets/pipelines/dummy/tools_dir_structure.txt +:language: bash +``` + +## Creating the Jobs + +Let's first look at the base class for the [jobs](../../reference/pipelines/base/job.md). It has a few methods defined. + +- The `run` method is the main method that is called by the runner. This is where we will train the model and return the model metrics. +- The `collect` method is used to gather the results from all the runs and collate them. This is handy as we want to pass a single object to the next job that contains details of all the runs including the final score. +- The `save` method is used to write any artifacts to the disk. It accepts the gathered results as a parameter. This is useful in a variety of situations. Say, when we want to write the results in a csv file or write the raw anomaly maps for further processing. + +Let's create the first job that trains the model and computes the metric. Since it is a dummy example, we will just return a random number as the metric. + +```python +class TrainJob(Job): + name = "train" + + def __init__(self, lr: float, backbone: str, stride: int): + self.lr = lr + self.backbone = backbone + self.stride = stride + + def run(self, task_id: int | None = None) -> dict: + print(f"Training with lr: {self.lr}, backbone: {self.backbone}, stride: {self.stride}") + time.sleep(2) + score = np.random.uniform(0.7, 0.1) + return {"lr": self.lr, "backbone": self.backbone, "stride": self.stride, "score": score} +``` + +Ignore the `task_id` for now. It is used for parallel jobs. We will come back to it later. + +````{note} +The `name` attribute is important and is used to identify the arguments in the job config file. +So, in our case the config `yaml` file will contain an entry like this: + +```yaml +... +train: + lr: + backbone: + stride: +... +```` + +Of course, it is up to us to choose what parameters should be shown under the `train` key. + +Let's also add the `collect` method so that we return a nice dict object that can be used by the next job. + +```python +def collect(results: list[dict]) -> dict: + output: dict = {} + for key in results[0]: + output[key] = [] + for result in results: + for key, value in result.items(): + output[key].append(value) + return output +``` + +We can also define a `save` method that writes the dictionary as a csv file. + +```python +@staticmethod +def save(results: dict) -> None: + """Save results in a csv file.""" + results_df = pd.DataFrame(results) + file_path = Path("runs") / TrainJob.name + file_path.mkdir(parents=True, exist_ok=True) + results_df.to_csv(file_path / "results.csv", index=False) +``` + +The entire job class is shown below. + +```{literalinclude} ../../../../snippets/pipelines/dummy/train_job.txt +:language: python +``` + +Now we need a way to generate this job when the pipeline is run. To do this we need to subclass the [JobGenerator](../../reference/pipelines/base/generator.md) class. + +The job generator is the actual object that is attached to a runner and is responsible for parsing the configuration and generating jobs. It has two methods that need to be implemented. + +- `generate_job`: This method accepts the configuration as a dictionary and, optionally, the results of the previous job. For the train job, we don't need results for previous jobs, so we will ignore it. +- `job_class`: This holds the reference to the class of the job that the generator will yield. It is used to inform the runner about the job that is being run, and is used to access the static attributes of the job such as its name, collect method, etc. + +Let's first start by defining the configuration that the generator will accept. The train job requires three parameters: `lr`, `backbone`, and `stride`. We will also add another parameter that defines the number of experiments we want to run. One way to define it would be as follows: + +```yaml +train: + experiments: 10 + lr: [0.1, 0.99] + backbone: + - resnet18 + - wide_resnet50 + stride: + - 3 + - 5 +``` + +For this example the specification is defined as follows. + +1. The number of experiments is set to 10. +2. Learning rate is sampled from a uniform distribution in the range `[0.1, 0.99]`. +3. The backbone is chosen from the list `["resnet18", "wide_resnet50"]`. +4. The stride is chosen from the list `[3, 5]`. + +```{note} +While the `[ ]` and `-` syntax in `yaml` both signify a list, for visual disambiguation this example uses `[ ]` to denote closed interval and `-` for a list of options. +``` + +With this defined, we can define the generator class as follows. + +```{literalinclude} ../../../../snippets/pipelines/dummy/train_generator.txt +:language: python +``` + +Since this is a dummy example, we generate the next experiment randomly. In practice, you would use a more sophisticated method that relies on your validation metrics to generate the next experiment. + +```{admonition} Challenge +:class: tip +For a challenge define your own configuration and a generator to parse that configuration. +``` + +Okay, so now we can train the model. We still need a way to find out which parameters contribute the most to the final score. We will do this by computing the shapely values to find out the contribution of each parameter to the final score. + +Let's first start by adding the library to our environment + +```bash +pip install shap +``` + +The following listing shows the job that computes the shapely values and saves a plot that shows the contribution of each parameter to the final score. A quick rundown without going into the details of the job (as it is irrelevant to the pipeline) is as follows. We create a `RandomForestRegressor` that is trained on the parameters to predict the final score. We then compute the shapely values to identify the parameters that have the most significant impact on the model performance. Finally, the `save` method saves the plot so we can visually inspect the results. + +```{literalinclude} ../../../../snippets/pipelines/dummy/significance_job.txt + +``` + +Great! Now we have the job, as before, we need the generator. Since we only need the results from the previous stage, we don't need to define the config. Let's quickly write that as well. + +```{literalinclude} ../../../../snippets/pipelines/dummy/significance_job_generator.txt + +``` + +## Experiment Pipeline + +So now we have the jobs, and a way to generate them. Let's look at how we can chain them together to achieve what we want. We will use the [Pipeline](../../reference/pipelines/base/pipeline.md) class to define the pipeline. + +When creating a custom pipeline, there is only one important method that we need to implement. That is the `_setup_runners` method. This is where we chain the runners together. + +```{literalinclude} ../../../../snippets/pipelines/dummy/pipeline_serial.txt +:language: python +``` + +In this example we use `SerialRunner` for running each job. It is a simple runner that runs the jobs in a serial manner. For more information on `SerialRunner` look [here](../../reference/pipelines/runners/serial.md). + +Okay, so we have the pipeline. How do we run it? To do this let's create a simple entrypoint in `tools` folder of Anomalib. + +Here is how the directory looks. + +```{literalinclude} ../../../../snippets/pipelines/dummy/tools_dir_structure.txt +:language: bash +``` + +As you can see, we have the `config.yaml` file in the same directory. Let's quickly populate `experiment.py`. + +```python +from anomalib.pipelines.experiment_pipeline import ExperimentPipeline + +if __name__ == "__main__": + ExperimentPipeline().run() +``` + +Alright! Time to take it on the road. + +```bash +python tools/experimental/experiment/experiment.py --config tools/experimental/experiment/config.yaml +``` + +If all goes well you should see the summary plot in `runs/significant_feature/summary_plot.png`. + +## Exposing to the CLI + +Now that you have your shiny new pipeline, you can expose it as a subcommand to `anomalib` by adding an entry to the pipeline registry in `anomalib/cli/pipelines.py`. + +```python +if try_import("anomalib.pipelines"): + ... + from anomalib.pipelines import ExperimentPipeline + +PIPELINE_REGISTRY: dict[str, type[Pipeline]] | None = { + "experiment": ExperimentPipeline, + ... +} +``` + +With this you can now call + +```{literalinclude} ../../../../snippets/pipelines/dummy/anomalib_cli.txt +:language: bash +``` + +Congratulations! You have successfully created a pipeline that trains a model and computes the significance of the parameters to the final score 🎉 + +```{admonition} Challenge +:class: tip +This example used a random model hence the scores were meaningless. Try to implement a real model and compute the scores. Look into which parameters lead to the most significant contribution to your score. +``` + +## Final Tweaks + +Before we end, let's look at a few final tweaks that you can make to the pipeline. + +First, let's run the initial model training in parallel. Since all jobs are independent, we can use the [ParallelRunner](../../reference/pipelines/runners/parallel.md). Since the `TrainJob` is a dummy job in this example, the pool of parallel jobs is set to the number of experiments. + +```{literalinclude} ../../../../snippets/pipelines/dummy/pipeline_parallel.txt + +``` + +You now notice that the entire pipeline takes lesser time to run. This is handy when you have large number of experiments, and when each job takes substantial time to run. + +Now on to the second one. When running the pipeline we don't want our terminal cluttered with the outputs from each run. Anomalib provides a handy decorator that temporarily hides the output of a function. It suppresses all outputs to the standard out and the standard error unless an exception is raised. Let's add this to the `TrainJob` + +```python +from anomalib.utils.logging import hide_output + +class TrainJob(Job): + ... + + @hide_output + def run(self, task_id: int | None = None) -> dict: + ... +``` + +You will no longer see the output of the `print` statement in the `TrainJob` method in the terminal. diff --git a/docs/source/markdown/guides/how_to/pipelines/index.md b/docs/source/markdown/guides/how_to/pipelines/index.md index ed3d66f81d..c7f2c44706 100644 --- a/docs/source/markdown/guides/how_to/pipelines/index.md +++ b/docs/source/markdown/guides/how_to/pipelines/index.md @@ -1,254 +1,30 @@ -# Pipelines +# Pipeline Tutorials -This guide demonstrates how to create a [Pipeline](../../reference/pipelines/index.md) for your custom task. +This section contains tutorials on how to use different pipelines of Anomalib and how to creat your own. -A pipeline is made up of runners. These runners are responsible for running a single type of job. A job is the smallest unit of work that is independent, such as, training a model or statistical comparison of the outputs of two models. Each job should be designed to be independent of other jobs so that they are agnostic to the runner that is running them. This ensures that the job can be run in parallel or serially without any changes to the job itself. The runner does not directly instantiate a job but rather has a job generator that generates the job based on the configuration. This generator is responsible for parsing the config and generating the job. +::::{grid} +:margin: 1 1 0 0 +:gutter: 1 -## Birds Eye View +:::{grid-item-card} {octicon}`stack` Tiled Ensemble +:link: ./tiled_ensemble +:link-type: doc -In this guide we are going to create a dummy significant parameter search pipeline. The pipeline will have two jobs. The first job trains a model and computes the metric. The second job computes the significance of the parameters to the final score using shapely values. The final output of the pipeline is a plot that shows the contribution of each parameter to the final score. This will help teach you how to create a pipeline, a job, a job generator, and how to expose it to the `anomalib` CLI. The pipeline is going to be named `experiment`. So by the end of this you will be able to generate significance plot using +Learn more about how to use the tiled ensemble pipelines. +::: -```{literalinclude} ../../../../snippets/pipelines/dummy/anomalib_cli.txt -:language: bash -``` - -The final directory structure will look as follows: - -```{literalinclude} ../../../../snippets/pipelines/dummy/src_dir_structure.txt - -``` - -```{literalinclude} ../../../../snippets/pipelines/dummy/tools_dir_structure.txt -:language: bash -``` - -## Creating the Jobs - -Let's first look at the base class for the [jobs](../../reference/pipelines/base/job.md). It has a few methods defined. - -- The `run` method is the main method that is called by the runner. This is where we will train the model and return the model metrics. -- The `collect` method is used to gather the results from all the runs and collate them. This is handy as we want to pass a single object to the next job that contains details of all the runs including the final score. -- The `save` method is used to write any artifacts to the disk. It accepts the gathered results as a parameter. This is useful in a variety of situations. Say, when we want to write the results in a csv file or write the raw anomaly maps for further processing. - -Let's create the first job that trains the model and computes the metric. Since it is a dummy example, we will just return a random number as the metric. - -```python -class TrainJob(Job): - name = "train" +:::{grid-item-card} {octicon}`gear` Custom Pipeline +:link: ./custom_pipeline +:link-type: doc - def __init__(self, lr: float, backbone: str, stride: int): - self.lr = lr - self.backbone = backbone - self.stride = stride - - def run(self, task_id: int | None = None) -> dict: - print(f"Training with lr: {self.lr}, backbone: {self.backbone}, stride: {self.stride}") - time.sleep(2) - score = np.random.uniform(0.7, 0.1) - return {"lr": self.lr, "backbone": self.backbone, "stride": self.stride, "score": score} -``` - -Ignore the `task_id` for now. It is used for parallel jobs. We will come back to it later. - -````{note} -The `name` attribute is important and is used to identify the arguments in the job config file. -So, in our case the config `yaml` file will contain an entry like this: - -```yaml -... -train: - lr: - backbone: - stride: -... -```` - -Of course, it is up to us to choose what parameters should be shown under the `train` key. - -Let's also add the `collect` method so that we return a nice dict object that can be used by the next job. - -```python -def collect(results: list[dict]) -> dict: - output: dict = {} - for key in results[0]: - output[key] = [] - for result in results: - for key, value in result.items(): - output[key].append(value) - return output -``` - -We can also define a `save` method that writes the dictionary as a csv file. - -```python -@staticmethod -def save(results: dict) -> None: - """Save results in a csv file.""" - results_df = pd.DataFrame(results) - file_path = Path("runs") / TrainJob.name - file_path.mkdir(parents=True, exist_ok=True) - results_df.to_csv(file_path / "results.csv", index=False) -``` - -The entire job class is shown below. - -```{literalinclude} ../../../../snippets/pipelines/dummy/train_job.txt -:language: python -``` - -Now we need a way to generate this job when the pipeline is run. To do this we need to subclass the [JobGenerator](../../reference/pipelines/base/generator.md) class. - -The job generator is the actual object that is attached to a runner and is responsible for parsing the configuration and generating jobs. It has two methods that need to be implemented. - -- `generate_job`: This method accepts the configuration as a dictionary and, optionally, the results of the previous job. For the train job, we don't need results for previous jobs, so we will ignore it. -- `job_class`: This holds the reference to the class of the job that the generator will yield. It is used to inform the runner about the job that is being run, and is used to access the static attributes of the job such as its name, collect method, etc. - -Let's first start by defining the configuration that the generator will accept. The train job requires three parameters: `lr`, `backbone`, and `stride`. We will also add another parameter that defines the number of experiments we want to run. One way to define it would be as follows: - -```yaml -train: - experiments: 10 - lr: [0.1, 0.99] - backbone: - - resnet18 - - wide_resnet50 - stride: - - 3 - - 5 -``` - -For this example the specification is defined as follows. - -1. The number of experiments is set to 10. -2. Learning rate is sampled from a uniform distribution in the range `[0.1, 0.99]`. -3. The backbone is chosen from the list `["resnet18", "wide_resnet50"]`. -4. The stride is chosen from the list `[3, 5]`. - -```{note} -While the `[ ]` and `-` syntax in `yaml` both signify a list, for visual disambiguation this example uses `[ ]` to denote closed interval and `-` for a list of options. -``` - -With this defined, we can define the generator class as follows. - -```{literalinclude} ../../../../snippets/pipelines/dummy/train_generator.txt -:language: python -``` - -Since this is a dummy example, we generate the next experiment randomly. In practice, you would use a more sophisticated method that relies on your validation metrics to generate the next experiment. - -```{admonition} Challenge -:class: tip -For a challenge define your own configuration and a generator to parse that configuration. -``` - -Okay, so now we can train the model. We still need a way to find out which parameters contribute the most to the final score. We will do this by computing the shapely values to find out the contribution of each parameter to the final score. - -Let's first start by adding the library to our environment - -```bash -pip install shap -``` +Learn more about how to create a new custom pipeline. +::: -The following listing shows the job that computes the shapely values and saves a plot that shows the contribution of each parameter to the final score. A quick rundown without going into the details of the job (as it is irrelevant to the pipeline) is as follows. We create a `RandomForestRegressor` that is trained on the parameters to predict the final score. We then compute the shapely values to identify the parameters that have the most significant impact on the model performance. Finally, the `save` method saves the plot so we can visually inspect the results. +:::: -```{literalinclude} ../../../../snippets/pipelines/dummy/significance_job.txt +```{toctree} +:caption: Model Tutorials +:hidden: +./feature_extractors ``` - -Great! Now we have the job, as before, we need the generator. Since we only need the results from the previous stage, we don't need to define the config. Let's quickly write that as well. - -```{literalinclude} ../../../../snippets/pipelines/dummy/significance_job_generator.txt - -``` - -## Experiment Pipeline - -So now we have the jobs, and a way to generate them. Let's look at how we can chain them together to achieve what we want. We will use the [Pipeline](../../reference/pipelines/base/pipeline.md) class to define the pipeline. - -When creating a custom pipeline, there is only one important method that we need to implement. That is the `_setup_runners` method. This is where we chain the runners together. - -```{literalinclude} ../../../../snippets/pipelines/dummy/pipeline_serial.txt -:language: python -``` - -In this example we use `SerialRunner` for running each job. It is a simple runner that runs the jobs in a serial manner. For more information on `SerialRunner` look [here](../../reference/pipelines/runners/serial.md). - -Okay, so we have the pipeline. How do we run it? To do this let's create a simple entrypoint in `tools` folder of Anomalib. - -Here is how the directory looks. - -```{literalinclude} ../../../../snippets/pipelines/dummy/tools_dir_structure.txt -:language: bash -``` - -As you can see, we have the `config.yaml` file in the same directory. Let's quickly populate `experiment.py`. - -```python -from anomalib.pipelines.experiment_pipeline import ExperimentPipeline - -if __name__ == "__main__": - ExperimentPipeline().run() -``` - -Alright! Time to take it on the road. - -```bash -python tools/experimental/experiment/experiment.py --config tools/experimental/experiment/config.yaml -``` - -If all goes well you should see the summary plot in `runs/significant_feature/summary_plot.png`. - -## Exposing to the CLI - -Now that you have your shiny new pipeline, you can expose it as a subcommand to `anomalib` by adding an entry to the pipeline registry in `anomalib/cli/pipelines.py`. - -```python -if try_import("anomalib.pipelines"): - ... - from anomalib.pipelines import ExperimentPipeline - -PIPELINE_REGISTRY: dict[str, type[Pipeline]] | None = { - "experiment": ExperimentPipeline, - ... -} -``` - -With this you can now call - -```{literalinclude} ../../../../snippets/pipelines/dummy/anomalib_cli.txt -:language: bash -``` - -Congratulations! You have successfully created a pipeline that trains a model and computes the significance of the parameters to the final score 🎉 - -```{admonition} Challenge -:class: tip -This example used a random model hence the scores were meaningless. Try to implement a real model and compute the scores. Look into which parameters lead to the most significant contribution to your score. -``` - -## Final Tweaks - -Before we end, let's look at a few final tweaks that you can make to the pipeline. - -First, let's run the initial model training in parallel. Since all jobs are independent, we can use the [ParallelRunner](../../reference/pipelines/runners/parallel.md). Since the `TrainJob` is a dummy job in this example, the pool of parallel jobs is set to the number of experiments. - -```{literalinclude} ../../../../snippets/pipelines/dummy/pipeline_parallel.txt - -``` - -You now notice that the entire pipeline takes lesser time to run. This is handy when you have large number of experiments, and when each job takes substantial time to run. - -Now on to the second one. When running the pipeline we don't want our terminal cluttered with the outputs from each run. Anomalib provides a handy decorator that temporarily hides the output of a function. It suppresses all outputs to the standard out and the standard error unless an exception is raised. Let's add this to the `TrainJob` - -```python -from anomalib.utils.logging import hide_output - -class TrainJob(Job): - ... - - @hide_output - def run(self, task_id: int | None = None) -> dict: - ... -``` - -You will no longer see the output of the `print` statement in the `TrainJob` method in the terminal. diff --git a/docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md b/docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md new file mode 100644 index 0000000000..3550efb5fd --- /dev/null +++ b/docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md @@ -0,0 +1,157 @@ +# Tiled ensemble + +This guide will show you how to use **The Tiled Ensemble** method for anomaly detection. For more details, refer to the official [Paper](https://openaccess.thecvf.com/content/CVPR2024W/VAND/html/Rolih_Divide_and_Conquer_High-Resolution_Industrial_Anomaly_Detection_via_Memory_Efficient_CVPRW_2024_paper.html). + +The tiled ensemble approach reduces memory consumption by dividing input images into a grid of tiles and training a dedicated model for each tile location. +It is compatible with any existing image anomaly detection model without the need for any modification of the underlying architecture. + +![Tiled ensemble flow](../../../../images/tiled_ensemble/ensemble_flow.png) + +```{note} +This feature is experimental and may not work as expected. +For any problems refer to [Issues](https://github.com/openvinotoolkit/anomalib/issues) and feel free to ask any question in [Discussions](https://github.com/openvinotoolkit/anomalib/discussions). +``` + +## Training + +You can train a tiled ensemble using the training script located inside `tools/tiled_ensemble` directory: + +```{code-block} bash + +python tools/tiled_ensemble/train_ensemble.py \ + --config tools/tiled_ensemble/ens_config.yaml +``` + +By default, the Padim model is trained on **MVTec AD bottle** category using image size of 256x256, divided into non-overlapping 128x128 tiles. +You can modify these parameters in the [config file](#ensemble-configuration). + +## Evaluation + +After training, you can evaluate the tiled ensemble on test data using: + +```{code-block} bash + +python tools/tiled_ensemble/eval.py \ + --config tools/tiled_ensemble/ens_config.yaml \ + --root path_to_results_dir + +``` + +Ensure that `root` points to the directory containing the training results, typically `results/padim/mvtec/bottle/runX`. + +## Ensemble configuration + +Tiled ensemble is configured using `ens_config.yaml` file in the `tools/tiled_ensemble` directory. +It contains general settings and tiled ensemble specific settings. + +### General + +General settings at the top of the config file are used to set up the random `seed`, `accelerator` (device) and the path to where results will be saved `default_root_dir`. + +```{code-block} yaml +seed: 42 +accelerator: "gpu" +default_root_dir: "results" +``` + +### Tiling + +This section contains the following settings, used for image tiling: + +```{code-block} yaml + +tiling: + tile_size: 256 + stride: 256 +``` + +These settings determine the tile size and stride. Another important parameter is image_size from `data` section later in the config. It determines the original size of the image. + +Input image is split into tiles, where each tile is of shape set by `tile_size` and tiles are taken with step set by `stride`. +For example: having image_size: 512, tile_size: 256, and stride: 256, results in 4 non-overlapping tile locations. + +### Normalization and thresholding + +Next up are the normalization and thresholding settings: + +```{code-block} yaml +normalization_stage: image +thresholding: + method: F1AdaptiveThreshold + stage: image +``` + +- **Normalization**: Can be applied per each tile location separately (`tile` option), after combining prediction (`image` option), or skipped (`none` option). + +- **Thresholding**: Can also be applied at different stages, but it is limited to `tile` and `image`. Another setting for thresholding is the method used. It can be specified as a string or by the class path. + +### Data + +The `data` section is used to configure the input `image_size` and other parameters for the dataset used. + +```{code-block} yaml +data: + class_path: anomalib.data.MVTec + init_args: + root: ./datasets/MVTec + category: bottle + train_batch_size: 32 + eval_batch_size: 32 + num_workers: 8 + task: segmentation + transform: null + train_transform: null + eval_transform: null + test_split_mode: from_dir + test_split_ratio: 0.2 + val_split_mode: same_as_test + val_split_ratio: 0.5 + image_size: [256, 256] +``` + +Refer to [Data](../../reference/data/image/index.md) for more details on parameters. + +### SeamSmoothing + +This section contains settings for `SeamSmoothing` block of pipeline: + +```{code-block} yaml +SeamSmoothing: + apply: True + sigma: 2 + width: 0.1 + +``` + +SeamSmoothing job is responsible for smoothing of regions where tiles meet - called tile seams. + +- **apply**: If True, smoothing will be applied. +- **sigma**: Controls the sigma of Gaussian filter used for smoothing. +- **width**: Sets the percentage of the region around the seam to be smoothed. + +### TrainModels + +The last section `TrainModels` contains the setup for model training: + +```{code-block} yaml +TrainModels: + model: + class_path: Fastflow + + metrics: + pixel: AUROC + image: AUROC + + trainer: + max_epochs: 500 + callbacks: + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + patience: 42 + monitor: pixel_AUROC + mode: max +``` + +- **Model**: Specifies the model used. Refer to [Models](../../reference/models/image/index.md) for more details on the model parameters. +- **Metrics**: Defines evaluation metrics for pixel and image level. +- **Trainer**: _optional_ parameters, used to control the training process. Refer to [Engine](../../reference/engine/index.md) for more details. diff --git a/docs/source/snippets/train/api/default.txt b/docs/source/snippets/train/api/default.txt index 30293cf501..1fe6cb895c 100644 --- a/docs/source/snippets/train/api/default.txt +++ b/docs/source/snippets/train/api/default.txt @@ -1,12 +1,15 @@ # Import the required modules from anomalib.data import MVTec -from anomalib.models import Patchcore from anomalib.engine import Engine +from anomalib.models import EfficientAd # Initialize the datamodule, model and engine -datamodule = MVTec() -model = Patchcore() -engine = Engine() +datamodule = MVTec(train_batch_size=1) +model = EfficientAd() +engine = Engine(max_epochs=5) # Train the model engine.fit(datamodule=datamodule, model=model) + +# Continue from a checkpoint +engine.fit(datamodule=datamodule, model=model, ckpt_path="path/to/checkpoint.ckpt") diff --git a/docs/source/snippets/train/cli/default.txt b/docs/source/snippets/train/cli/default.txt index 3f64f687ad..1990dbf97e 100644 --- a/docs/source/snippets/train/cli/default.txt +++ b/docs/source/snippets/train/cli/default.txt @@ -2,10 +2,13 @@ anomalib train -h # Train by using the default values. -anomalib train --model Patchcore --data anomalib.data.MVTec +anomalib train --model EfficientAd --data anomalib.data.MVTec --data.train_batch_size 1 # Train by overriding arguments. -anomalib train --model Patchcore --data anomalib.data.MVTec --data.category transistor +anomalib train --model EfficientAd --data anomalib.data.MVTec --data.train_batch_size 1 --data.category transistor # Train by using a config file. anomalib train --config + +# Continue training from a checkpoint +anomalib train --config --ckpt_path diff --git a/notebooks/000_getting_started/001_getting_started.ipynb b/notebooks/000_getting_started/001_getting_started.ipynb index a0fcd2d0c9..cfc4620eb8 100644 --- a/notebooks/000_getting_started/001_getting_started.ipynb +++ b/notebooks/000_getting_started/001_getting_started.ipynb @@ -168,7 +168,7 @@ "from anomalib import TaskType\n", "from anomalib.data import MVTec\n", "from anomalib.data.utils import read_image\n", - "from anomalib.deploy import OpenVINOInferencer, ExportType\n", + "from anomalib.deploy import ExportType, OpenVINOInferencer\n", "from anomalib.engine import Engine\n", "from anomalib.models import Padim" ] diff --git a/notebooks/200_models/201_fastflow.ipynb b/notebooks/200_models/201_fastflow.ipynb index e501844491..0826e3c51c 100644 --- a/notebooks/200_models/201_fastflow.ipynb +++ b/notebooks/200_models/201_fastflow.ipynb @@ -1,835 +1,835 @@ { - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Train a Model via API\n", - "\n", - "This notebook demonstrates how to train, test and infer the FastFlow model via Anomalib API. Compared to the CLI entrypoints such as \\`tools/\\.py, the API offers more flexibility such as modifying the existing model or designing custom approaches.\n", - "\n", - "# Installing Anomalib\n", - "\n", - "The easiest way to install anomalib is to use pip. You can install it from the command line using the following command:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%pip install anomalib" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setting up the Dataset Directory\n", - "\n", - "This cell is to ensure we change the directory to have access to the datasets.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "\n", - "# NOTE: Provide the path to the dataset root directory.\n", - "# If the datasets is not downloaded, it will be downloaded\n", - "# to this directory.\n", - "dataset_root = Path.cwd().parent / \"datasets\" / \"MVTec\"" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Imports\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint\n", - "from matplotlib import pyplot as plt\n", - "from PIL import Image\n", - "from torch.utils.data import DataLoader\n", - "\n", - "from anomalib.data import PredictDataset, MVTec\n", - "from anomalib.engine import Engine\n", - "from anomalib.models import Fastflow\n", - "from anomalib.utils.post_processing import superimpose_anomaly_map\n", - "from anomalib import TaskType" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Data Module\n", - "\n", - "To train the model end-to-end, we do need to have a dataset. In our [previous notebooks](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules), we demonstrate how to initialize benchmark- and custom datasets. In this tutorial, we will use MVTec AD DataModule. We assume that `datasets` directory is created in the `anomalib` root directory and `MVTec` dataset is located in `datasets` directory.\n", - "\n", - "Before creating the dataset, let's define the task type that we will be working on. In this notebook, we will be working on a segmentation task. Therefore the `task` variable would be:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "task = TaskType.SEGMENTATION" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "datamodule = MVTec(\n", - " root=dataset_root,\n", - " category=\"bottle\",\n", - " image_size=256,\n", - " train_batch_size=32,\n", - " eval_batch_size=32,\n", - " num_workers=0,\n", - " task=task,\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## FastFlow Model\n", - "\n", - "Now that we have created the MVTec datamodule, we could create the FastFlow model. We could start with printing its docstring.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[0;31mInit signature:\u001b[0m\n", - "\u001b[0mFastflow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mbackbone\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'resnet18'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mpre_trained\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mflow_steps\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mSource:\u001b[0m \n", - "\u001b[0;32mclass\u001b[0m \u001b[0mFastflow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mAnomalyModule\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"PL Lightning Module for the FastFlow algorithm.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Args:\u001b[0m\n", - "\u001b[0;34m input_size (tuple[int, int]): Model input size.\u001b[0m\n", - "\u001b[0;34m Defaults to ``(256, 256)``.\u001b[0m\n", - "\u001b[0;34m backbone (str): Backbone CNN network\u001b[0m\n", - "\u001b[0;34m Defaults to ``resnet18``.\u001b[0m\n", - "\u001b[0;34m pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.\u001b[0m\n", - "\u001b[0;34m Defaults to ``True``.\u001b[0m\n", - "\u001b[0;34m flow_steps (int, optional): Flow steps.\u001b[0m\n", - "\u001b[0;34m Defaults to ``8``.\u001b[0m\n", - "\u001b[0;34m conv3x3_only (bool, optinoal): Use only conv3x3 in fast_flow model.\u001b[0m\n", - "\u001b[0;34m Defaults to ``False``.\u001b[0m\n", - "\u001b[0;34m hidden_ratio (float, optional): Ratio to calculate hidden var channels.\u001b[0m\n", - "\u001b[0;34m Defaults to ``1.0`.\u001b[0m\n", - "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mbackbone\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"resnet18\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mpre_trained\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mflow_steps\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackbone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbackbone\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_trained\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpre_trained\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflow_steps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflow_steps\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv3x3_only\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhidden_ratio\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFastflowLoss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mFastflowModel\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_setup\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_size\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Fastflow needs input size to build torch model.\"\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFastflowModel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0minput_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mbackbone\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackbone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mpre_trained\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_trained\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mflow_steps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflow_steps\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv3x3_only\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhidden_ratio\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtraining_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mSTEP_OUTPUT\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Perform the training step input and return the loss.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Args:\u001b[0m\n", - "\u001b[0;34m batch (batch: dict[str, str | torch.Tensor]): Input batch\u001b[0m\n", - "\u001b[0;34m args: Additional arguments.\u001b[0m\n", - "\u001b[0;34m kwargs: Additional keyword arguments.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Returns:\u001b[0m\n", - "\u001b[0;34m STEP_OUTPUT: Dictionary containing the loss value.\u001b[0m\n", - "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;31m# These variables are not used.\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mhidden_variables\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjacobians\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"image\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhidden_variables\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjacobians\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"train_loss\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mon_epoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprog_bar\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"loss\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mSTEP_OUTPUT\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Perform the validation step and return the anomaly map.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Args:\u001b[0m\n", - "\u001b[0;34m batch (dict[str, str | torch.Tensor]): Input batch\u001b[0m\n", - "\u001b[0;34m args: Additional arguments.\u001b[0m\n", - "\u001b[0;34m kwargs: Additional keyword arguments.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Returns:\u001b[0m\n", - "\u001b[0;34m STEP_OUTPUT | None: batch dictionary containing anomaly-maps.\u001b[0m\n", - "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;31m# These variables are not used.\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0manomaly_maps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"image\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"anomaly_maps\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0manomaly_maps\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtrainer_arguments\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Return FastFlow trainer arguments.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"gradient_clip_val\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"num_sanity_val_steps\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mconfigure_optimizers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOptimizer\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Configure optimizers for each decoder.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Returns:\u001b[0m\n", - "\u001b[0;34m Optimizer: Adam optimizer for each decoder\u001b[0m\n", - "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0moptim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAdam\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mlr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.001\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mweight_decay\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.00001\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlearning_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mLearningType\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Return the learning type of the model.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Returns:\u001b[0m\n", - "\u001b[0;34m LearningType: Learning type of the model.\u001b[0m\n", - "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mLearningType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mONE_CLASS\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mFile:\u001b[0m ~/anomalib/src/anomalib/models/image/fastflow/lightning_model.py\n", - "\u001b[0;31mType:\u001b[0m ABCMeta\n", - "\u001b[0;31mSubclasses:\u001b[0m " - ] - } - ], - "source": [ - "Fastflow??" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "model = Fastflow(backbone=\"resnet18\", flow_steps=8)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Callbacks\n", - "\n", - "To train the model properly, we will to add some other \"non-essential\" logic such as saving the weights, early-stopping, normalizing the anomaly scores and visualizing the input/output images. To achieve these we use `Callbacks`. Anomalib has its own callbacks and also supports PyTorch Lightning's native callbacks. So, let's create the list of callbacks we want to execute during the training.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "callbacks = [\n", - " ModelCheckpoint(\n", - " mode=\"max\",\n", - " monitor=\"pixel_AUROC\",\n", - " ),\n", - " EarlyStopping(\n", - " monitor=\"pixel_AUROC\",\n", - " mode=\"max\",\n", - " patience=3,\n", - " ),\n", - "]" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Training\n", - "\n", - "Now that we set up the datamodule, model, optimizer and the callbacks, we could now train the model.\n", - "\n", - "The final component to train the model is `Engine` object, which handles train/test/predict pipeline. Let's create the engine object to train the model.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "engine = Engine(\n", - " callbacks=callbacks,\n", - " pixel_metrics=\"AUROC\",\n", - " accelerator=\"auto\", # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n", - " devices=1,\n", - " logger=False,\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "`Trainer` object has number of options that suit all specific needs. For more details, refer to [Lightning Documentation](https://pytorch-lightning.readthedocs.io/en/stable/common/engine.html) to see how it could be tweaked to your needs.\n", - "\n", - "Let's train the model now.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "engine.fit(datamodule=datamodule, model=model)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "The training has finished after 12 epochs. This is because, we set the `EarlyStopping` criteria with a patience of 3, which terminated the training after `pixel_AUROC` stopped improving. If we increased the `patience`, the training would continue further.\n", - "\n", - "## Testing\n", - "\n", - "Now that we trained the model, we could test the model to check the overall performance on the test set. We will also be writing the output of the test images to a file since we set `VisualizerCallback` in `callbacks`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4b40cd5a1e094248b521f07ef14291de", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Testing: | | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", - "┃ Test metric ┃ DataLoader 0 ┃\n", - "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", - "│ image_AUROC │ 1.0 │\n", - "│ image_F1Score │ 1.0 │\n", - "│ pixel_AUROC │ 0.9769068956375122 │\n", - "└───────────────────────────┴───────────────────────────┘\n", - "\n" - ], - "text/plain": [ - "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", - "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", - "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", - "│\u001b[36m \u001b[0m\u001b[36m image_AUROC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.0 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m image_F1Score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.0 \u001b[0m\u001b[35m \u001b[0m│\n", - "│\u001b[36m \u001b[0m\u001b[36m pixel_AUROC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9769068956375122 \u001b[0m\u001b[35m \u001b[0m│\n", - "└───────────────────────────┴───────────────────────────┘\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "[{'pixel_AUROC': 0.9769068956375122, 'image_AUROC': 1.0, 'image_F1Score': 1.0}]" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "engine.test(datamodule=datamodule, model=model)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Inference\n", - "\n", - "Since we have a trained model, we could infer the model on an individual image or folder of images. Anomalib has an `PredictDataset` to let you create an inference dataset. So let's try it.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "inference_dataset = PredictDataset(path=dataset_root / \"bottle/test/broken_large/000.png\")\n", - "inference_dataloader = DataLoader(dataset=inference_dataset)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "We could utilize `Trainer`'s `predict` method to infer, and get the outputs to visualize\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "predictions = engine.predict(model=model, dataloaders=inference_dataloader)[0]" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "`predictions` contain image, anomaly maps, predicted scores, labels and masks. These are all stored in a dictionary. We could check this by printing the `prediction` keys.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Image Shape: torch.Size([1, 3, 256, 256]),\n", - "Anomaly Map Shape: {predictions[\"anomaly_maps\"].shape}, \n", - "Predicted Mask Shape: {predictions[\"pred_masks\"].shape}\n" - ] - } - ], - "source": [ - "print(\n", - " f'Image Shape: {predictions[\"image\"].shape},\\n'\n", - " 'Anomaly Map Shape: {predictions[\"anomaly_maps\"].shape}, \\n'\n", - " 'Predicted Mask Shape: {predictions[\"pred_masks\"].shape}',\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Visualization\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "To properly visualize the predictions, we will need to perform some post-processing operations." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's first show the input image. To do so, we will use `image_path` key from the `predictions` dictionary, and read the image from path. Note that `predictions` dictionary already contains `image`. However, this is the normalized image with pixel values between 0 and 1. We will use the original image to visualize the input image." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "image_path = predictions[\"image_path\"][0]\n", - "image_size = predictions[\"image\"].shape[-2:]\n", - "image = np.array(Image.open(image_path).resize(image_size))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "The first output of the predictions is the anomaly map. As can be seen above, it's also a torch tensor and of size `torch.Size([1, 1, 256, 256])`. We therefore need to convert it to numpy and squeeze the dimensions to make it `256x256` output to visualize.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "anomaly_map = predictions[\"anomaly_maps\"][0]\n", - "anomaly_map = anomaly_map.cpu().numpy().squeeze()\n", - "plt.imshow(anomaly_map)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "We could superimpose (overlay) the anomaly map on top of the original image to get a heat map. Anomalib has a built-in function to achieve this. Let's try it.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAGiCAYAAAC/NyLhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9T6wsy5bfhX9WRGTWPufe91637VZblt1mhI2QAMlA0xJMkJHFAAnhAfIAIcS0/ZP8YEBPMD3qIQxozxCMkIExEgN6iGwhmZEHRsAEW7jbxt397jm7qjIzItZvsFZkRcXJ2nuf+153c987cW+dnZWVfyIjI9Z3/V+iqsqX9qV9aV/al/alfUda+KPuwJf2pX1pX9qX9qV9TvsCXF/al/alfWlf2neqfQGuL+1L+9K+tC/tO9W+ANeX9qV9aV/al/adal+A60v70r60L+1L+061L8D1pX1pX9qX9qV9p9oX4PrSvrQv7Uv70r5T7QtwfWlf2pf2pX1p36n2Bbi+tC/tS/vSvrTvVPsCXF/al/alfWlf2neq/ZEB12/+5m/yT/1T/xRPT0/88i//Mv/r//q//lF15Uv70r60L+1L+w61PxLg+u/+u/+OH/7wh/z1v/7X+d/+t/+Nf/6f/+f5S3/pL/GP/tE/+qPozpf2pX1pX9qX9h1q8keRZPeXf/mX+Zf+pX+J//K//C8BqLXyZ/7Mn+Gv/tW/yn/yn/wnf9jd+dK+tC/tS/vSvkMt/WHfcF1X/s7f+Tv82q/92r4vhMBf/It/kb/1t/7W4TnLsrAsy/691srv/u7v8sf/+B9HRP7A+/ylfWlf2pf2pf1km6ry4cMH/tSf+lOE8HnKvz904Pp//9//l1IKv/iLv3i3/xd/8Rf5e3/v7x2e8xu/8Rv8+q//+h9G9760L+1L+9K+tD/E9vf//t/nT//pP/1Z5/yhA9e3ab/2a7/GD3/4w/37j370I37pl36Jv/H3/y5P3/8+C09s10S9RvgR8HvABXgGFmDzzwpU/yiwa0nVP7X7tP1l2Bcx02AApPv8JFrrB93fvtXh+7fV8vb3GZu88gndcUdc0kvXbs3Hbr+sPB7SR0P7kxjycbjbFFCgqA93mwOlO6ifE/2JhU/n0nhhhv3weLzG/W95348G8WjAjo5p77X/22/Dp9c66mf/rG/p81E/x+cYn+21ufha6/umw+fomEfPMp73lmd+rV/js45j/9L7Hccr3baDf45aG8bxtccHXQF75ARMwB8HfgB8z7ZP4UqUgqDI3ZjYnss3H/j//Zk/z/e+9723DMpd+0MHrj/xJ/4EMUZ+53d+527/7/zO7/An/+SfPDzndDpxOp0+3f/9H/D0/R8gnIhTQqdg73zjNo8jN9AK3NOTuwnXiM5IcAr3RKefDPDtF81RGxcSw/e3gNlb2msE8Ig4wDGx6GfyW/vSE0ZuwHWEkeMaO/re73utC/3jjLTqbho04GrzoQerfo70gNXvH/fB/bx6RBxfam9lVMb30vYdbR8BV/s0Jm2cB0eD+Gjufg5w9f1p+19ioN7KOD465gi4+rWuB7+PrX+f9cExP0579LwvLYxxjTb08fcp8njI+sPHaTCux/bICTj5Z/bPBPL0NZKUQPVL3Y9NYrZefgtzzx86cM3zzF/4C3+B3/qt3+Lf/rf/bcBsVr/1W7/Fr/7qr37WtTITm05kElrlxhj3bSRMtb4iaT0CrjbJ2xtU/mAlrn7fo98etR+XEL4mdR19XpMe2m9tJXTnqkARkA7IPneN9rcYu9DT5pdoz45FI2jdcTvcg9ZIuB6B2xFovUXqeq299LD9Pj3Y7n/vqVI/x+twTeFeI/FImoTj53z0Mh9JWiNgjn3sj3/Uju7R9+uIHoz97/+O7Wgu/KTaKAa1fUfP1MajdN/7d6m2rb7mjpoK1HBbqu2S41To97XHvWCIIsAEugmaBA1yyJts128PP38kqsIf/vCH/Pv//r/Pv/gv/ov8y//yv8x/8V/8Fzw/P/Mf/Af/wWddJxPJRGp1wjdqYKCjG40YHXFII0A9IkLj+Uec7Y/TjhbIS1LY51znpePG9ogLf8QBf869XuDw1fer3nOF+99unB/d9qgbPba+pN28mzuP5slI5F76fA5wvdSO5lcPFH1raoVH81IP9o/nvJUAPxqfI1Vo//6P+jUS4xEk23a//3NVha8BV9s3Sk4vradH7/4n1fr38Rpw6YPz+v438enBvTSA+jgL9wA3LveebCqm1br65U8YTZ4w4Ip80mW9fntN1R8JcP27/+6/yz/+x/+Y//Q//U/57d/+bf6Ff+Ff4H/6n/6nTxw2XmuZiawJNoGMfY7w5g572mj3f/GT2z74VD3UE4qek3nronlr+0lx5K9JXW8lmO3ZRuL2SBx6SxvZubZdbtvqn/H6j7RK/aXHR2h/R2GjXWsUErTtfIvq5wisCp/On/5Gr73TUfp4dN+jNkpIj5C6f3f9OZH7Z4kP7jP2o3/OXk360vgdgVX/W79/ZJ7648Jwzlvu9+g9PAKfR4DUnhP+4FSFPc1p+47GahSJemmtXaPn3o4Wix9fA0iTzvznfiq16d2WbAbOfslGSk+Y7aszsd19Prx1DD5tf2TOGb/6q7/62arBselVYJZ7B4zMbUD7wc1wjG4jh/iS/QI+JQSB10HixafgZbFhvPZbFsZrXN9bwLDNtJ4wHYFNTwjeAmL9MT3XfMRNHxCrCnezf1xMj5Br1DLBbdH92AzzKF2Nc2mU2F+aL424DP3/pL0k6R69i3Ff/6DhwTmjk8bR+x7POVo7o8Q1/j3a1/6OKrJHxPlRewSG7Rlek6xeelcvSVs/Ccmrn/9tTMcxf2R7bN/HPmQez53+fsmZx3hjIHuSUDEHJvXxqcDHAFlM8soYcEW71J11oHXz4+sj8Kh9J7wKH7bmdNGDVgOuQ/PEo4k2EpyRW3yJ+3orwX5rO1pIR314dM5Lx36O9PYWjn4kIhx8f3TtkQAejeeRVNd9f3TrkUYOpx3u7+kCGKf5Cac6HvhIWug78dq+R+01qbb1peee+wd/7fzX7tdTmd5if9TeIkWOYDy+93Hf0ct8y7VfauM9x/Pfuo7G3x5Jbm/t00vtpeeGT1W87ZyxX68BcDtvHH+5SV1V7peAtvtjx/ROcU2B0kDrCLguL3TplfbdBq4FE0VX3175FMg+sXs9WsRH7PYD7v3F6/xRtZ/UQjk6/jWu/7V2xCEendsvoF4a6/c/8ERsrXZfHtHvcbu99oZTVUxVUul29iu2J+Aj0T5y3BlvdgQ2cD82o25l5KZH2+ePA1xHYBW580S78zDs+3vkvNFvN6nriLAeMSVH+3+cdjS+rx3X96fNxaPfflyJ6sdtj5i/EbjaWurthSPYtmu0Mcr399Fuzt89dnd+iUZ/26UKx16K7RbPb3rIw/bdBq6mI22S14qh+JUbgLV3FYE8+UblXmXYXlJb/G3E+9FX7onJ+Db69on+6pU2LoD6YPuRGuK1hX4kgrylteOP9GxHRPGRAWokwi/18agPHSHvBYBRd3506uiQ9dItD311BGq0RVkV80jN3FjK/mbKza2qJ3qjZPrasw7P/PABe8LUfz96V4/OHe/bA1Zjl3vg6gf0k8HiXu3RdPS9qvRRezSPjp6nbT86pz7YP7bW/9fWT3+NftzahJHhr/JYOh3H4aX79u/k0Rg8uta4Zo+eUYfPEbjp7dC+S+1StYOQcWr0rgQ9DrZ2Ptj3xvbdBq7mxZK5AVXTr7a10wa8ebZo8PeRuDdywKcv8iVO9lFwA8P3txCsz5WWRuB663lvPWbs/1uA69F2O+cRMR0Xf3/f4SMCUe5pa1vTR2u4B66R9jwSsNunhVc0mtuYoOJAtt+kv0DsLnT0HEdc7njMS1LX2F4DrqNzH3HaPTN2JGkNg70HsTrBqz3Bjtyo1S7G8njejlL90fOOL/lgfuztEQPVP/e4/Vobx61de58wHE+qsY1z5qXj2t+j9TNu9+f0vz0ap/79tdarxcc++jv65BLdPXuh/GhYxtutfOv23QauK7c10gNX2+61FO39NzVQ7l9sP6rjBBxfYHszj4IzH7XXJnTfh16V1BPDPyjgOnrG1o4I6NECeIskNl4Lbi5IcM+NHoBWYz6aINALBEcMeM9j9AzwkV9OPxSjINGE7uw3qE2qOvI87MGj3x4JwvisowPEa8B1xPmPQDhuw+N51Ot0xk8v3vrnSKCoTeJsi6+9pN5bauw7fCqFvCa597+9df09utdb2yNi3ibR0TEvMaqvrcmRmflcgO6PHdffS314pV9tPQGfxIKNLu/98BzxLj+zwHXGBihzn9Zp4SZx9Vx34jaQC5AT6DjR2iQ5UvHA3eK9W71vUUkc7W/tNfXguH/87VE7eoa3tJe425cW0hFnOAQc3zF7/VjDMUEPt+Fu6WVSt90LA31XjlSKcJOejhbTI+DauusBlOD2tAZivdqwndQ/20vvrkdYeeH7UTtia/tBOGojczaifM8ZtMGL99N+5n48dk1hhC12HmcNxMa0WS/N67G9xDS9NDZHzz2OST8Gbzm/P6/XFvSMyWsM6lvW7ZGqr22Px7X2Enj1Y9Xfv0nErwGW3PNW7baNpo7TqAeu3pm7519+Zp0zVoxwNcIyrg04nvMiN1NXBXP3bPErL3HQI2d8EFX3yfZLUtJIvF46/6X9Y/s25xz14SWw6rm3A87uLljYpaV9Hflvqkb8m8ttc63tiUFbMEludHT89IJB3/2e0PaM5hHt6rfbp+EO3NP61D1Dr+O/myvt71skph40RonrNanrCLiO5uTYv5eAa5C+emm3fWbu6aly8zrDf8uhk05Hatb3/5HK6+hvPw7j/Bufc9yWg33t+2sA2PrZ930cx7cC11Ef+jYCztHae3T8S9dpf9ukDt32o7H2udB/7fmpRzxTz/w1rbEq1J6J244e/k3tuw1cfeLcXhtxRBPGd3vHJI1qnHHi9wulJyaPnDMegcUR1z0Sm0fn9/146+J4dK9H7UjKOmKzBnWf9Mf7Z2QSj5zSWqqniqmZWqqZvguNYPaSVTrY7nmP/VzuX1c/hH17bd8oZO/3Erd3vcScHE2+R8eMVKHv/CeD53+P7BKPCHCPyCNwtfOGh5Vw/A6moUufSK/i24lP0wuN43VEPHvGiGH/CFyPnrO/Vzv/NcB4qY1MwiPg+jYOWUd9OJoHR/18C3Ad3ePoeuM9/b59IuxRuzFqgPth2KUsNeDadzRR7Nu17zZwrXwa6N9L7nfcIJ86D+5zp0exft8Rp3egKnyJWbvDwNGNurXXPAePOLm3xGWM7dE5I7q/QDjHNXTEDD4arlG7OtqaRuLXrjGaXB5JXEeLqWfw2nVfc3TrMaGnqa3/E/fvvMSOODcudnRMGFUBnyD08CDtwUeGoZ3bI0bb91aC+YhNHgc73I93k7J6FW3jusf3dzc+TfJ6TS01Mkv9M/vvR7g1Lh/9HCnoCCSPFnN7h71mpu1/q7T12vt5BNRHevCj9hrw9seNtKSXwgYP0v59t7/9aUdrqXds2tXG/Tr48dp3G7gWjo3E/Tx8JOTcmVKkk7rGC/Xb3QvdVV/yunp8nNPaER7l9hCf2NsYT+z+Ht30pYVzdE7PoT8ArJ3TEv/wKV15C3D1kkp/+x245J4GjIAxaK8e3rddV/prD9ftMeRorR/xDH3rsWQHuQC16a2bvWsbBqLevXtFsf+tY/ttNCAEFEWa+nTvp3i3q19B7aedx6oI4hm3R1VQu3fs9r8kIXZAceSzcTT2bWyU23xRH5+7frzhnk3dfPez3H//RNhRVz/7jwo3CnqkURgeoL/v0Xr9ZEL0Ew3uTxwn12sEezx+BHIZ9r907tj6e/fzYjy/LbJOldGvu5He9narcWgaE1H7g0r345gR/e3tuw1czSFjVHX3k7p/n0dM0ThJb6uO+0XfUVAJ94zQ0Tx6dE/16430pH1RPfihXzTjhcebjce174+4yCOq48/abBu9Q9kRaMD9+mI4ZvSuHrswgtXRnO61syN4jo86SnBHn3bcI6bjSAhuTYCg+/ka/KBuTWp3smqHoFr8R0XVgEc1YBWLigNVQDRSUQOhYVBVGnw14BKbxgJIQRCC+DyW6l2Wjja3jXv0vpWX6Ab2BZ7mRVreH1vH6z4i0MInTgDjvY/WW8+gIAfL4GiBHlysB8V22t21eprQM7oj0/tovY3ttWPaQ/fP8IjYvOV+Rwxwz+XBJyrCnlkdVcP9Oit6cPl2/UeOOd9e8vruA9fKPYj03PC4sMZxG9fRnlCyn4iNujXQ6l7ktwWul/DmjlP0C3/yfl+62HjM0XEj1e4RxgexPeOojhuBqz/96DOqCvv307cRKPqsJ6316/jovEZo2oLK3d/c7e/bCIBvcLCye6mdW0ClolSUAkVRLahmqBulZkrNft/svxUoxZhRoGhAVaja3regGoBpqFXkDxhsW3xuCA46EaCQRIjOXIVQbcqGCCEgIkQREEWCIMEGQKQf2Hq7VwO8fpyOmMFHat47ABtVhd0L7afgSCgfAWdrfbLX/hHqyAj249jd28fzITNU/Pc7IOxbT2iO9h+1l4jG0TE/Lmj1rb3fdm7/vRv8Zts8WrdtjfYeg4f6wgZco/qj/f7t2ncfuBpRhWNucOToH4JXm+T9yW2hdZPmpUX1Oa1h48icCdx5Z921HtDa35eA6yWJbWwddeqlrDFWapR4Hn3otkdJDT4ds171VofvfbfrsN2uP9qxevAbcyv3Yz4C4X6/JtFUqJWq6mp6RYuiuaC5klel5kItlZIruhowVc3UuqFa0VooJVO1Umv1/U3iElQbWAl1l6oEUaElOBXRfRiqQNDggGUSF9IEhkoQNbCKQgjqcdsRkYgEIYiSYiCEgIRAiMlALAopzASJSEggShBjZkIAHORsrXTjdWfP4FMQ29/ZA/WUPchjJqcHzn5OtWsfMTT7/BKX+HoC7Z9236N50M8FFW4er3eThPs1eARojyb80fGP2qjiPGhvKsY40o82iC/0c+R3P5G04Ga/Grm+Oh7I/di9xSZ73L7bwKXKzrY2Mf9oPsGn4PXJtR7d5A2T7XNB6+ieb5KajwBovPmj315TX7TFLPec7SOAau2IsIy3P7rtI+Z0FCZfemftvB4Q+/P68KFe4toZTHVGWvdzVc0OpbWp8Sq1FgOcUqlV0VzRrVBzZVvrHXDVnNFaKbpRa7kBV83UqlRValn3qQviIAZooBJutKVl5Vbp6JL6mxR/VYqI91+UgAGViBJi2IErSCCEiEggBJgcuIIDl4FcIMXNvodECJVQJkIOBAUhISlAFSSG23hXMY1ks1P2NKpwW6cvTfIjwaIHqUfz72hujecinTZjBK7h3H7+NUKv/Y8j8X2tPers5xKNR8e/kR7pox+OTvLnG9dSU9LszEo7ZlysrT2qKn/XqW/VvtvA1REcWxwPXkw/drWfjOPL6v+2398wwR4xXEfzfHy/4/7xmnfbb33R4zO8BlqwqwaET7P99MMwqsJ7ierRcD0Cpf73/piRcx8d8o6ufwRcgxSgjcm5A0IFrQYwCrWu1FooW6WoGiCVQvZPyQVds/2elS1nKEqtlZIzlUrVYtu1XbdSqqsGFbRuZtdSTILTiqpatzR0zxKc5gpowEqgW8c12rZ9KogBbcKZ72BgJQH7iBBj3AEshUgIBn4xRWII9okzIU2EkEhhYopP9vtTZHo/I1NEpkicTEpDAlKDVSBX3d+V9JKYKvcxet3Y30ldwzs9sq30p76VmWkSosZPj2vLY7+eX3Snv0cc1FuAa5z0LyFs3x5d+xVO7xHte3T6iwe4dKrBbFeb/3znbEOnIrwjsN212vaoKmztZ1VV2KiSxsfzqR/Tbx3v1k2wdr1RonujpH4oPTzq94/V3srddYRjtGs90m33a3HMCNTaIzo1zt2+NZVfA5u7WmrdtY5AfSRAI43ZOUfdpSItlZwzpUlMW2ErmwFUqfbX1XzbZhJXqRXNG6UUA7Ra0OJSVc5kNSmrqpp0VnWXtHaVYK0dPb85b5idDFBTE1bEQQdqdWnKP0pxsKqIFBeWlcklDPVzg4gBVKiEBlwkBzHstxiJIRFDJIXJjouBFGdSPBHiREwz82kmpkBKkfiUDNBiIIVpV0WGkFzFKcPLGB2dXpiTPbP0yO40vv/+0n3rMzu8hAefHHNEgPvneKm9BlqvMcSPxMBHv79y+Ge1foE6F5LjTX3fmzhqO2a0X43v/RH3+bOqKuwHqTlWPAKF2v/YOL23vuEBuI5OfbQojj4Mfx8ycJ87A49EmVea+D+P7Asj4Rj720tcR/aicazGsRi7OM71o2woo7mhP3dXu9mPqkCpZl8qlVoKZd3sby5s20op2YBqK2w5k0uhlsKWC7W6tLWZ1GQqQzu/NuCqZrsqDnQmPSm1cNNmq4FJ61dVdelLfV+TzmxAREcNeHONb1JXQaWCVER8nygpsL+IJmkFAYlmrwohIBKJLnEFEUJM/j0SYyIEOy6liRRPxDAR4sS0nIgxklIiXSf7GyMpbcRg14wpEds9/foiTZ3p4t8nut2OeWrtkWqwf+eP1o0Mf4/W3NHffeMok8GLC/WgA0eT+6iTY0dfA62jfd+Gi36p9dx52+XSV1826BMV4Qj24+cLcHnrkT4+nlMdIft0tn6G7rjf/VCPzD3339/2Eai+dT282l66yEGHQ/fTkfNFL20d9b3nise0SkdAPc7v3gljPKaXtvLBNe+urbegfPci02rSi6rZoHLeXHLa2K6rSVols21XsktZeatsLm2VnMmu7iu5spVm6yqUuqHFJK3stitVpdRKzRV36aAW2e1YVdJtCIN2Epmr1fwaWm+TR9VjtFCTqLTTn0oBKYgUmms8osRm08FtYP4JUQiY96DEtINWlGgSVnDAiuEGYikxxdl+i4mUTsQ4kdLENJ2YQiKFRJyjSWExME2JOUGMQoqBODlABgFJWFWG27QzIOvm5ueqmx/xao+W9XheHY89IsL9iW9p48Tu2/CAd+E4RxzxIwb7Nfr1ltYP1hGH2XGM6ozHXVdGSVS5B6jRY+cLcHnrqd8rHI72x8OxG9JRO1hUb/EobPv77h2pz/rjf2zw6p7pUb8eeV81td/o9n7k3fcI4Nqxzkc8dDTqXd3HfvZq3ZYoefQIHNeFd1DrhpZMrZk1b2xbpuRK3jLX1VR5ZdtYyoVcNkre2LYrW97IuZCLkrOpA2spbKW4lOaSWpOsqqkGay0OQMVBR6mVXSWIx2cVFZorOiKoFFTU4rEq7GFeKiaBAdLyOO4PnW8gRkakz1pqAyeU7v3awAZXIVqcl4AEJERExB01AjEkl8SEkAJB0i49JZfAYkjEaBJXTIkpzaRoUlaaZ1IMpBiYJpPIpijMSZimmTgF4hSY0+zXOLnXoucx7NdG63r/95HUf9RGWnwk0ff0tafZ/g4+dXHtL9z2v7WN+s6uU0fOgp9IgUf3/gywelWA6z2nxwN6ZG8DNhKEUVXYL/iREx05jZ/VlE/9wLQ6W6MN8MimtLd+ZssL86GbaC952x11r4FWO/8lJuMT8Dq46OdoH8a+HTFW/f7RtjDatxh+G8Ht6JqtHTFgn3C73XF9LcL9ePXxqw4UBh5azYli267UbDapZVtZt0zOhW3LrGsml0zeVta8UMpKKRvbutr+UthypRSzJ5n96wZWtdZdJVibe/zu1OFeiM2OhYEWVFMRaoCgu3Choh603D2z3gBMwBxJTGTcpcgWMCzaVG/jhK8Gdu5laOTGpDbzT7CMGhKKSV6YAS3E6kAmpt4LkSDRQCpOO3CFmH1fZE4zwbfTmpiiOXdMU2SaTPqaY2SaTsQUSXPkNBViKqSUmdLs1zZpDtw2hjiNkxsD1GNJe7Cj+TZuj+f1493TYvw++NjV9qK6l9O/qEMudOzUIz9+P+5hxh0Z6Lt2fTl62Pb1M2mFHg3OaLx/SXx9JF0dcZZHv7X7fbv2HQeug9bG5VWmZOCEjsDnaC4+cg8/ItSPbvtat15qjzQQ47kvubEfqVd6QDoCLjk47ihx7qM2zuG+vEHfegat6A5ct1CRiqoF8ta6uQrQ7FXL5eKSU2FZVhaXpNa8kR24tryxbQulbNSysa0buWRKLWxZKS4BacZjr5RS1VSP7tpuNivz4sO9EdVBxmEC2XHHvQeDeiyUAdeOXC0+a1cV7V/sr7JLYY23UmWv46h3BMTPaQD3yQA7OElFpInEArFl3xAPSjZgMzViIUiyv6EQYyDGyBazO3FE0hSZQiBGYUqRaTZ14xQT81TMiWNKbHMhpUKcMk9TZppOpJhI80QIoMHB1Am19FJRe+BxXvfDBvdr/yXgGiWbnVZLQ/kOn/Tgw3Di/Tg/5hy5gdZLDO/O1MnQxwPQeo1ujb/pPnk4HqS3ANfY2aMxOgKtRwbqz2s/BcB18OaOpIyj88bfHi2G/reeuL/FBfyI0Rjf30ivxv2vPdPR/UcAOpJsxtZzt49UgSOojXb2o3700m9T/fUp/cZ+3UlcJmVpbhLPRl4/suWFbVtYloUtZ7atcL1upurLhetqdqycM8u2ULabM8WyLgZKpZDzeqcCbHYnrcHVfg5KNaPtZd7ltRSqS0RBfFvbkDQbl5oNqxGhBHcBrfv7NIKmClLV6Yn/eOdS3rJsqPPHrT/DgDag28fWgVBM3NhTP1W/rghIRDC1YZZsNjTZLFBZ5ptzR1r3OLBpcpVjNI/DNCXfTszpYuCUEqfpiTSfiGniNM9M6cKUEqfTiVM6EafEdJqIc0JChOh26z62sGkxXspROs77fn72QyXcawKPhKndo1WskkEvBR3qwh8hSccgH6nX22W1O4ahL+MxL9Gdt7TiN1K4r5BxdJOxo0cEqS32bw9Ib23fceAaZqYMu0bu645j6c4ZObRHoDByey9xTXC/UHrT2hG316vNjgBqnD+vTdAxBVa/GI6YRuEYuEZ711h1o7XXFlG751FQMONxCtlio7S5qS+Zks2ZYl3ObHlh3S4sy8W8AbfKsqxsuZKzsmwLeTNpbNsMoJqH4JazqRlL3jNaaK3u5QeWxcL6YqmYYCdSd4Sr9Vn8z83WqlpRp6473dwdR9r4eWBxI8KeV5DqUlmrvCzsalJtKh6vIacdoWnTW5rOUW89bUHWO3g6Flhws3JzEvBrtd/FJDipIJTdQzCUukto2yY7iMUUicmksjRFZreTpTixTJWYMjHNnOaNeZpIMTGfNk7TYl6Kp5nTk3ssTomYZiQGD3ju8jYeCQrjuhzXa48zwn2h2R4g+k/A1K/9OTuh7yft2D4DVT6hUV0Lw74RI9/SHjGtAntarJZdRPXBuQNR3FWNw1q4Xbi70efYS97WvuPA1c3KnisbweTue/fDYfbp4fiXgOsI6Fo7moB1+N4DyHifcfuobwePdHfeI7Xf0UIYjz0CrqOs4EfOQkf3GDUHvZs7N6LuX9Bc9lipbVlZLht521jXC9frxYHr7MBVDbjWhZyVnJV1W02aKoWyKbmu+/VKLaby221klUrzTGwEXLq+jQvRHr75/LVEuNp+U27bDSHC7bL9T3fVmXcmR++TaO/oY5RNNN6kP/eCafk00AY6Zm+TDtpuomAwcPaOBL11qD0p6iDR9XcPeBalagUx4K0FpOVBzMVixGIh5UBJlRgrKSjbpLadPBRhKqQUWfPGejKwmnOm1IlpmpjLzHSCoJGIeT4quq/13eGEWx/v1uWRWrEf05Fh7NvovNEDWwOyT1BvbAcXfglsjtZ2u+eP0166ZgOvfd8wnkd928eu57p6pO+34dMxOiKun9d+CoDLZ+cRmHxC7BtLM4DckTqtIzb79xGojtQV/fFje2mOj9c66v8RSB59f7SAj/T9j8B4/DzyNGxtVF2P0mQPWM3FfSTO3Bwu8nJlWcyp4ny9slwW8rqxXq9ctitbvrKuZ5bF1IPbVthKpmzF3Ne3TG7xVrlYYLCrBHGHChN9iklce38b6thD7umUhgfTTl+127U6SicidkwAgu7jtlfQ8RqNMsm+v2ltqIIUd7QomIt8EVQU8W1RyyovrZ+YDc5Eo54qN0DjmHkDKrF7bvyawfIlkvx79Gdu0ugN1AqKiAFZCEoMlsA3pMASlRALMWZiNMeMlFaetgspzSZZzYnTdlMnXtaJeU7M88zpaWE+TUxPiVM8EVKyxMAh3OxeL7V+3o/ajh53HqntxgS++zHCrVTLyIUe3Zzj9dcf+lZ6/jlA9hZs6DV8b2Gm29QC7itctx+PxqGvY9bo8EsD8nL7jgOXU9I+QefIYd2BUjdz+0nyCOhG7rjffqRD7xfGURtVh4+O6ft21L/+Ho/63o/BEQCOoPYIBONwXGs9KI314fqFkLmVoGmAVfHgW3d8qJl1XdhyIa+Z82VhXTa2beOyPHNdNrY1ky8rl/XClle29eqSldm1LCWTUoqSS3NZr1ChuAcgqtywyJLZmkfquGrtgfQWINY9XLSl58zQzQkiGC0VQQhoS5ETBUnaZdmXu4z7Eg0EWp5nqQolUHPLAYgVY8z2LJKBknz80v5cBqFN+lKQW42vHn8No7r8h9qrHA1wLfN8QB3ARu1E2NWLskvLgtkHa63mal8qJWyIZEIQ4pSJyRw6lhKJaSHFyGmeuKyROEXm+cJTOTHlxFQm3umJqSSmnDjV98x5Ypoj01PytFMR0cCeh7Cni6+txdaOtBpt3BtRH4HL3/OdWPaSSq9phPr7HNGrozXbt7eA1pG25+iYfpx67O2l/CMw1fY8zuzcqU3bwPWtrxLeD+jPLHB1I3tUS6c/ZMye/BKxfwtwHR33uV1/6ZFGgDyayD1wvaQa6a/bX2+ss9Vfs5/8RxLpqG45KvDbfuslLHdrV3c5L8VtTXnjer2yrpl13Xg+L2zrxpZXzuuZ5ZrJW2a7bCzL1b0DN8984emYys2dvXQ5AKlQ756rf5DArV7WCF4OBu7eZtkrbuNpU8oWpezHNjtMcClK9sqxMgFJ7krFaMLd5M0TUWhSFQZ4LkRp9mtVP35zSaxi7vYtESK4lGhgticQFmjVD1RkL4RgcqLsz4cEH50dobDYs7ZLXWoUH4vmdKL7kBldsywg6mooqQbvpRZCChSJxGLu9EUzSSOxJjYt1FCZNJHYqGLbU43kAFknJk2cJDFzMld9SYjrsFupF3+4G43smb1HUsXR2tNX9vcXGOd+3z6HTrxEW167xlvvezQeLwHXYR+kk9ZGIOrRcLzQ3QB+q/YdB66D1hPnNnb9hNuBjnti/BpoPQKUceK3ifOa/bFXGx4tnnbtI2mnv09/vUcgVIdjmtpv4sb5J+6lpN5BbRyT/pjGYB3Vz2rfM5AV3SWuguZC3jaWq8VSbcvC+bywbhvLtnG+XlnXlS1vnNeFzYFrXVa2xQOG8+ZOFxbH1XL/1eZD0ajoDlaNQDfiXLkZnfosFZ1BQyrBB1BRI9hkblWGG6FU11y1+6R9XCUBJ4FZYMY+QSGqbbcp6YHL4uqpUNm9Kk1q9d+iQFC0AMWdR0qToIxai7/ABlxCoGrxb6GJXS5RYc4g+zvW++++vQ9jsOO1nxTuftmHA+xxWV6ypWyVUAUpglQhJPM+XEsg1UQs0QBKMlOJTJrIFFKJTDnyxMa1zExb4pQj7/N75jgzx5kUJ0SiOci4k8ydI0ffRsno0fpujFdPS8bz++uPzNxL7UgteST5PWJAW/s04uG4jeeNEtcjW/XRNfsxa6B1J3WNrV18vMlLtpaX208fcB21Hgh6TmsEqKPzjib0HRB2bZRSXpvAvc79qK+9VDQuqJFr7KWn9lYbuIzP3UDrhBHOBl5HjhNHADmqAZsq8Ehw2SUuNfC6ZtbrlXXZWC6rqQTXhev1yuW8sK6ZZdu4ekaLLWeueWPdNkoulGVj81pYmutNsqp6I7DRqWy1wTLi3dD6fsWKNLfwAPu2eLqlah+xIpH7dAnJgUFsoESxhEpxBzMFJA1gdQKdFZ4w21YUSAqtREhzyiji70GhBsvutPp7yiCrmI3HJbPYlZfQaiCFhjtpQ0UIdxlnu9ekgeY9SHCloYOZujpI3emjzSGVTprbLyb7O1e13IpaTZWvCKHLIyk5IlrJBTYNRBKhBFIJXCUzlcBUInNdmPJE2hJPdWVeElOKPF0nlnllijNzesf7NDO5231MM5Lcnb73zHzUHjGpR44bI83obWM9fX7kxv6W9ggYx214DKZjO3qO9ncEsaM137c6nBNw23WPvK1TPcr13PpRp97efjaA66V2BF5HgHUEYP05L13/c/oCn9qejlzQe1BsYNRLXe2Yfu701250vK9w3BuhH4FuD0jjpy+/0wipgm6VuhbqWsjnhcvlyrqsXM8b58uFZV1Z1oXL84V1K6xbduDK5JpZiwFYLVbvqmSXsGoL/vVO7c+pbpe5DU/jv/eKwl0c1J6FQtoKNOi5qf/soZpEY6rDgHQi5k0Ca9/wsh/QbLAa1exZ+9grTGLqOPTmbe9Es0kMgiANc6MVfBT166K0gFn1c3wI7spPya5tuHExN5ra91OpobnWi8O+eSjeKmfozS+htSq3fJHuH6IVkyz9RsZc+H3EcnpY122ehCrUEs1OKYEskZyVSTOpTBQqmyf2taDzyhQ3TrGiU2aKE1OamE9qEtw0IZPZv27LsL3/7msvVfWt/z4yum1fv956sOu3+3u9FbzG9hKD/Tnnj/uOQOs14GrH9+O2Z4MO3Q+9Lav/3hOjb9e+ABfcv9QjR4geNF4Drva9V8+9JHUdnR8OPkdZKkp3Ti+ZNQl85PrgU/f2/h49dygH57ZrPvp40cA7k1FVylbIl5V83bh8OPN8ubAsG9fnzOX6bOrBdeVyPrNuHky8eSomLZbItrhXYClosZx+VQt3dYhanFSHWD1Yichtqagf2QBMzHhU/dzgXhFW66qVdzSQEJoqSjG1YnLgumevzafB3c6DST0agCBorA5ebcE7cW0q28JenNFSDDrAactu4fY2B0dL1iv7M6u0702SauNhE7jBbZNS9xOTUkN1D2m5ZQjhJlDdVId+rlom/P2dt0wnLW1Ti+LewVPRoBBuz6KqFlStlVgyOVgsmCU+jsSwsWk2qSpGcq6sm31/CpkyraQ0M6UTX5XC6WlmphLjjEjgptb02dFcwHssb9LDEfPWr/nWRnPBI1CqbzjmLe2oD0fXHAG3/T0Cr/753gpc7R4NnPuxq8JNbdjrWI8u8gW4Pq99DtdyBFqPGIb2It963/H7aNfqJaN++1H/+372k69/y1N3jYeS0gsfGPIHduft51doeQLXzMcfXVmer6zXlevHM+fLwrJklsvK5Xph3TbWdeV6XdiKZbvYStkLMZaaqX0nOvtbz8y2L7sDnB6vW+mJldz/FhFuwpoDk3Rqwl3X1d3X1YU9+y6iSDV1nVTQoqYC3KBOmOoUNXVh7F5Wex9ZzSEjgxYh7hlHFC3qdjD59N35X+kBXQSNpl1sc0Sa84g49jcPyFA8SwaoKDE40InRJDu0sjkgt2TBoeD2xWqZRxyEqts+Q7F9ukvG7mkZsfqOwaTRkFzjpAXxeRCDpZ+6ritJrAjmZb5ymmbmmHiKJy7ziXmaOE0TS37HKZ+Yt5mnOnGaJ8/m8a6bx3Kf4/VoffetMYdH+/vtxqjGbrsHBbq/j9o4aUca1Dcdzjm6/gh4PYj2ZqZ+HvXHHo1HO2Y8f6crvbG9j/R+1OnPaz97wPXaWI2TBY4n0tH1jjgd5W3v50jKOgKuMWziqP9HfenBtv9+Sy5+m7i9nWsEs/F3L+FtHLZluqgls16urEtmuW48f3Pler6yXlauzxfOl5V13ViuC5d1YduyJ8JdLYN7yWz15hWnO9ffr/6GLrpjRmgSgbbcezcJY5cxhA6YWuRVwFId3RZY6NR+5mm3yyj7eXdoCXgxE8wlvUKtBi4Bk0g2zyy4sodaaVCTqsBUnl1GfHFnFilQs8KmkAVycPAyD0Qp3XN7JeX7V28Apxrci9kHweeY9HOkBfe6ZHgDNkzKA89jGNyBw0Ohowc8F+mSDgc0ajdX/AWpnafRziMKIRqjXkM1UAPP0eiB4lg8XpVIkUjJlZoqOSbyVMilMuWNtUxkray6caoTRZ7IeWaeJuZJrGSLBCOhe7YIPtVijXRgBI5Hax069Vm3v18/I2PZX+PoeuNaH2nO+P1I7fmW67x0zEhz+vHqx8eZEnvG/odehdgP1LdrP3vA1dojrupzz3uJezo69tE9jtIt9e/86POoHYn7R4B8xGG5qufOS3AEtd6TsLh3W7XyHiVnsqv9rteNy2Xj/PHC9bwYcJ2vBlzbxrosXLbVamG5l6GpBF3auuuWPdROZP1v+y5qxHY3V8ktcSw0m5A6wMndEODSh+xFDs3ZolF1aUeq0sSUmxu57P1sxR5VCqi72ddgoJEdBHApozkqiEtdjZgVB68sN/Aq7pHZvDIzaMGyxFcIpdmiIKA3xwkxSxy1FbHUHd3N/qZ3c3KXVPssNEFuns7xZueL4QZc4t6Eewxataz4VRXN1Z6/jUFV9gz2LTA7Yg417gwihD1pMf6neqB4lUqhUjZFo5KTzZ1SYMqJrWxUKlvd2OpEpVLmQt4yOsM8zcSQDJhr7IXnbkJxv/bG9Gnw2P7b1ldbg6HbHp09HtGOEfTG/UfnvSbFvQS0/TEDb/jJOUd/R+Da+zkCF9wPwlsI7nH72QKu3t40EnE4Jvhtf5swR8bXo8n0iOMZJ8VrADU6Zoz2qSOubuTw+uft+9YAqrUeoI7K7IzfHeQ0F8q2cfl4Yb1uXC8Lz88fWC4ry3Xj4zdn385cLqunZsoePJy9mnAl10Z+6ycL7SYz3cYteMohFETlBlp7VeEmRMiNUKOWnqhdWu1iVqSxF2nb3W6Gwtv0sJdhmd9j66ClP1IXf9weRY5QzJtPM6YWK5hTRlIDo1j3YGYKiKsUdffGFFh826vQBq/orVIpJm75lKxdQLCHRgsg0SS7GggSPSN8B/wNrGK4ccwOqhJMMozRgFxFTIXYntnHyADGFouqUqhojmiBmkE30FLRYgUzNek+z2/e1JY9xW4v1FotLKDao5u3ZyHrxhZWy06fJk5PK9NkWTjWslrKqGli2TZTKaaJ9/PCKb3jlCbeTxOTvLMs+eHALVu4ed+KT4sWPtKr1/vPS3S4X/dH2yNY9X4N/cQ/8nQc7/Ha/keANf72qM99O6Kj/cS6cwboVYWvIe3L7acPuD5nTN4K+G0ijUAxAsFbpK8R5I64un67B7WRgen3jZJRf32G43pQe6QKHH8bpC9VRUshLxt5yyzXC88frizXlevlyvPzszlgXFfOlwvrxdI3LevKuq6e5cKS4KrXt3Ly53O+T8PUiKQB1Q5YsdFXzzDhzgAS1P/e7Diy6wjrHvDb3plWD5RtUbkUl7gsK0Ud9UiK22tsnxIcPFscE6Ym1IJ55hV0jVAVicpeMLJAU5nt86NiKsAMrC6lZOx7Czmorop09z3Z7W7dy5cWICz7+Nm34I4bkebYIhFzuffchk0Sa8kR7HLhBnIRWoJg0zgmmvehuN7WRqKpCu0Za4SaxYCrKBotjVUNJvbsy0LZPRSlQHXJEvcitfctaFAv8qmgJu3HklAqU8qs00bZKuu8MaeJfKq8S5k1TuTpiXdTJbknYogTxsDIbd302oh+vR8xq0dMMN06eklSG68xgsERaLzEZD9qrwHbeM0jkOq3exte4N6Upe2vOLfWX7w/6du1n07geqkdSUefA2BHnNURl/LS9fvvjySto0n8iLM5WkSvPUMvVT1SCfYg6GDVvMS0VnJeDYgWUw1+vFwcuBbOlwvXxQKML4tlxMhbYc0ra8mdSrDcPNdaHaSD59pxJzi3H8QM+rVzPW8Ewr0IgjRp4Xa+5bjbabY/o5inYklGsHePgYJSqVqNCLfhdYFOHRj20GUHKv8CVNuHUHOgJbzd8xViEteOl/iFm9OFq9gojXDr/t5EOuBqL8l0dfvA7cDFbVwN6KsDeWD3WnTgFVenNnd7jZ4NZGCAGhPR7IjmcSgQmszl6thQLaOWF9KUoGg2NZ+KUsWkxh65WhFNbR6J+1w0RFM1cNcKEswZZMMS/0aX+fJkhUC1qiX0TdmcRlImp9nArsI8meiUREwSvcvoL58ydUdr69G+nXj7vlF6GmnJS2u9b6/RmyP69hZp7BFwHdG8o9b3eQet9qVHuZ4D+Hbtpw+43tK+PdBbeyQ2j7+PbeTYGtPRS12tb710NzpUtHv0ts6XgGvk/vqyIo8krP5D/12teGNeuVw+8vG8siwrz89nzh9dylo2zh8tyHhdDMi2LZtBPVvRxuocOuHGXe/PqoAEz1puLYrboYJabE4w4ui029RJ7RlFIEJwTzl177Xdc85BYk+K3Wpw5QDbTAvsNcmmG4Qub+HIOBuIuZS1xwPU7jS5xZZFbfl9TZJyArdjV71dYq+EjEFkE4iq3hxBDEjcab0TW+7pn/1gIFEMWNq1S3ApqgGbq1bVQUsdnt2GGBS0hr2iM3SMQTuo7agmUdWkhGSgZRKSPUNVC0lQH6hSHAi7kRe6cai347UqVEWDGf1KCUiJbLmQYiTFyHZdWKaZKU1s68o6z8zTzHLKbDVzKhNPdeW9rEzTE1M8GePS5xZsa6atl7e2I/rc5vdo6hkBjOG3I2nupfYW5nxc30e/v4YtR74Wo2DVM1D7AlR+HEL8HQcup7YtS0A/cCN3NE6iEQyOxvCllzmCBbw8EUaw6kFLuLdZjcf254/t0XMe9W0ErY2b1PUoU8ZeQ8qS1l63heV6ZVlWPp7PnC+2fb6cLQ5r3bgsK9eWa3DLbNtGKZbdolJMNdQyMahLTY058z4ENQIa/Jl2Ghk7Tn+Xyqykxi54gNtNHBhbYtsIRFdN0RjC6q7bNgY6i3vE6W4ra3i1Z0X3YFtFbva0JilVeyG3siNGiKsWS3UkJt1J60Pv1YkDVpVbvsKmL63quQmlA1BXGe7BwZ1o4KrX5h2pXWyN4YsNnmiAWExFFk3qogQIZkcL0u6Juclr4w0KVfHUTQ52iB3f4hCi2HWaJBkrNWEpumol1IiqEmvYmYeW5d6ELXf8aaCLswyqhGbTBGop9hxVkVrRUqghUkKgTpktFlLayKWwPmXmaWOrhawrU5k5lZVcM6cpc5pXTnEmJkshhUbPACZt+B7TkKM1WrnPSrMzZvtj3a/zvj2iPy/RnUfnviSZHZ3fg/Zr+NL6PzLSO6j16FaHk75d+44D19Dewon07SVOp7/mCAYvcSJHfXgEWkd2rdc+/X3GBTDes7XRVlUefD65jnO9ngg3l8zleuFyubIsC8/nC+erZb44X6yo47KaxLW440Uphaz5pg70YNOmAhKXFkTC3kcBQpHd+6+po3a7lqv+bN6HXepq6r/mM6geeKtyAy2i0icTV7lx8xoxgGhgpdACqnWQTPeqKHshPu9DNRHSslFUkx32zB5yL4yFdo73BX0g/Trh3reberAzwug9eW+7q/qAauGWve/m8Sgtaa7/qi1ZbxN3o0+yIKaewwRXCdUDoIHqcV+hm6p3c9bfXbUB3xMH+zgGt3lV18HWwD5ubZ9b0Pbna7auNkdrVVoNMtQCnDXYu6gRSq0+F5RCMU/GUJm0UKgEEYpWihZkViaUmCZCEJMu1SdYv059+r24Rl8CtX7/59CTo/0vAdOj9hbg6n8f+zjSzhGMu/d/D1SPLvj29tMFXH8Y7S0T5qgdSVi9h+AR5/boe3vnIzf0SPK6MeifglUXN9SO3zMiAFAp68J1WbkuKx8uz1yuF5blysfzmee8sm4r1/OFZb14PFZmW7MXbvQijaK7J1sDitAFEosaMQtueLfhuklcRvyEMPmDCxA9I0LGiK1wkzwULKu5eqyQO0F4vJB6aiOiE8UGIN2Y6b6tNy1gS3rrIQAmgdm+ugEl+oktyW31VxfdqVEcb7ymloM37bcm4vXAdTcJqntA2gEmUNUH01BuTEJzmlA7niI2XgF3DZd9DCWYA0upaqVZ3B9eooGVKuYaH8TUdgohht1JJHqGfFF2r0RxriN4H0IJNyahgi6mQox47bQmsyYsfkvtfroDMTcGA1DPRi+CqSIDpqKsSoqVUgKlFrIUT95bKWSmurHqRtXCkk+cthmthXdTYa6FKQSXF4KXm8HWXNq5pPvXcz/899uPmOQj4aMeHDe2I8D5HPpUH2yPtKXNz95ENT73zsQM+90Wvevl76SvL0l239YeSSevtTZBjibXyGk8um/PdJjD2r1d69E7HCduu8/uiMDxoumY8f28I1VhD1wdt6RYxoptWzlfPnJZrpyXhecPZ87Lleu2cl7OXFaLyVqWlTVfTcLKhbpLWX7Z6PaenahZzr2AqX3CzokHA67scViYPSPsnoCyZ4Bw5nrPZK7SOHMbgJa0Wt3JwCQuPPCVnXnoih3b30YY2w4F8dgpirhbugGtAZj4uKpLUYIQUTKOBKaga+mfpBFyfzp3JlG5BVNbrJfbmrA+SsReegucvUO3fiLuMuc+L5T9xuwFLtt8FOxhxK6vVNf2CdXtSCjmpg/sabGq2b00igMLBsYiu51MLBfJLXMHxpDsYKmKbgKpSUMQS3QlqKefih7Srfa9l8Qao+Ua2l0Sl1rdFmbSZVClhEq9WgqpTTNZM3NOzMWKkZ7SyinN5Kq8T5mnNPM+V6Z5JqWJNE23BfIWFVrf2lj3zFG/f2RMR0e8/pX35x+1t4DZKG319+mPk+4vwzbdOQ2PRlXhJweMCPnt2s8GcB0N9GtjdvSyHr1geDyRerAanTCOEuMeXUse7O/7Nf5+NDFHR4xPHDNuWSrWsrBtG8u68Hw534DrfOa8LFy3lct6ZdlW1mxZL3LeqLVSaqXWWybwEbiDc+MShOigFVxCkvapIBpcQuuGW6FlM6/obo9qNieTFnWXvEyQ0R0wdu/clm4oQcuI3o+39u9bjfC2gOtdDbarV2VXe95AqcmL4pc0O1SfkYIGxl0hybvixZ7lfrffNSRt+eCkf/ltougOis0Jgx2YWwfpgOs2VgK0ki4K996YFMu8oU2d2C4lWP6pm1pXiwFXaODVGSXtHto9rzndqMjNozEoodrbKwiVYIHHHlReqWioLiG6+nWXstv7a5OmRZlZaRVqoWZFV7P/7e70WahTpSZFNKJTodQMQXmSSqUgAcIU/N3G2/q6c0LYX/lxO6JF3au52/eIDowVH8Z1f7Sf4Zjx73iNI6evsfW8Ut8/uvN3zGqT8Mib4/PbTz9wPZoobftokr00AfuX3X5/5Gl0BFpHn15V+BaJ8CUOamxHANUHF/fqL3dzLzVzvVy4rguX68Lz9ZnLYumZPj4/c1lXrtvKsl5Z8mYpmraNWrMb3rXrZnOLxt2hveSfG/N34KouVYjsDgHSnBSciO2FijEyWwzFHLxwNZLbN3z8W3YHleBJbqtx94lbPaxgRLoBQ/MU1zZ+RbBcelhNLDXyqdKNqZ8uLnFZ9eDmXu/gs79z6ZgXvcU8407kCnt2CcXGoKF3k8BMJHMi44ClTeKQW4eC3JjfhiyCSaCOkntC76ZSdCageWGak4u/za50CcEYDJVGSU1VF7PZzrTZIxGqChFLpdW0jyaH9km5LNQhdOVUhGAu8yiBSqGYwOn92jPO7+vRJ4i4i36oXgHG3hvVoEyXilTIsZBjoZ7chX6qVl2mbmw6oVIoUjlxIkSYppkgyexn+BC2JI5tjB/Rj36NH4HSI3rUWg8oo036kdrv0XXG40a61jO8R33qx1wOjuuly327gZd0P3y79tMPXG9pI5h97jmPfu9tWu177z04pnZq540T73PATA8+o12rVxnu5ynbalLW+Xrlw+Uj1+XKdbnwzfWZ62o2rvP1mWVdTRrbNnLJVDVPMN0LFbZHkf3ZY4iE6Nw07G7VsdHj0DzpPC6qlz60xVkZYa1SdwcLdTsRVd0T3dPxSouacklC6764tL2HCQOu9h60kzBcMmxFEFnV0i/tRF46qcPPNXHhlrmdid1aF5Jly5hAnsTqcSW7f7DYVzRAEHM2MdVtNU/CAuKpkxqo1dJSRnF7LqAXBCDc1KdSDUy9szuNVPu9CSz2bOEGdNEYAdtu3jRhZwp0T7rYbJPmIdik5kAhJEGS54V04JJg7z+oGvMSoznjbBZYbLhczSaWTbjKsRIlUGokFiXHjIZKrRZrp52kjWeft35aeqqAOWmIClojmldiCOSwUXJlnVaWKZHryppn5jyR68ZSK6cts+XK17WY6vAEIcTbwN+w+3V6fCSpjJ/xGv1aftRek5D64x6d9xa6drTvaH+vHex/f0sfX2k/ncA1DuQRN/NokrzlxY3H9NxFO6YHpP7z0j3bZO6db8Z7P5pgPVCNXmm9lNVLW4BieQHzlrku5iH48XLh4+WZ67pwXa48Xy5cVws2viwGbjlnt2W5+3KjogLNULM/qpevsLjhG4cdJRCq7Hy37BKBg4XWPctCdQeEVheqZVwwIck9/zwoFdhd7pvXXv+6dxORyA5iLSVUi00SgRACgUDUwFYtgJXcJJBgNhtXhUnACHRxNaeRXMs4IQFJEZ1AJ5CTEE5iBv5ZkcmlueRj2JLsemC0MRlhB3FLhXSbHE0Vqr3XGy5pgkss5rzQnDOqmqqtgT4eT0XFs4j081eG+etA1jEm0OVD9HclBQiB3WMRAy5tUml7n2qSt6jZLyXYs0oI9l6iEsTGvFaIVSge0Fy1ehC7UJv6uLNvWgB6NcmzrSuXusRVjFUA3TyDS0GSeE7EYl6FBAM8KhKUWTMzhSd5QiRZf/cZz83+1Ushr4FZTxtGRrZfx+16R4zqW1tPb0ZQ6Y/p+3IEri/RI4bze6lr//01Yvu4/XQCF3w6kCPgjAbRRwN/dI1HIDhe+0gteHT+S/ccRfCj3+EYqHourQetegtWrbVQSna14NnUgdcrz9ez7VuulgVj21jz6m7uxqGW0lIPNe5fbuoqkX0IoqdeMn6cPW1TUFMdmdd6s380AshOVKsTFPNAiy5tuYHeF4+qqyjdxVqhk9j6obu3s3hnIImlPmpOCkEIMZAITBqpm3m9qZffMFUmXk8qEKIR1OD5/ESU4MAVJMApUCd14ArISZAEzNWAKylhMieEm7dnMKCs4on6Wv87nalgEigGABotRkw8FKC6RFWl7u7nVKF42iktapnnexDrsrhrvL3PXVRGb+EIw1zeUz9590rxedAS6AZXG5p3hgGaBlRLg3pCCLsN1EBBkaAkj2WrqrvnY61CqXal4nNxD27HpWvvt4ozA2qSuZTbMNqU8/ReU7gDrrZOAgUCbDpTqKQYiRECk3k8cgs4uFu3r615eB0cHgHMCFov3WMEmUFiv7vGo0//+wjMRyrKRzTztb6+0n56gQteB5m3TKjxnL4F7l9cf+xow+rB7K33bdd7qfUTt0/hdARc9f7EUl3Kulz58PGZ8/nKdV34eO0lroXr9cqaN9ZtcweMshvoh0uaik2c+PSP7zWebKiav2D0YXDXaSfYmqFkzIiejZwYSLpksfmjhdsAtLVtqOH7O+CSWxZXN9fYcRogpkicA9M83TJIRCWKJ4hdKyEpYba+B7EyHBJBsOeSTQhFzAUbV18ZxaNg2R32/stNLRdECUGJAaYKixNWQc0d3dWnHmLm2CUEd8e2YXO7XBRialKLIDuIQgzu36eCaKTWYF6fValLpXpGi7yZSlI92z+ukoVqY3PEhcfWE+v3Hb8gmWZvMq/EAMHsk+a+Yv6XzZkjakS03gS96OOrQoymhgxqdcJqDNSq5BrJWghaCRal5cm69MbggMfj6W6Xyrn6OYGcoGQlhEpdlKyRrSRqgTVl5mlizRa4fNpObFuGCqf5xDyfmJ5OdGVKH7cRkHTY9xpY9NeBe3XcSwB2JJH11+7d2D+HRo0Mex2+92DZH/tjqgt/uoGrb+PAHUlcbwWSo5c7TqojoHprP+FTjq3to9vuJazm1v6ojhbQciPVap+Py5nL5cJyvfLh+pHz9cp1WXhevErxurEsi0lZpVgm91zdi6/uEkAz+IeI2TCCkHYpC5KrbKwCcSBU9kSpeLFFqiVM1Qx1g7rihSQH13rNe6YLvUUc72NkSWLlzsbRkvI2dVUbkyCBp/lEOgXCFMimXSOKMKdoRFErtcJJ0v4MVRUp1ZLH5sLmJUdkhbJahpGqjXMQRCLV45Q0u0NBESTbAowiJBHep8AvnII5PCp8FCXOwaKfat3NKKconLWyVOValGkKntDD1Kdfz4F3EyyhsqhHPVQsRyHmJNHUqrUGk74ilhM4mq3QAKGShT1NVJV6s2v16sNmA+vmZpPATf2q1Kju2q/7nKnaFKqVIIGqYfcPaSESyd01g78/S0Flcn4Malnyi3k7Vq1EFTa1MIuKkqkgjelpTI4BZfNmrLgaUBUtwpZd3ViqeRumQtmKZbavwrZVSrHnKe1dT0pKiSAJQrg5sTQa8NJ6P/q8dE5vStBu3wga3fvY76UP9r3VLtcz6yMQtd97CbFXEx7RyG/ZfrqA6zWAGH/7NsDVX+c17uho/1vbEXcF95O1TZDRW/Agp9quOqFQamHLmfNy4bJezI61XrmsF5Z14bJcuKwL67aybSvbZudUT9u015JqXRN24hKCSSSxzx4ecFuPEKurgarZgywzO27Lgpq5qeXU3JBNwpPdc9CA69NBbX1pajKEveT97iiyHxuIRJ7STEomBdQtW39LINVoEo9CLpXQnDEqkJsLtVJztSKRGQOlUgzUyZiNy6TK/f2IFYAMQQlBOKnwHniH8L0g/Ik5WJHqCt8gTCGQPE1UEWMA3iX40aacK1wyfP0UqEFZETaUn38Svp6Fb1CeFVbF1GnFgD2JS7JFqBU2wUqnFFOXlgK1KEsJhGD+fAhkD+i2+Co6cdpd6HcpQvZExKZSVJoXoB14C8u2PWF3mjQaaipDxT0BW/zeroozFaLVPhOSg11tzylYwuBmaxNcfVi6aaNdKRUD5zYva3GFhYMi1YAcBSG5Pdck9eZlFDaBcCIFCMw3danez7v7ydrWDveEvP9tlEz6445s60fbPRN8BGKP6OIjetaf3/8dr390jSOG/Fu07zhw+VvsOYG3ANDRi/q2tx8nXD+pPgcMX+rP+H0ErAZWfTBxP6HN/xylsmwL1+vC9XzlR+ePPJ+vXK8Lz5dnLtcz67JwPl+5LGbLyttGWQGtn+SO2z3EBIJXsd2lrWiSVwitJGPw3IMGAFqATZzrV0pWk7Ja7SbNVM9oUKu6E4gPRgPNJj6p3JUwaRJBaJ2L4oHPeOYHYWLiFGZOwaKRtULKmZpNybStMCUxrnvbWK4FvSp6VcpzQVfrPyuk5pDhFXunUDhFqyll0p7V+crRsnjMM8QZ5ln4uafIH/9a+OokfH0Sfv6rRFVYi/Knn4TZnVquGnaVcw3wdRaKKjEov/B+oohy0coz8INZeErwD9bCgj37FANrMSNXVFivkIupI7cNwmZekx+ysK7C5qVU1LPpkyJVlCJKkcqKBwNLtXIluPem27RU2bNGIbLnh2wTePdkdMmkqBXhjBoIFCImpmcULcHViqbWC66eDZarihohaKRWIUj1I+2/SCWHYt9UKFJu2Tc8BEBFDHx9zRZVag2IBtNOlELekqlTa2XLM7lsNg51ZdWVIpV3WjjNM6fJ2KKdGDxS4Y2g9RYJpD8mca9dOQK6do4ebI99a33qaddb7fKvqf76a/yYakL4zgOXU3AN91JIPzCPjIafa2vqb9l/jriRt4JW62fl08wZ/bmdN9Tds/WSVu+A0QGXeZwVCpmtLjw/P3O+XLmczeX9uVMPXlaTsJay7KVHzCeg3oKJvXMBI8gxqElUBMupGoSYAjHFPaegBRyHPdOEVvbCgiW7g0BR6qYm2dWClu3msVhuju17OUm3W8geiAstPkpaReGOGIi744dknHIKiaSCXAphM8msZtjUBlZT5qpqKtI1U6/ZMjxsrt4Lllw2EJirEKP18L0Kc4icpkCulYiQMJtMjIEQhTJbfUlJ8LUI14tyWZXfuyrXzWSDpVQ+FOV7U+B7s/DVFJmjSbIqwBRZtXKulX+SC3MS5inyJ5JSUD5W5RllnvyeIqyilGJqypiqS5fC0/5ule8Fq6FVK1wqXLUiMTDNiXOp5rcRAmUKbEHJomwxU1QptVJyRbOp3cxrz8rBmI9Di7cDS3Vhr87Uiu5ggmVSKbUSaiBVpXgMWNJAxW1ce7Cdx465XTWq26nEGJDsasiCOVtIMY/MGl06bgsxGkU16ay6w5BSSt2BVytUClvNZAqalCK+He23shX0JJzSTIjJXOZbYsxHUpZwo8S95DICXgOdUTJrNK6nD6PEpQe/NfVd++2Rg8hPun2RuIZ29LLb36OX8G1fzNEkeCRaP7rPIw5JD47l4Li2r5+w9X6fYmxvyQZaS7lyvl44X69clsVsWqu5ul+3hSWv5JLZ6mbZL5qU1W7uf0JL2+TBwibYePBoEHfECHu8Drg9C9zl2LzBanUHjAZcxW1atXhcmKkmjTm38+89aGWXskzS4mZ78eDXEM1JISYHrmglUiIQipKvldDcpfGkuCiUQtFKLRVyJVYr2BgkMEUh+vPGIEzZuf8a+JrKHGCOsNTgdhphCpCihQVcMecBVViK8iErJajlbhQb861WflQqS1GWKiwVTiKkapJtCQayVxU+bJVZhXcCkcqqsKiSBSYxiWJF94QbqjBFk4yi2phm1NPwafOf4F2CCYWoTJNrBANICpQ5cBFYUNZoz2PSW7MH6V14wq47bAxVe5dq87QxJC3Hr3gWF6mgDn6m/vNzPWJc4DYPfU8KeD5fl7hpYc4maYlNQKoEWrXolvLqtsyUPeJATXcoCpI9ri0LcbtJwXEzqVAr+9yfaFlMWsXtbvIegVcPWiPw9OfBDcRGmncEXEeM+yM60/dtvOf/h9pPD3CNL3Bsnzv4RyL0o+9h2H4LcMGN4xFusR/jdjuu79ORqrD/4KClSi2ZJV+4blfO64UPTeK6LHx4fua6XlnWjfP14vFZhZw3cy/HVTk+yy1eSdyzDvNSE/Nii1GIAeN6Q7xlwOiQRnEbRIWqxs1a4loDiNoKS9aMqvkqG13ZneW7YQzsBMHVgRazI6YmnHHJLzCdEmm2mlNBjGNnM8ngfMm06mDzHEnTZJkWyroH1yatTNHih+cAT3MgViEWMdvGqmbjUuFUA4linD/m6p1d2ixqgdO/n2GbIAdl3eBZKhqUqQrfuCRSVVlQPpbKaRVCypyWwDQJp9mkPUPmwO+WgooSL2pSVRBCFP7U18EAhcKHojyJkKK9kzkKMdt4bBmuqlyzAVmp5k7/NAnfm+z9aix8hZIm4XQKrE/K7xflmwLLbFxCrcKSK8vViobmXNhWf4/2UPYOFXNzb8jQHH20SWXOGFXL9mhvWrvlZcxF9AKfIUQI1b1ZIUikBkG9NphItvRTCBKKxWRVIQcxB6BqC0dbKIZLdTiYq7b1ZB6XNZsTjCziCknzstFayTX7AxbqdOIpBoJMt2TG/Sw+ohNHrUlUvYZn1LwEjoOT2zmfeBV39zuinW/p1x9h++kBrs9pb/VmOeJeeg6pB5eXxOzXXnwPTL0XznjuCFi9irDvWwSVTNmyubpfvuG8LnxcFr55fuZyvXK9XHk+f/T4rMx6taDi6t5rrTwEWLyMcbQGVBGXONTilswhI/gQmN9axAiTBQ+zZ7jYkz9QKaHs6XxqVffaqs4Ft4exB7PS8XLLw7dLWDhoCTIFgoPV/C4xT4GUhBQDWTNlK+SaKZhENEcHUC+D8dUkzO5uLQDBVFNZ/fWKayOzpaiiKstqn7opcRM+rEItwSXWQBVzqkA2y0gfYU2WRFYjlKnujg4CfOPSqyBk8XS2/q5l82wURZBozh1pimy17mVjNCgaDbi+IfCUTAreRHg/ez2tDO8KzFWZK4QtU6vZJk/ARaGoxXrVEKgBNlWyKqEo102JPn4/f1LkyWBFVVhy4Hc1sYRITpAdKEotLJt5h7bEveKBzruHaieBKFAnl9Ar5jSxLzOzdllt0ECQikokhoA6aBuY2aIRhCDuLi9CKdVKmVCoTY2omb38DBbMbN1xOVwAl16LVmousCmZzKaWo3MrmeW02fXCxjtWaqw8Te8IYSKG+W304EgTM57XwGgsPtu39jhlOKcHs/Ha/x8EqaP2swlcL0lmenDMEYAdnfeSlPWa9NWrDo/u3f72wNWO7dQx5nBX2MrKmjcuy5Xny8JlvXK+XjmfL1yv5pCxXBfWnNmyq3dq2b0G27VN+xZ24IohEBHHR9nVhlG8QGFzcwf3BLSs3u1vaZKcG/kbcKk/m+5oZIMlYlLUXvgwQCucKAKSxBxBUiBNkcnBap6EecJKxWtprnJEtcSzkwgnYArC5n19X2QvP1XsH+uFq5BUMU+8zVRGZAy4FgviDe7GX4pSqqUu8hJUaKodHam7FFKbB+Se+Le57rOPi/q7vSWqVY9sUELmFiogukvxIgpFuarZIDVEJJmDzLIWLlmYKkxVkWthqoFZYQph99xs0nEMMMU27ubGbjes7jComI0qQKh8FZUJU2cuGshVKDWAGki0RMz70+1ZNLo14hUrW77BFutn0pjS8l3ZFWwOKrjtq3m0tryIFrTdAtL3OEKFYnmpPAjaPFnbeLdAeENLs4sRyq7NkFL2LC4xCKyBKpbeLHoar5AjoQSmACFaOQLZSwActJuC4/a9IfYIND3AHV2yZ3RHl/Qj9eN47Uefsa9H/X7p+j+B9tMHXK8N0hEoHB3zGsfz6JyjCXQklb3Ut1Gk1+G3h+pBQCpVzGZ1uS58vJ75cLlyuV54vjzz/PzMdVlY1pXr2eKzSqmUYuq5PfN3dbZXjWOPDlxTuqVGTWoSVvP0Ava6WrUYQa3qXlp4XE2rbiuV4l5pRgcdmHa5zQdOBHEisGdVdxpOEMIUSP45zYk5CVOEWZQYTXpbSqFuhYCSghIRThWexOxGi9F4TtmUUM1eY5mWjGCZe7SYmmhVc9vPynpVtua+nxVdXBUKBkSefV2EvRYYoexZ4jWqJfxNisygqYH27aWbrdLscxj9vzHMzcHAiTVObKXCpVSuvp2iMNeIVuXjUpAtEIpJUPVa+J7A90RIqbI1AagaCMcA72YhSWCTQEZ2FRqeOspcCCsJ+DqpOXGI8JFAroFShagTm9fbWutmkoujlWq9LQt3hDCmpd1IKE6IRUNTFhKoRP890EIlwi4hx6gevC0EsRIrNQQvhOk5FcWyiNQ2N+nqm6ngSRUpHq+mUlGiARfqJV2UGsWcQUJAJmNKJAgyhz3QvaWQ2p2MjojBkfQzgo90+/s20rc2Udp5vUrxNZB5BFov3f/oOcbrvSQ4vLF9x4HL30SnYrgb1F4i6T1umvis3Tnw4w/oS8B1BFiPVJb6wqcHq5U7NWElk+vG+fLMh8uZ8/nKh48f+eabZ5brwuVy4eP5zLJsbNvGet2opZg6xtMZoQ4+zX4ggdklrhjMrdqgypwOZM92K3tKoaKVUpv6z6SsEtwaIHX3FlTPIG739MFXv2bQvfQ7k9hrFjwNEMQYmKbEuznxNAmnSTilwrIVtlJ51sJXVZiAn5uEd152/iSRJ0/1UyucVoEsLEUp58paK1tVzrmSxYjVGrH+OwOeVyx7hwlx5jJfDdgsghkQQSffji1xrNxUwf7RgCf7tfyFX//8ey+3ofzowzOtSCUYI+DJ7n2XAzmt+i9m1+Emi5jUKqgWfvf8ESrUrVoWiwJsoEVZS+H3S+UfarNhCnNS5mvg3Snyx5j4uXeBhEkla47UFMxbcVkNIESYCaCVhJIIPMVqmauK8HshsoZADpF36cQWMlupbLqxebJmk8DaUtFu7XgohpjVDjV1a6iBTKCwmeoaqFIdpAIphD1XpqBIiFSthALhNFFqJWfzIrQKyJUi5VaxG7+3KJKgSrH5WYWsG7UIRQO6mTPMqgWdKnXNrHJii5XtrLzLmVwLXz99TQwJy/c1EIT+60gbmjPGCBRHNKQd9wgbZTh2bMMc3WnrEX0dJcG2v6fJfwDtpwC4Pt28ayMH0gZ1BIR+33jN1yStxg3193tt0owurWN/e6AagetuYjY1XGbNC0te+Hi58Hw5c75eeb5euFwuXK8ry3Vhuaxs60beMnV11eB+zZuaqsFT9E+QJnXFXT0YMNBqPmG1stfhanWOWgaGGtRrKrmU1R7IJSdcFbXnQwqmApSASSNux4opckqRKQVOc+RdUqaozKGSohn8giiTCu8QnkT4Xgps2WwlFDiJOYnkqqwZlk25ZiXXwlKUrSrXUskBK/s+WcCt0SsjoHsQtg+YBlexBpcXW4aJhi3CjRC2c93uRzXpRpt0qibB4cf0E2WPfwr49cVVdTZe3/v6xFYLq1q1X4m6Z0yv7T2bz4JtR9Bodryi5qjRJOq1QsyVa1DKEljc1VylUmuk1ZhEcFueOWfUrEhVYi1e9kxIBL6OJs3lKmw1sCJMRFaFqIFSKrlkC/zG8y228doXhY1DlYpUi020wbD4t1jNASMqVjxSLYB6937FcmQiYsnuq9tNm/v+jlWeskt1L6Oyh6yopfVqeTUVzHDoVaSXHAhbMGYlmaSnriWYQmRKMykpEqeblNw/3pGEM9Kml1o7rpfOHml6Xtvfg9YRcI1qTO3OGWnpT0DSau07Dlyf0Xri339vA/6Ic3kNtF7bPrrOo8lyBLIjcA3clO1Scl1Z1ovbtM5W/PFytc/1ynJdWa4r27KS1+ayXG6ZwNWlGRdyopj6L0kDL8+IcbMQ0MQlxdWCDbiqZZQo1QhwqVZDqQYPWg0mNgiw16mKN7uD7MDlfYp6c7qYI19NE6cUeJrhFApJKkEqMZg7+2xsN08I70T4QTL11laUtVSSGoHJG5wX5bJVrlm55sI1G3BtFYoXmtSq5jXWJKTm493eYcSlTX/RjaHgBhDBBZzdxdv3a8WyqHt827aaHkdz3aUto233bLI66EuEVm04psDXX82cy0bZlK0UJzi3CsG41Npfier5DrFnbc7bK1bgcymwrZnnAikqKVSCKcUA4ZTEAEwxBiGDVFNDzhVmEZ4CvAv2bkoQlmAS2YaQYiJqZPPsFeag06QvvfGVDchb5QBk31eqg4jgxS4hdudDcKmrhXKo1e8Mlgh5t+v6erCcjpbc2ScqreCoxS/fvBB1f9cCFULekNyk7EDQaO89wBx8W4Q0pYE0DIz4jwtcPc8zXu+lNoLdKHm1/rTrHNnQxuv11/0JANjPBnD1HEj73nviCTe975FnTjuuB47x5fWtl8Dad+duXwXCvq/tXr3Y35pzgLUUctn4+PHCx8uFy/XCjz584PnDM9fLwvnjlecPZ9Z1ZVs21qtnh8jFM4/fHiJ4efUYIWFu7UkiSaMXe7T8cRD27OCN6y4K2T0Cq1a24jkRi9kxLIN5N+QexLNLVS14GCf23DwW5znybrKg3q9OkXcJghREMu+E3U3/6zlyCkawtk2bPwbntVKuSs7KusJ5qSybfb7ZYC2VXEzqKrXehlvoGBs1X/Fmp2oAay6TdkIBViznX6XllyVEeBeERZTNgVqy04FoxE4KsCrr7y8+Rpa/sIpnvkgTYTab2FayBT8niLNwOs0+dSoXWSmpEpKQqlMTfz8oexC4qPWTbOAXivUhb7JLdaiBdw2FlcI3xUA3BEgxEN2T70kDUsxRIwLv5oQW4bplfrQqM8J7ga8FZoUnhPfB4tC2IJyrMIdAIVGYuUhmLZl1y5Sa3SNV2aOXd7tYe1GVyoYSqFbtkyLm6TpJ2mmqEomxEkWYJKAlOMNVCDp5mq/KWrPnqKyUyl5Ch9Be+i0+TcU8RwnCFrKFPGRLXLzVQi6gJ7FA9loJVcjFbL/v5kiUZJlV3KEJ4T4ZQU/sX2OkW+vpnHIv/RS/vs+DT1oPTiN4tb/tuP6cXl3Yey72n1Eae8uzPGg/ceD6z/6z/4xf//Vfv9v35/7cn+Pv/b2/B8D1euU/+o/+I/7m3/ybLMvCX/pLf4m/8Tf+Br/4i7/4k+7KfRs5ll7M7dsIaEfX6SfSOKH6CfJoErRjQ3d+D04jaI36ajFOueLqweXKx+szH5/PnC8XPn44c36+sFxWzucry2Vh27KpB3NBu/x6TToIEszFXSwTeZJIlGgSl5jEJdVzx7l6pAZ14FLPTFC9PlKlqNfqou7u8JSb9CBw8xR0dZs0c2UQUpiYYmAKgfdTsGDYALMUJlUiJmU9SdhraE2YkX1TuG4GUuumXK6KLqYGOy/K81LJWclFudTeJsddHsaOfts9zCnMBM32CsUkAKlQN2xbxIpOdu8vhwBRieL59oJ0wcleZDMqOdzUhTEEd3c2Fen0NKMRruWKJGU6Bd5/NRFOgbUWriVTQwHNpFoIcouFyxI4zTOqwrqpJQN2pLFkx/ZJVfbg35KrV0pu3qNWgywmqEkgCTrBNdwCxWcRpuBxUKESxZmHauN9qsKsBmRQmLDsIZOYxLVi8VdJJlKKbCUY0ad4vsDavRS5LTnB1LWhUoJ5BHqmQqfTzXvVMh7izI5lBzOHiX0MCogWzw0ZvBxLq/+mt7WLMWRWY0z24qZZs9kQVQkVFjG7XwDOfr0aFLkK83wipYkgk62NILe13q33V6Wufn8PDD1Q6PDbkZbpkZQ1AlffGh0dweql9pZjXmh/IBLXP/vP/rP8z//z/3y7Sbrd5q/9tb/G//g//o/8D//D/8APfvADfvVXf5V/59/5d/hf/pf/5dvf8CURuAcXur/9YPfXOZoYbx3g/h79tfrJc9TnEVBH0Krdj/u8VkpdWbNlv7CMGJebevC8sF7NAWNbLYap5HrLZlBwtYipiEIwNWB0YhrFYrGiqwdbtm4t7OqRGnQvH9FAq+yF/VqBycotsyld1mzZQQyMQATUa1sJp5R4CoFZhK+DcIqVKJYgNmEAEIBJbm4IxT0ZS1WWDJdVuS7Kx3NFF2XNyvOqnJfiQdDG9ZtnWEMp/ZQ5ATQYQKpLXW3hpSkawBUsUWv1ci5V0HwroaHV8+vFlgPEVK5WBDntlwzYmGZVUkPyCEECKUQkClUiMsM8B55OCX2yNEYhmwNCKBWRQnAv0arCFgLvnxJKQGJl0W13jEkSCTXc1GSYJF6WDZq7vvmVE7x0SjEjEhrcU9QBUkls1A4sTI1YslK2SinBciyKeXgG0b1OdHJbFEQ2MdtQCAaslqu2WUbblbnlsG1q3BZiIQFxsUJpakN73haYHAPmWdhyaMptfYkHYaOWwBipaLCc820tNhsmgm9XEM9A4gxAUFiCcTpRhEuKTRfPvCb3aoQQE1plf5adNvQE/hF9egRmR1LTwAC/6Zwj5ru/dy9NPbreT7j9gQBXSok/+Sf/5Cf7f/SjH/Ff/Vf/Ff/tf/vf8q//6/86AP/1f/1f88/8M/8Mf/tv/23+lX/lX/mWd5TjAerF1yPgGrmYnqPo97Xv7fhHktoRZ6TdsSN4je0IsMqn56gUChvP12fOVytB8s3zR54/Xrg8X7l8OHP+eGVdNtbnlbxte2b36sl4xYsFBm01kQIz0aQrMbcMK7fh7u9ZzA6TPfsFVkrdvO2UzT2xai039U4DATrnzSq7ShDE1GYeNBrnyJQS8zTxgxB5h3LSypQLsRSiWDzRV5NJNcVq3ZMV1qz8bi434Mnw8QKXq/LhY2G5VLasrLXuWd+1vZtmP1L2FECCmJZtnwcmYcjJij4SlBgD3//Be3KBvBb0RwtJEhKt6jFr9jRRRowbkdo9Jg3z2FYhV1PXtQwgKQghu6SnUHNlu1yRBOkUTE0LfNw21+8qT3PgHTeNVvB4rEpgJXB6SiCR96nwMVbPpB74+a+/MnCocNkKKZijxPX3vgE8+DbYApAoxCkwCZSyUMqK5EzEAPWK8KNifVev7xWzMJfAKUPZqknDRZlDZAqBJ4F3s3IKla9C5FkKi8AFmELiNEVynLmGjbWsHl/mDhyohxjIHgtnaj3TaVpZHCVrMIkcT/WEUjunI8EC6qMEQqjkwp5tg1A8WbJSiFSqZ1WhA8ziIB1MA1eUqsUZO9iqqT2rCJtWMsU8IjM8Zfj6KRHjzI6cPf1pEv6RDemITo2S1Sgple738fwRKMOwHbi/V08vx/scSXc9Tf7/msT1f/wf/wd/6k/9KZ6enviVX/kVfuM3foNf+qVf4u/8nb/Dtm38xb/4F/dj//yf//P80i/9En/rb/2tbwFcb4Dz/uWMtqJRF9v2HV32aML00tEjUOpf+Et960GrDL/1h9TMVjau25UPz888ny88ny+mJny+cD17xeJlJa+ZXIrV0GrGqJaAV82Ty6SqQCQ5aAkzlqki4vFZpVWNVUou5Oou7phkVYNSpHjqpHrLGQggagl2nQiEzjEAAUlWC2s6Rb5+N/GUAqcYeM9GykoqlUnVmVTh5HkCN1XOWfnmmi0RsEJ0aatU2ErieSlcr8qHcyFvesu/6HYfBahp5+DR6lx6M7YnpATYAmEDEnu2h+ZxWddqRQ4R5jkhWXbnBwnNmGBIX5tqVgGtt6KZyaQa9STAGkGDWp7FTcwxROx4i+y1fsiMVSsuAUkgkzJPQpwiKQh6LQagEkmSKLl4bS3lKQWTvkJkkkIJ5toeQmCeJlSVd/qesl4t2XJRUwZrZduEmYx4RFf0spAmrW1cFczbVEEsFVhVZdVKqkJSS+y7EtlUOOfKU1HmJLyfI0+TFdV8iso5b2wqbBKIYeJUA5sWlmxzW6nu8MNeBLRGIKildxJzkghS2YJQg+V1qS7tGuCaE1ILE4wlWgyYz3/B4rMkuqci4kWi/b15xWlVK7VSq5iEBlQthJrt3YkQ0sXCQKqS6uSqgsqkkdN7IcaENI6m/zDQkB48WuvpWQ9evc2sl4xGOteDlKvFd2/K2O0/unfrZ6N3PUCNTYa/36L9xIHrl3/5l/lv/pv/hj/35/4c//Af/kN+/dd/nX/tX/vX+Lt/9+/y27/928zzzM/93M/dnfOLv/iL/PZv//bDay7LwrIs+/dvvvnm23dwjxeCw5E7AqzxRY+icgMdGc6DYzF7BKxHn/06TbNe2fJmNbOuV84X+1yuC9eLZ8JYVlZ3d8+5UIvbBpqKsLpGpElazYblQJVUnFn1JVu9JHzVXQ1XaiXTCp3XBlc3N/dGuAVzsVfZgavZswgg0VIWTXPk9JT4+hQ4ReEUKietRKkGWGoJaAOmGloqrBXORXnerCR9kzC2rGwFllK5XpV1VbPpuKea7npSHLz6F2LufQ28LENFghxM+tlc6grsqtNydeJV3Z264kwCHmbg1y7VpTyB5mwQ/ed6Ay6p9reNDwUrLxJNpdWqEwv+WxGoFZkthmlx6UMxVVv1DBiWHaSyJ511T0QRPNja7JXiIl4IwtPTTJZCKYHcvBRp/E/d6druEi5NArI5U4IamDiXoMECuou4V52oJ2IWLmpSDqXwPpiKMKE8JTUGSxWtnsBZAQmIbBT3+mtps3RPsqy+9mxeVgkm0oZmSBV/8546yu2tQWxsgqcYMzWyUX6VaEyPZ76wTPmYypQGXnbVCnihOYrbQKUIS3b1oApzWPbQkjnNhBIhNpxpmT7kXsMz0p82fRutGRnpBiKj+u9IehuPGbf7fUfn9PTtiFb+BNtPHLj+zX/z39y3/7l/7p/jl3/5l/mzf/bP8t//9/897969+1bX/I3f+I1PHD5ebSMw1G4bbt417ZhRInr08o5eSH3hnMaxjFJX79HTaGbviNHdQwG0UnXjsj5zuVw4ny98+NBKlFw4f7xwOV9YryvLulK2Qt0qpZSd2FFM936Xc9CzYsxiZSNCddVJbVksgtmuPBHuplgQsZi6o5VGL1F3wiieI0mq7MRcqoctD6D1/mni3VPkq3eR9ykzSSZJJmE0Jni5EPFURBcq5xJYinLZCmu2eB6pcNmUy6Ism7CuG3Wr5pafG4q4tOVFHnsuIohiyZ/MqyLFBnAnQk5wjTvYS2mekJYoV72Puikslj2D1SQstUR7du9GXDMmRRXcU9HVXU1AC9yCrwOIF2KUKZpDxFYhK0yKzAILxHem5v1RhXmDOQlfn05cr5vFqtVqHpwuVaWABZkrLLUVaQQR934LwtdzoqT35FpZN7ieLx7ugKdsKoRukqqaKvE0T5QqXOqKopRsjjyardsCbKG4DROeYmJZKtdaOa+VP5Eik5h36/uTx5dVk5pDtQKg82nisgXWklnKhkqxMUwGutpJC+run2aXi2gwVZ8UsymqmMuGBntBMSXXElhuDnU7sKXyyL501W1pN6JSBU81pQSq5xCueH4NtChhDWi19STEPRVaSNHmTDjxbj4hTCYRN9rFAW3ZiUNHh2r3+ygF9e0IUMZr99uBT2lYf874GenlT7j9gbvD/9zP/Rz/9D/9T/N//p//J//Gv/FvsK4rv//7v38ndf3O7/zOoU2stV/7tV/jhz/84f79m2++4c/8mT/z+s170Lpzcuj2P3qp7RMPtl+6X8ULNvln6s57ScraHSb8mI7LUcnkvHFdLny8PHM+X/n4fOGbDx6rdb7yfL6wXBbymtm24m7odef6G4AEbRJWZJLgbs2BSaJlwvDZKdlVZtqSpFaXtLIBV3BVIeoxw+p59vwDOzhIFSSHnctPp8Rpjnz9LvHVBKdYeWIhko2A7pNd9oV31cpWYPXUPFuGbYWPq7BtypYrqye7bVWUDauc20dv0s/+Di3NUAxY1vhocTtCIYamZgMVCwXQJcEW0dmyQairidQ5bq0VXYMX9bSsIVSXllMbD3+n4zzrGZ1OCGxBsSJAttLxNk8UNgfLSfbsHSVVlknYJuGyKLlEi6XbqgkbIVhKougunsES0O4laWKysRAlrJvZ6xBOIZDevcd1xqw10fz0dL0YQLuTRikbIQTevxeuEUuTtakl/82YvXQLrFoparF1crLUTDEI/4Srud2r8lWIlhklBf5YgbVW1qJ8XJTTbAVBn5h41oUshRzyrjZUZwja+5EARZrN0Z2SNJqKj0hQByNaoUolNWcbsczzlEiLA9PmSYupGw1lCkjwKswmXedacD8YZDN1f8mZqMElsmLZ/oOS64aGwjt5R4gJdGI/mWGOjHaqfk71zHhP93pJq7+udH/7uTgy3qONqwfHI4nuuyJxje3jx4/8X//X/8W/9+/9e/yFv/AXmKaJ3/qt3+Iv/+W/DMD//r//7/zf//f/za/8yq88vMbpdOJ0Or1+M33w9/BAuf/at0ccRM+J9H+PJk574VO3r5f66vC93wdO3BREyZpZy8plXTgvC5dl4bp4JWNXD26LZXcvxTK8172Wld6pBy2Y2LjzFCIpWCxOIhLdRctDiq3gXrV8dVndxV0so3vFY7MCu/FeUgOuxnnK/twyWcaCKUXezYnTFPj6JLwPVjE4haaiA/TmidakxK0YcG3FVYGbeQheFlMPlmyOALphtqOmGu1T99CpK9vrEyEEdULFTpAMMbK9Gg3UGu2aYpJSs0Phf5vdQr3PqN6kS4DUJCj1Ypc+RxK3VFCN4Wl9jQKie393tRGgWXbC2Lw2S1V0xrKqJ8jJcVuxop0uvWkoyKQ3p4tQjYGJ7h5O9QDdQCjBq0ubLrOpr+Y4gaffKu7zrrVwWRaiFKJYvFSWbO7pyUQoce/F4vFuWg1UpUJU8ZAIc/kUtdI0IQXiJIRoGVFChUJhrULx93mSZGq3IGQpqFc01p3x1P2vaWfVYq5MnWEMjDv2iLRYFnPYMMeNANXST7ZCYkZFzOaljRDI7RfEHJTq/u6EbHmrPJP+aoxBEOYtEVOCAGGz8jqJYN6QbS31INPo0Qhco9pwZMyPwGxfDMNfGX4/kqCOaOUR3f0JS18/ceD6j//j/5h/69/6t/izf/bP8v/8P/8Pf/2v/3VijPyVv/JX+MEPfsB/+B/+h/zwhz/kj/2xP8b3v/99/upf/av8yq/8yrf0KOzemnYv9uhFfiLuvDCC4yD3nMY4+O1S9eD4iI1wmyx97FQPXHXYBzRbXKWwZEuae14uPC8XLtdlt28tl6vZttbV4rRKK8Kofk25gZZ2oCWBKSZSvAGX+CKuZKpm556VXIIBl7htS93l2JOOSsBSr02+7QRtl5xaBdsQeT+d+N4kvAvwVarMapnmRG5ZCVQteHjNpm5LGdbNSs1vG3zcKuet8nEtbIsXpKzc6mJloHaJUn1QW40waXWaMNuGiHpAc7N42Ri0LA4VByV1539Ne6okcbDR/R0rLSV8PwYyx11V2EBKoprKMIZ9vkjo2NemJhXAE8uKzzltXqENnLNSrwrvjFhLy/rRpLtioGl2pkKsFndUfZ9O5jYvFAcuyAEC0WpnxUiqlZbqa54tziqkQDklAkrNlnMwBWWSyhRgYTFP+hSQGCy7PIGyWIaNUMD1z267Uk6ePqsWuE5KcNCbKJxEmBRCKHxYYXWvyac5GRMmlYuuzmBVQjIpak/N5ctfa/Wijy1tlKLqqZnapObmVGReprsOwelEVwBTKlVa7Bi0Ct2Wq7rueTybp2pVCNvi/VKmNRJjNGZijUzTCTyJcJuvN4enbh41GtTToUaD2v7eJNI7ajxyoHjJLNJ/P5K0erAcwbBtPxQo3t5+4sD1D/7BP+Cv/JW/wj/5J/+EX/iFX+Bf/Vf/Vf723/7b/MIv/AIA//l//p8TQuAv/+W/fBeA/BNrR6Cljw54Qxtf4pGBEu7VjhM2sj0H3felAVTu9vdAFrCFVArX5cyH60fOy4WPzx/55sMHLs9Xzh+vnJ+fLffgcp8wl2r6e4vGF7NdYSVJZnyBx8Dk0lZ0g7dK2LMFlFzIxQzmaykUqRRRcqzGzTbjt+cLlclSDhHdqyuaxBBCYEoT71LiKUa+Pwnv2Ji0MtdKdK63Kua9WD2ouUBwe8plUX50rVw25Xk1lWApBm7qsWl45gm1tPTQalkJVstLGogEIrmTCm+Db16S2aQHrahu/ldQErA5bVBTGWm8ZftoACUOWtUy17c5Ed7FXeWiYvamxti0IF8LpJa9383m1QjeJ5NbsWDhNRooRWdWfP5pURAPeG0q0qCQXDKMu/BgCYM9hEH92BjsR3GRPeayT/11WYhTJEyB+TQTkxBC4ue+9z3ezQlqZrl+YIoODlqoerV0TBLMVpcSlYhuhigZZa3KNVjWkEkEogHRta5Iga9i5EmEpznw89Uk8A/bxjdaIQXenRJzDCx1Y6mZTc2VXT2XWGOOxOPualHPPQm13uIRJ7W+mfehOyqJWsybB+RbfuZICBY3Vyi77ReaHOfLW5skb4yRquVtFC9MGdZoNlM2NFYiSjm9Q94p8/TkBt8DutPakdTT6NHWHZO77ZE+jiaT/tqjinJ/sIN7j+e9Jo19i/YTB66/+Tf/5ou/Pz098Zu/+Zv85m/+5k/gbk7pu3x7LwtUw5tqmS+PDjv6wLFoPHIaDbBkuF4dPuO1u4NLyWTduC6L2bEWq6d1uSyWMHdZdu9ByztoqWa02kKUlnZITcIIzWtQLGN2DB6v5ao9Bc94YemPSg7kisWceGZ3qx2le4omSWpedkmQSXaPuxgFktnPUgq8PyXeT4GnCO/ixuwVgqVYNouWZT3QCIupBtfNMl88L4XnVVmysmzVAo0d4FrOKfXYLKO5LqWg3p/qXLTNGdklvBZrVoywsnXSqq1U1WgpeboVGDAJRGIgJHNLt0PCTS1bMXbb54Q4mBNAktwcB/ZL6z6f9spdO0ds3m17zlm6aeuUWP046QiEh4+hbX+AFjTc7qV+v92JBsVc2W1ZBfdQtMwnuossNQshF8IaqcVUejFa1v5S/fIhMZ+eXHWtrOvmIFyJmJJNMSZI/CkFyyzfwh+I0RgPIoSTxUERKGvlyR6Hd7MVh9wEsmRCtHhACGg1z8PqBmTZ1YFQJZrKt4jZdIU9d6TsslRXydsZoCDmQZgc+WWXtOzawV3hVXQnMa08i6pJZlAtCbIU0I1rWUiepDeWyFQsFGOqiSiREJIVx2xEqJeWjoChl6wSt0w+Pa1pzkAjmHxCk7r7jJLUS5/x3CNg+5btpyBXoSPGCAKHf8cD5Bjkjq7Ttx6wmkqw39fUg22i9KB1BFY6bio5byzFQOt6vbr7+3LL8r6slsYpW5xWdWcAyz8nzo1jbtvSxWuF7qNxJ/CVm6t7KUquQlYhw16SRPcsCkaIxaUqA65gzy1egTZZUcd5MieM90k5pcocNiNMChTYFn/myp5goyosWTmvJm19s9RdVVjdLrLHNvu4aj+mRmOQRgBD07JYUChe0N5UOE26qi4VWBCd3PR5iCSEhDqACQlJEVIgziAncWAyxwzZ1XcOXB0o4WrV3fbSMlC0999y4bU6V42kq7vAt5nrY3XLl4hJej6npfq1fSyqNI9Oc1ff+2Qj3pI+2JJocdxSIXpmEi9PQ0sHhRK2QIg2X9JkSZCnp7SHMSCJeTavvFqVUopVDMBMfqoZVJFgGf0jyhQqYrmzQIQYJyREQpzgNKNYsPZaLdWSFQQVyMq1Fp5LoUggpoikSCmugajVQxbag+Ju+8GzSFnftA2Lmi9gIFKCe8tGS3llzEE09bQPYty5V6jmU7ivZRWQ4Ml41VZbFSGHCmJ21FiDAxfEGkllIlRhKpFZk79Hm0DS2TUfgkjPaNNtH9Gz0WntLcy6cqxSfARaR99/toHrhXZkO/rcNoJMD1AzN+/BxPFLO5K0+n6NTSBvq5UmWS786PKBj5ePJnGdzzx/vLBeVpbLynpdzeW71M62I1A8Fsu5xSSRSSKzBOaQbupBIuYrb4BXiqkHN62swZwxCsX09IJx6jOEFByssCDYScy+NXli3BR593TiXRLeReHrqXKaMlMsBC8KWRXKZl6CokpSWBerdbVtyj95rnxcKtfVsrhrl0GkVlw9qHtAtbSSLMElzGjVjc3JpHitJ09OVVeqtrpO2y1DfmPFxV6oSDKiGSbEHhRIBHmC2Z6fd2oVKRMganW6cutXV01X6v3CdgZA3cZijxZ8ytgE2YUqR2Xp2F1tWV4r6Fp25JaW3zAJkpVwMqBkjmhsNptOYgO/rkkZc3hHyZmSLdlsDV12dJdIzF7TpLJK3ja2ZGCRq3CJhRjhlITTNHkdN7HqymIMQywbZVmoeSPUjTksPIXKD6Jy2a7UWmz8thMlBGpJBFmYTu8p04nfe4rkHJgJfBWEr+bISSunUvhH22JSmQbev5+oGiklcr1mYikGXlqpslk5lhDZmGEVRKtlvahKVfMu1Ao1VhKJ6F6WYKEklvTT3lp2Oc3wzCZmk8RUTDvRVIZNiFMv92MOieqMqCJFLBH2prDBu/jEU3oiyhN7Ql7lXrMzqhIbrfFl/olar1cbjgl3R5rXX7u3rbXfdPjePrW7xo8BVGP7jgNXhyqNC2mA0A/u0fFvuXR/HbjX8fY2rMk/YTj3yGvwiKNpnJoWSi08Xy48n8+33INX8yS8PF9ZL1fzIFw3NzC3/INq1y9YrItCK0sy784YsVMRGuemngUj50LOlVyVrMWK6YXqH/XyD9Jouql3YnBbjRHxdIqkKTJPie9P0QKJJXMKlegVfpktALWqUgJMxRKc1qJ8yAZUy7XyzVL3DO/N7tJi0fYsIMVWYhAvWaF192QM0gh+RTWjtArPhaqbSVxaESyvkriOLQQHLEmITPtfwoRHvlk5C1fzSVQ01psazj0OqU6YaNKWu827hCXuxtgAbe93kyQVQgju2anmiq32vIpJu4Bz4hacSzWAN6FNCdNNsFI1OQCMsdlTFuGZPtxj0eL/jCkIBHPycNubirKLurURZLtXC71QUYhmw8uzFcRMAaYozEGYgpBcfZtrRlmZ6pmv0sbMypQvnMqZWwaTiawTW525Lplav6bGd7zXryjxHZsKz1rdlV45BeEHAS4UFrHEtjEEppBIOlHXDCVD2bxqTLAE0SGhSTyhSSD6/VcNTN4TQucaL+I1Q6VxdT6a1fIkhkhxHXytLvn6eKmYOrHi6CWFVTYjH1WJOXLJCaIQcmDapr0e3bvZ4muERovkRpt6O9RIh6SjP3THNPCCx9niB2brjs71NvzeQY3hvN4H4Ega/Mz2UwBc7a/cg8GhKu6NwNU4h7EdvcQ+Xqv3HmzXGT0Hx/41QkWl1MK2rXsmjOti2TBu214EcvUs767+0JbIVrmVHyF4rsG427WSmMtz4xlxolhr9bILri70AOMGXM2pQEJTieEecHKnLkyzqQbfz5H3CWaUmUoKhTAZuOnUgAsQUzeVzbzDnrNyWSvXtXDd8ABedxjY/7LbY3AbXsBsMW1MDQNu6j/VQtGM1XBqIGYXECcouLehhGSZuqVJWe6i5xV1jeqwA1GTpna7UVuYd7aAFk9Ud9f5lrfBPAVtUt1pUBpN05t0JP0E8iz9VjHa3qV68UkVkKqQg9lrIrstcF8nd9x5ALVj65Z3p6EAJsHtPKGBlxHfG/floV0ma2x1fzcVy3hRo/2eJrMPzVhNrylm0I13uvH9tJLqlbp9Q9SPBEx9WDWxcWLlRM2VRSuEzNMUuYTJKjAX4YoVCJ2D8D64xygVlWwipwhxSpRqodaqxvAZfJi6Uj3foQbzVBWF4k4+bY0KBhuCMztiHrNNxyhgpWg8Q4fi0ra2eeCSq7S6CeK8hLB5arS1bixlJRQhlchTXglZiDEwx2x1xGQIKpXh0+xXvaQzgtdIDo+Abbz2CFzjfR99+mu9UXZ4qf0UAJfLoho/wbFPwWt8S70F84U2vrgxh9cjZwzl3nOw73KvJqxQdGO5LlyuCx+fzzx/PHO5XjhfLInudTV713bZLNP76h5R1QlFEUIx0EpqlWWjRGYic0wGXDHuwcFg4LHVwpaLBfSqBVRuslFciujLeeB2rT4OydRykXSKfPWUeD8LX8/wThYilSRqoP6k6KwsQTFXCWESWIPyXJXfWyq/dy3kphrs1apZzfmk2HNS8dpgsXstRmnUdVmqmyf7tYvU3XPDlXIiSIik6C9VIsKEhAnTAZ7Yg/Bc0KjaJkD2QNUGItUBxj2/tJpbu8e1WYFepbpHZkE9o4m509/qUrr3p1gtNA3F02WZRCxtqgPFU0hRIG6gGZppyEUBUk2kavNCNLBVhWju5cHtfiJKLV69d8/iHxANJMEmQPMUlWDT1214u6NG85ij7s+CE/01WijFRkG3QkmWZeX7U+Z9yDzNhZ9L8P1YkG3hunxDkm+ImolUlMjGiYUnlI1LySx1ZZFATiByoqQTH8XKh8yifHUKfB2Fr/3Zvlkz1wIpBJ6eJrQo62WjspndrsJEZgtQklj8BYFagjE5MVBDM+5acl5M9t4D7lNIBDX5TaMxewEfp+BKw72ml41lq/ymPu5ZxeZEFiRDiVZ+aMqCbiZKzyEyT0+E2FTXL7SRbo0OHf125lMt1ehJ2NGBOwmrv8dIYkc7GN1xP7sSV8ciNFXhASh8qpZzllM7DrRXC74kWfWg1XOt/Us6smWNKZ38HFVT9y3Xjct54Xy58PzhI8/nZy5Xy4hxuV5Z1o3tWsirew8WpW7VE67ax2xaFquVQiAFsyskMVd4W2TRa2ZZGp2tVjZVNpQs1aUt9Yti6pHmiBHEM59b94MIU0xMKfF+SnxvMgeMp5hJyZKS1qDUWZBZ0QQEz0JR4LrBPz4Xni/K81VZys07sBY6T0mzO7R8b7F2kogaZ6Bad/Vf3SUtH+xdhegeajLtMVYhBpOkJKCu/1USWicsdkr22DIJiqRq9jxP1STiRMklFIsztaTDkmygrPpzdmkLNDZu2+aMYCeqhyJkKkHLXlEXxUC7mtQlYE4OLmXlTT35r0tgPo+380apQlgFXYJVcUwQJmEioBMWiLyrHf0hQhNrXT0WBJkFiXXPO2klOGztSDU3BqsIfJNE0cparM8RMZWmZjRnUllIYWOOGZUVzc+c6pnvPxUKCTZBNiXNkS1UVrlQvNhjUgg1IQVWeeJSNqbTe4KjcSVYBWYKX0clTsJS4MNawFOcvX96x2UNVjVhw71vjclgsncmQQlafD2A+ZV7xhBVYw49PrJJXyqWgxEE2WO7CohQfKGahG8ZNtQ8N6yqwh5Qzl4TjSpMJVGLUAskDbx31fk0WXC4u0h+Kk0dAUXhZo9vrd/uVYsjzRsd0doxjaSWbj/cA9+R5NWbYT6zfceBC/ZR66WcUSWnen/svs0N8LjfDdwGdxR7e3G5v2wDzNER48je5RNUa6XkzNK8BS+uGrysLMtq6sFlo2wb1fMPalVqi12qgBOR4J/eczBI+3vLGGGezUqmekYMi9EqVM+G0dRecgsmDmIZFPZ9QozCnCKnFHgfhHctC4ZUJJqKqCTQSYizmMammjt7zvC8VD4slcsCS2aPI8KdL7S4erAxqmpBqlZuopUK9GKVXs639sl0dxWJ971l9QjtL3R+4kBANXmmDFMLKo4Hai7QwcMBNPRqMhuv4iqhihcKDK4qQvcM5hox1aKr3My05uqBRreqWobx7G7qKlDNo0U8I4cJljYPdLP9FmsUbqq7zWxjlmGjmgPLBKqy27+0mjQoJn65JOrP5dmLJXhy2+ihuNWDuH1BhBp2pWdtC6Hxg7UFTQtZLBemoCxaWGNhroVNNworwsZTqNQQUS898j7NXHVF68aTrOSwAStZr2xl8hyTihSzPwpiIQzV5kWI8BSsmOQm1RMJi1X3niZzjKjVXeAt1VVN7iQTTDVtqaMty3NLF4WaJ6Etk5YxxgtthrgzKRFzYGmgZq+5VbTDGSaTWHdmBshVrLZbTVzrumtTriURYyLUQJIZxCX9LqvKTrva3/ZpzPUjctir/uAeeF4CoJ4uPtrfS3O9RPct23ccuPTTr72UQ/f9E0TrRKRmcO4BbBz4e/r26T1H0CrDp+1rOOv9KjmzrBfOXk/rfL7y8cNiru/LyuWysG2WzqkBV/VYLRoR12bTCu5BmJjEa2vFaZe2wAHL6wFtVLJUcrAA41qzLeQIMlnhxLBLmy2DglpNpmjZE76eJ94l+EoyMxuRSnTnlS3AVexa70+RlKBeN4vNulT+0TeF83OhLFZoUdUlyVw9A0UnSdKBc8u7hKVeUK8BBtkCkNs7lggSiCEZ4XWnFNeRwe567lOgmDrQgEu4+YhjUkl05wph57rrZqiqouR6s5lJtBIa6kRPE9QolsVcoLnAq6v2xEFHwNMgFVjYbXrSbFTq9pvoAOUqQsHm5TS5s7+PZV6duVfj1lu2/hoVNlMB1lD38jKnp+Ru12bvJNRbHJODZohm6wqSaB6JLVYrmDHPSLFWQi6+RIQlze4QUYkbpFwRycxx4/1UyNHUvE9YOqk6CX/s3Vf83uUD53XjNC9oeiLKzDkvUKwkjUglqxJjJKVEkEiLbVtFeJoiT9HKmHyzZrYKhIl3cyJES+wVF0+RFpQ8Y+PTGEQaU9DM1/bM2Stx7jQ9GdMYou1vUthuS5WmSqiNQ6GGdAN8jyFUlLUImgVK4JyDcW4B5ngb83lKxPAEeNRZdsLV06qR6RZbNrt0RPeXYX984TqN9rV79Rqrdm6zxqSOTva0+Y2WmqP2HQcuuAejblf/MvbUA2U4tpW3CDeHip4raYc+Emt7DqfHwzYxjoCrk7y2bBkvzh9XPn5z4fn5zPl84fJ8tppa68pytTQ6pRSr5+SqQVX1arvB3I1JJK+vNQXPQyimMpQQPTNAZdVKroVNCxubgVaoVAo1OoWL4CkPLGg2GYhJrIRJSFNiTokfnBJfp8IpVqaSibnuXPlaFZIwzRBjgawsK/zuh8KPvlEuz5XzN5V6Bl0qdSmU1R0MUBDPUu8crPgYK4Yw5h1Yqaxu1yqors6BWsJYk7KiewrOnQu4eY9VrQZUrcim29DNiH57uYISJnEHEwOw6oS5tMDVbE4n6mBn3obB8xm2nI5iqtLY4nluwElxCSsLbOw5FymO0Zt7j6oBeQ31xmdV47mKOkiK82C+DhQDr5JbiiLz9iMJTILM/gwBtmUjTVZpmSS71ygY4d0D1hVPSFxvAmO7qSemFcQYgKbxUNjiRIkRwfJSqFZOdeLjFpAipBj4SguTx2g9LxdKrUwxslCYY4WofE+EdcnUKlSEoorUSKkRDTNTNFW5bkomIjHyx07C95Nl5/iYN851Zg6RH7wLBNlYc2XLVgaopkDVQE7i3udGnXNoTE5GNOyq6VOIllcxgMRIChDEFr0Gi1usWixUolaPhQsWRwgQgteKs/EqBMvJmCtrCUg2JiLlaBEvKCFNvA+BFCEx32jYKDH1qsEGTM1FPvApiLWp3ycL78FrtGW180Y1YgPJRo9HJj/zrdtPAXDBvTQln4rAnxzbn9NZGA8w8PAF9b91xuj9eyvWOAKXf0wdVsnrxuqeg8tiqsHrslrS3HVjWzdKLqb+cu9BdfGgiwW2Kq6hy0XYqQlD82LSVk/L1IMmddW74OLmkr2rBpure9sXrUjh0xx5SsL7pMxSiRQzTPvzV2coLUWOQFEua2HJ8M3HyvlZWc5KWRRdjUg3F+wmVUTiXhtJPEFpc4evanav2nIHYklhpVPZxGgegubObiuvucdbEl9PINzG1j3uTApSVM0estvkG+qpOUbkWixJa/Ouc/VhbQb4AK12Uwvc7tM8tXmj1QADr7HVcky2roo7pGjRZs4zwHPt0E4QnLEqvYZAcbd7fx8uVZo01Ep1YIHKmzmN4LaeiDllNCm4jYtNEeuPW7lcVeXj596tZjPC1IjtmZwrrAhbnFk4kSissrAwk2pmqgtRtj0tlohQk0lTMcxsYaJ6AkbxDBYGgNnCIaqDQ5PTFauFJpWggadYmVwq1pzZ1JfnZBLZKtW0GzVQxZLsFnOhted2D1OVyWqB+Xsq3XoJCbO3Ic77qRWYLLLnjmzrsakNa0fdG5NZK9SsbHkzZkwCS1iJ7sRz2hZSMvVojBaf0ZOnvfW2+J4Z7783qagHriPQGm9wJIm1/T0z3+7V08wfA31+SoCra72TBrygKtxP4E5Ee/Rza+NL6jmInqNon67icA9atWbW65Xr5crlcuZy9YKQV8uOsS4reVvJmxcPcc6uca+7rdQlkz6lUwzRJncIlvmg9pkxLKi4iOcfdLuWZa9xdZXIfgOJTpyCqafmedrd3d+zEaWBlgU912oZLjw7FEJl3ZQPl8o318qPvoH8UamLUq/AqtTViXJx7zzF0tw4kOJpobSIOWtoA3ELIrYUVKYSbP1PKe7u7BYnZphYHRjVwwCqc7+qRmxaNu+aMyGZrSW4t4NpdypryeRiSYiNc/VOJ6g9d9uBlqXIgpBAUvCcityS4GIgtbNVzpxQgzleFDVUatJL0wy0pLwN0HxuSgPboHgai1093eKKCGpJeotLAwV0au71kXAKlM3riOVKbtRCIVbZiyASAoEGTkJohF5v4KFaLT29E+YtPrFoIQoskrmwgla0XIlpNfVlhOpSfwgTUb6i5hNrTWy+zCVYLa1kqeYtDi5nLGotMDeXyBLQHEgTzFGY3BZ4rZVVk2kRBNasXDVbXpVqSWiqixKitp3DTI7iEpMxHzFUc8ZJ0b3vLXg5ubq41mrOK9Ui1IqDVnBG1HJJml2selxc8bWkqwXJaxUmVjcPwJxOTNEsbUkso6LSJN+OXjWCMQLLkaqwSWL9OaMjWt96KWy8Zy+dNXViD1yvOEW+1H5KgMvRZRC8boDTj1bf2siGe11uf0rvqdPbuEaOogzn9C+ps22hlZI3rpcLH7858/z8zIfnj5w/nDmfr57i6cKyraYiVKv4s1dedWO7qOw1tSYJzEwGWgRmSZ7twTqXxTwGt1BYsRyI2cGrxroPw82BwT3I9u3ANCXmOfHHp4l3sjFrJrKR5Oa8sWDgUAqcipAvynJV/tFV+bAq1xXyM9RzpS4VLtVcuLPCBpIDUa1ceshhV49RxFNaVUuC6ytLJBLDyZwHRAgRj8UKhGgvqlbYNsue0d55LdnshOopoZyzL1Up67Y7FEgxSaJkT1ckdU+kqh0XqlVvxQliV3Qwiq2wSeGEZRqZsIwrLkFKwaoYb+zcrt6pq6sB1qbcXNZ9HoDFBeG7A3vCY0mea8/zC+4Jo4Sbw03TMnhZec1K2ZSyZCQWwsmzg3gQcnNuCSJsHjMmKoQQmSY8o0qkloq4JkPECGuQgDbq5lJcie+4ivD7NVNq4YnEewJrPnGSjScpnCYhykwIMzl+zVlmLiXxMcMWJkJIfJUmzqsFmAfNxKrMJE4kEuuuQg8k8uqxWBL4hWlCJVBIfMiJNVnS3o+SWddM9uKp5gdolqiqiVwnNr2whK8o6Ykcngga0AQpKWFKHrDvWtYqLsFNps7NGdFM0IK6o1Ege00ve5G1VLJC0cCkmzv2KM/FVNulKilY6ROq7gkGQsucPHoDHoEJ3Gf86U0ko2TWbx8x862F7m8DQeHeTPJFVdijCrbduI1eLNXxbfTNufrG3R95v3SH3v1tx/X2q/7lKB1oKVRLnrutG9fryvVy2SUsS5y7eg7CjVKKq6/8Qvu9HUxaQcjQCkN2+QiJnrWhOWNk8yCUavWRxNWDXZZ3cxKz+1hKNL9PCEwp8BQD70LgSc0TLGnxvG0KIl4ewzoZELYMl6p8rMrHi7JuRhTrpVCvFV3VglU3i1kJxR0wPLO6FnPQ0Ky3PIzaBhr3dLNYtWbTohFjhOLj3jwVWz2jXZXlHO5uP6dSSjYCJU3Vk41DVgPAPfNFxymaGs0DjIsLQD6der6IpOaOPoHMYZcsDZTchV2xlFHNU9AxqmVFaQ450iZeA7oOROUWL33riPMme5ZeJ6YtDk2183CMfm1Vqqtqm3qzudlXdK/LhUu/LXFs6qRTUE/s0NSFDemdUQgRmLnwjkjB4M7Y81kzZ81MGSKJyIzKe1aZWUIip2D2SQKqgSkpk8BTFKgrquaJawMUfb1s+zMXAilUUojMoSBxZZXAitkyr6psYh6PzZlCKBQimYlVMyiWaUbAvIgSKomKWrFO99K0ITdvR9MjYir4ausnYKppe91Ner4FQVcqJWSkwhYTq2SibCzTlWuYCAhzjIR5vknaPU3r6VdP38b9vWt7T/8ekc6+teuOEl5j8NvfHrh+tlWF46h0b6p5C+7HjcfI7U//6U/h/tC7vz1INZVg53yxA1e7lCpl29jW1Vzer5ZAd7mulhljWVm3zSoYNw+jpmpq9if/L6h4McjgdYhu4BXcqNH06FkLmeJxWk1VWI0IN0IXrJcCbhcTcBvZlCLvUuCrAE81m3pQ6g6OiFJCt1hUWDfl46b8aK1cFjXHi6wGWte652CTDUIVYrFCk0agTXVoOf+8em4bXLHS7CZhmT1PduaDRnMp7uShLhU0zwxTwd1YRxHZHT1y3szWFwQJCepqxv8a2VaTnmSGMLn33938Yl+85iHIriLUCDIpMimchHCSTjp3TiEY7dPV7X3OfGubPAWXnuxBpXOn/xS4/JpNCnPPxAYmu72rOigqTa/LDS27RdC2442w7stAXRWWvW9e38vGuhKVXRVr7t3OJYlQS0JFWGIlSqVocOkmEnUjUoi5EjUSNSHyDo0zVRI5JHeQsYKQ71PgqyR8f7Lcidd1Y8mZrAoazQ2/SakEqkRLayWRRCJJZQuBlUScJiatLGSueUM0YyUrM4XAphORDDWw+pDVVHBRGt2TM3s+UGcEA8neYcTAO3jCqVoJ2lx13FtUA+qjUTV4EVDYQiHJRhThOkdmMeA6pcgcVqtWEKMzuAM9a3RrBBflU4eLfX4e0LWx9ddr3xvD1s5r1+9NKz/bwHXQmr/Frh0c30j3vR/k8SWPp/bHt9/aixgdMcbzVa2+1mXh+Xzhw/OZj9ezFYT8eObi0teybJTsykHRW4ZvJ2Ixuecg0fKvhUSSxIS5wgcCZNO+ZVUsP4BlLlgls8Vinm9BrVz41KQtPBOFz+RgHl5zSvzc6cRXofKOwrxlHwMz3q9tuAXmYKVQLlvlH6+F81a5ZqVsUFcLmNYLsKpLWbiqw436Ky5lQV2gbB58zLoDZXM3DtHKpmhM5plVCtk9jXcpukm6FFBxp5FqYKLmWVfyYkl4a2EtG+JglonOaDsrqu8hBLQKpQHLDhiW3QLYOVdJwfNZqgX9noT4PjC9C3z/5584f/zItlY2jUhKmImnmht2DLcyKOju7dKcVExADI1H2OUUEagBgqVWtHgiz2XJyu6JDW5j2RMZdvO6cFM7nlz6VjuX6bZAarUpgIBm2Fq5Gyph3hGCJWda5W3Zn0UINUEN6DRxPQVKTKTwnkt5z8SViBUY/f+z9/+gtnVLeh/8qxpjrrX3Oe997+37fVK3Gz6BAgWOnAiEQIGMGyQZhA1OBAocGCtSYBwIBLZAwmAwDoSMQaEQSLECBwJjB0pEIxmcGAUSKHDS3Zb6z73vOXutOcao+oKqMeZc6+z3qu/bku171fPe9e591p5rrvlnjFFVTz31VKGlYooi+4bWeJXyQlGnaMRAzmBYo/WdF2lcr2AX4dOnt8iNmvAZ46tS2HIMVTo+Cn1UrmK85Dz7cam8bsZdBvexM9odrFH8HoaLyo0Xikc+rFijjxfggrCBXmFsoBFhaRpqR6g1sFdPKEY6qDjdG5HpCujS8j6JC6NHDZkXQQjm7MAC4rbCMI85wRuvV+fDRcPDOkf957Xt2Uid17b5Oq9pk+E617r31kl9eh2+4WHADsAktsZ33n7GDdc7ce0zevhFzPu8yeMDfmbQvPeQzod+z2h94Z1E+4y23wMe/PzG7dON2+fG7a1xu7fA1HuI7BrjkCia+Q6JSKhINLarWbM1ae8lWU/iEKXEnvJNnU6nS5I8kvGGApse0ZaSyf+YvaUUrrXy4Xrhe9W5Ylw9iBARKGRNUua3EHhrzls3frzHq/Xs7dUCGrRmcHfoAQfqiIU4+b0RZQ1SGQRWR6SpsZjnpbWsNu1jHHVtkcZaXLeY/NOqCgHpLVLGSNX4MGZmgwkpexavRmLHM2+WyXWXWHwJ1QMthMpBqPquZ++5DC0IpiplU7ZL4XsfN7QrN3f83umqqZOXjsoDk+vQjg9Bk/DMZS4gIouvgQSBZgn4pkyT4KHybqd58IwszEDLfEGuoXDiC16zdqxaYdCinsvGVMuAJlCJujkp4W35gG7GpvW4P3sqm1gw7/xa6VoYWiOikY7SUctJ5WAWhA8d0fvr9apcSyjPVwpuzu1+o5bOx2vlZav4nirrnu1/XKEo11opZgxRmhVUB1uBi0SVwCfgjtG008sNpyF+o7uysxF6GFs4FObsAshAekfF4txLQJzoBSWei6mmOl2Us2hJLZQCw1I+awW5AR/YFFcW6KMjLaKpfa9U2RFXLvrGVa7Ri2w0amK7iw3LaT17B3R6MHBzn2lY3ltC/enz8Gi4zuK70xDOtWxuvx9xzc0ffhw4y/w5X+endUAqXxitnxSFLY+eR0P1YLhy+LljY7Df7tyzJcn9bWd/6+z3tuDBMbI2KelfU0UichSRb4o8VhQ6VlFKGi3VWbyamHjqDgZIOBtBhuE69AclDNe63sNwbaVwrYWPVXnRzsagWBA9pmTgJHMggYB8bsan5vz4btz2o0eYNcN3yzAQdARTTkawsjgZq1W3NNmTCiolemqpoCUXRTnuq2UNltlB6SeN1FS1EM17M/tCWZYZzK/yuMeshWN2+01dP40IeEwV/jl8JjzohFHjWOgDdmQJEWvNnlXqbCU0+wpOTxHeSaNfzycNkMwGlHIgee/5bAjp3ZP3wfOZMvtixsXm856L47m+bd6H5TDnGBQl4MD5ZUVTLV4OxRN1RifKD4qhyMrN+Qj1dsm8mFmSNzyOZaVkH7uCiaAMlNloMbDOkZCnmERqtsaYeEWjyaJJ9JNjpNaisKmDdNw7bQyEqGu8EA5H1GIpxY3NjSvGq4ai/U2cXQdN7pg2xG7cXdHI8tG4JaSnmFWSL4gOEAkYsAgEfR6iGH6KdkWNW+TpwiHKNHg80tkcLcd5OFcwxkC70FVovXPXhqDcS+W2Ncq2cR2h8wjy+GzndjYea73zY707Q3z5DH8icWP+fM9wzfdnrv/83b/PKnyKYf309hfW5LxDbmfDpU//nt4vp4++t2jwtM8Jy+29se93fvyjN775nVDF+PTpLYqN7zdu9zutB7NqNjKMiR0LhoyCukQuSzPSIjsMq2S0VZaC+hBnZ9Bt0GkHIUNtFRUulfdcEKclFhW2Wvn+9YWvCnyv9KDgEjVKv8MgcszKh0sY0GbON587/9ebcRse8k0tRICtG958wYNiWSNkEhT4dixsPjJCymIkTamqquFhB1wSif5ow9KZ7TVmZ1vHVnGsj3wYHiRtGxa1cSNdyaQsy1lbbnr4ORCCSRdST1FHlg88aebmTPFxSp0NBOOc9CKUi1JeFP1QqJsgGL/1G7+JjYaZUVUZQujUFQkx2wpyEXiFIhXZwKrjt7hftDA+ptB1pFpF8AbV9fDW53kKUbheCdWMcVoUZzR3zs8thyYt/lyYVoX2hBpjkjmesKbiHYa37J6c4TkRKd2tLwq9MSLisICcDUc2pVwqVl+jpowRLM1s9km1NDah/iL3iKK2F+PlKlxq5YUrjMaP3j7z408D9YaMwEmLG5dSeRF4Kcpba9QifNxqtF7xnc3u/LAO9hJK9L/ZnK4dY+B1cOsSNH6PiGvF9yY4FfcK0uO5saGhJYVptMihFCqhbDJqQNIjaxOxMfkuSMKGoEF8Sqr/6G0Zo88UfCjenc2VWj+BhjajfqhsdUOn8OLZCX8PVdJAOKKIIBypUcuSqYLT5+ERMvTjGIvN+Fz0PGsXz1Dhhe+8/YwbrvfiT3iMqt7bTk9MiUn3TB09G66z8bLTx7/lkGeP1kZnfwsyxts3b7wl5f2e7+37Tt8b3To2BT0TyomE9iF1VIawSc1kcqVIXb2oohI/RHJbKmN0RhYZe4iGJj17KrtrCY81CGGK1qDUfn3Z+EGJ4mL1jmp0vN2B+6a8bMJ1U0oVbn3wuTm/dTM+75Zdij3arsxmj55XIATLahUbay7xuXwaCc8puiUsqEEQmW3QQ4h2ZG2aYpZtKeaCm4YKjwYmTjDgRtsZI3QhLeFDkTCEwZ4sOC1o2/k9pEFzoug4hX8ySouFpqiyXSqyKVYcuQp+cdgc3UI1f3vRyE+kEalbQa9h7S4I45MmNTjzThll6YUklpCKKZLRY5QquMKmlVFigQ9uxFxoNN7L6SCbLM9dSvaCcsLhkcES050Qn4bxfxj7IociR475yeD2pEm6axrGiPwlo18hmyVmcXwcy5d6iTjIMLz3yLWqxEAVD91CmbTKyTQxxhg0G7x559U6tYLWCy/6ipniY0dtoNR0AAduAcv/jjcM4aUISuOldi7sXKRxHc42YBvOvTm35pk/LYSeYAO1aD6Zk90RhodAM6MheknDFVBvKVeUK6pXhgpdQllRXSNDZ0rRMODqvqJ3dETRs8Es8rYR4gEqgyI7gvNWC1u/I12pXbmMLZYxFaRsB6qyYOjZY28WQZMR4uzfHON1SAl49YxMnUlpczwIj0obZ8N1VumYUlDw+1Dh4/ae0Xrv35rGSY4b+pMirueE49OhvgilMxII+ntCgvfOvrd43VtoELbZW2scvY5OXyDn/lojFCEm7V3RI/E7i4zdaUsZY6wCYy+EhE/lgKPmtSe0tGnhpVQ+1sKVQWWEGoGsNBS1KtsWArsd59MwPnXnc07usRTe02jksSfdG+YiB7Pg8jD2GioMUig1WIMzf+aw9PBsVjfnsSb6NYkE64kHfhf3ZYyoybGU1cm93KPoOj5hOT/nGFon/OB0SoJCE2abdWNeDK2ajUUdrbpqm+IxWdiTraI6vVkhBHADkitzXBahVAmyioFuEizMNO6KLFbhFP31HC/Ls/Wjf5aUYKlNtfvzYLbMF0oK6ZKOAkbmyeDhlkxjmjBoGLaTukayNn0l39IBUEHVw3kSjYspk4U47/U0ZEeBcxwuZKJEpppKnruH0kXTBMWVJCqEjmGVHvfdZvQXkFvr4fDOum5hp0hnk0EZIF2oHWozdAcdoWFZhWDj0rmy06l0KoNo3xIdtgeSrFYZGtqJYUUQskieaKQa60YgF6MQEU/On1m+YAJoIirM6MwY1ukW68Nund12qhd229i9Ucn89+ooms9Kp2B0GKlpuApjvWwaKogGmw6LXv8eiBWP6PE1t2eEah7jOd74KbafE8P1Hl43N3n6/RTTllxkLiS+zqG3pU+vc5T1/BCeMV2PwMEt5Frue0g53d6C9n67R9+t+22nj0Yfh9E6LxKSEZeiFCupR1ioWaQbEGFMSHOnj2gIuaItN5qMrNeK+pRzxIWwqNRVhI/bxsdS+QGgWQMjkjBQCR22ry8B3ZnDb33u/IuMtPad1Yk5CCYsFfYyDaSBt0lrC5bfhL1iiYoFXbVQKvG9Cq5ThicKfxUnGidGS5hgX+lqiTIfgGRub1iPxLfZGimS4ULqF0BGbZ48cfd+LNCkQSWgy+jkl4ZZZWkDahW4KHIR9JrjqhQi22PMZHl52TAT+oC33aOmbY+mmoKGBa6CTvh0ZCSXJQUBJZOROAj1mAGe8CwRZa1atZBxSGehRCwqoVo//z7lwWzWe3mEeuvYloYxDVPAzXkPAqcFptCupCRXQpEpbizpPEnJ61TH6wgWZgmj4DKL30vKdskxBXM9V1HKAPVQobnvjc06n63z+iHEaLeivBDkoNEHQ3XVRuoIybA2nM/D+Og3IOZa6Dc7dCifHdmnLqizVdDN0eK8ECzDbFTCRg99w7FFB4CZ2MkaN1ciFyfRAqYVW2r/3Uv2exPcOyMlOUIOSqN7Q9nAbDU9HmYhGGxQbOdiN4oLNzZudqN4lsqUpIeKI4Ukjxg1mZvTLYv3wnCFXXFKim43rSsfvUho/WTI4NFozXUzx81aN8/G7vcNFxxx63uSw9O6PIVST3Zs7VKe3j8brDO2e34Ic/983yUUyz+/3fl8+xyv9haqGPcbbdzp1lPzLqIIX4XSc1GKgbdR2CaDUGvktmokpN2n1znoZvnq0a4k8w8r2V8J9Yb0nFQjWiiqfHh54Re2jQ8Ope14nTk2ZQ8ZNEra+tvovHXnN94Ge1fc0kiI4RL6gTNfJhlVuIQmoGgJVtUg65WiLYZaWXR+ycp/m/9zw2pQwnUTdGgYrAJiZU0kb2mcslXMmeyyGm5yRCnBess6ME8e4Ih8ymEIJA2rZluXiKBKOgB6UfSlhFPw4shVowflJeFZAdwpaDQwdOdf/vbUuBP8LshnR94c+9Ths6a8E4x7XBMNZAe/g+/ALQajEAZBhgZT04E9aodcCZ3AJcabArsazsssGJda2SbiRd73EZqWeLShD73CGJoZ56+iZYRQBjnND8v2Lt49jDUR8IgaoxLMyZkbcygUTDpCwGfZiyWlzkbUJopM7kacqkWPLzVFvGB+Y++dz9a4iPO6CS9bkB+iq0HBRwlhYHeGxjNwD8fmmx5YliIUC6WW3pzbN0ZvYG4UFeqloF5AjQ/XhhMlElGeHMu+YJmjbqs428VgZN4v812FmE8NwWtE3oni0S06HURh8rYWGNMsfhDHVBgaTN9dlF2EzY1mAdVba9g+sOsWrVBEV0Sl2PoZjzFEj0tk3YCIwColf1aGloAOazBqfchRD+Mczv/ZkT/HFGdoEd5fqn+X28+44TqHPe9swulvz8Yr33v+qDztej7EmV0Djw8lPzex/vDmdu5t577nz76zj8ZuLQzWSuUf0BoJ44RMjiQFPhUySrDStDzq55kF3XhYEDKGTRZhuqcTUpoLqR5Rf1Flq5WvLjUESN2Q4KKvfbvClPtpIyKsT4n9h6GYNyPzQspSEY+/+INTEGhTRgKW0aPHNU0UMe5NGhGL65ge98PjzZ5JcfdGiuf6QZN3ohbL5vMOssXqBC0nuvdJyDiUNY78Vyk18z8l6pkKSBV0U0pGWVw9pJZKFo4TUSgdxi1hTQliQfb3QHbBPxl2c/yz4Z8NmTUzLQyXN5Dd8T0Xih4LjU+DmhEOIsh28qym5FQKNsw8YHkpeI3Ghl0sosOltgCYI5ZCxDk2Z2PP+XxiqOY/siNAYpWZB0vocgZoc17MD4ucpo9QJqzogk6iCZkby8EzVSZmZnTWWS9/0UOM5d4sSTfRR6xKpVQPpl8V3DpujeGdKTbYhnN3p7hR0xkajVWDGIZ6ZpsTMr8MLjLo0uhe6TiahXLDYzwZBbUWbXusIF5n6pQisjoGDA/1GSm+WJyhlxi5PZcompY0NDEfonBZE5qUbtHorhnsDptHs9DxguqVqnUZq2m4pshvlH2PNFKhxaRpzARQCdUQk0KjRlE0YcRWE8sVafnxUCYsPaHBwzf/tzniOt+Fp03Ov8jT7ydrdQ5f/Wm38439CV/1fGhXo1vj3m7c9jfe9htv+51bu3O3nd0au60MVCwO5mshiMNk3VINg1VTeqlswSwMQdiYrCMNV7eR0dZY0dY8t9mG6nyeglJL5XXb+P5WuEgUfooYs524S6Amczx+3p3feTO+SXhQsLWIBTwSEV7J7r/RcWQqfWtC45nrqbo6NgcLyyOHMynrPiJSUlZeIwwLzJopTwPt4phMwxWst1nAOdXgyIVsiaSdpMDcHbcUzvWj75Rq5AhKvSAlPGPfEmItIBelXBUuwrikOoY67iGia90C0tx93ScbI+C/LAzmjag3uoN/BoYgIySBrHnAqzfgLqnpGD2ogvAlMIIK7gZSPD6bHWq4lGhLg1Iu0Xrj8uFCedm4e+M2bvglIuswJkZNgochSz3fDMbesjF2lDmc58l0BKJtWN7XekwckXAwBoNhEsZueVKDkvVQAlRNfUPCAXLPGjthOXSx0IbxqhnSGUJ3uLWIzt3g8lLYdGMryuWqXMTx0fn89oaPnmPA6EN4G44NQ71wMYGeDMxs3uoI5oZQKJuw9ej47brTRqVgjISFm2WZA6HAwiDIOVbTR/AoG9CC2Gx/k0Z5xBxSl+x20yNyRGNJ0lSdB4pF7ntrd8qeGqX1Fp1ZS2pO3q9salS9UvAo5l9OwQTLo/R5Gq4gaMQVVTqdyhQu3tnoUmm6cd+uaaXzhNJoaeaLPen+HFPt2P7tjbh+t9u0Qidv9NmGnSHA88fOoe00cue/w0MAh8CwnVu/86ntfN7f+Lzf+LzfeWt3buPO7o2hIXAbbd/9oFnD0h+sGr21tkuhlkLZCluZBAbobUROq4+lWN5tQnXJ6FJdbLbl6nmc9OVy4RcuV77aCq/sSObDQlTd2U24GZQm3Dvcd+c3fmTce3RoxUOANmR3xoLgoidRwHnu0cMr6n4EzKNnl4eKfdXt6PE0oPcRDTPHYLZwIfN4k3Tg7skoi2sm8z0mASku8sfpoUxhYnGwJhlVgWbzwggbe+QwNNTlS71QyobWK9gWavrawzhVDbLLFTo9hE9voX5ADW8XCzacSRACJBku1iOK8g7awfYwSCQcqMPR4QFBdbCucDe8jRwnhrjNUGaChnGdu6+IcgAyOlLBBvShaFOa3ahfF/wiyKb45kiN59Kb4dlsspSSLMtYmMalRG7RDO4BJ53VXZAwPtOTL9lBeS2NZdYrzXDfSbYJ4kZxZ0sVedFo1bPNsC2Nxhy7RTeqgOZ9leD642Y0OvQYQ2oNT8fiUq98+Kpi/c43n36MjxC6FcLI9R45RO+Nr6RyRXmtNcZ5y8i5G2pCLYXLVdFtsG2NwZ1mAbRFtJmOmyujC5K9y5wNrYFqlPpCEYKNKmGUNjI6toi4Jns8EJkegYs7xZ2KcRHnIvBqwnWHqxS28sL28katX1G2O3q/UOpg0w+BHJyiLE4jqKaRqgsubOuvls9woOxcaGzcuWKqdK3rmeraMxEHhK56rJ/n1/N6+1NsP5+GS55+PlipFW48Gq1nb+A9w/ZtOa2JcqRla72z987eW6i890YbLRZaD61A0xHNAG1O3lh8ITytUg5osNSyXpJN/UjPdrZAMM+i41nAPNmCJ294Xky0GC98qBc+qPIqhlqHYpnEh3uBTjYCtFDF+NSMvRujs/qDDcsckno2b5RFz0eIKGUyz5IJWDxyWYG7z3PzkLrSrDdLKr17dpg14t/DFiw6xlj1RCoEXDck26YfRlqyjitEbQlIzWe0GItr9HWCbatodnie6hxBx8/BkHk7T4djpCFxorfZKmB2hzESFiWCvO6Ri9ol6toGIfnTJVq37CDdjx5cWeMmCTcGmyUX+oxiIvQ7Ddz5hRa5qlmfNYRQ/O+O7kbfR+a7FB126n3muBd84j6FvHdx7UGIYUF6huM1I0wPfFMZqDhVj8Vr+CQZRPkuKw5OQ+dT2WMuj7PrNSsym/kf4Zg3IuForL5tEkc0j3Fy78amAwVeSuV27+EUIcwaLF05gDiFvRu8VC7bla9fLvzm7cfc9p19tyiLkNCb1B7RjhtcS8qgG2wogxFX4uMg+phG9GUxntVLQOYUaqIGqLNlX7dZ712MdHCj/q0Q2o6bG5sPqjmbwTai0WRtO6UNdAc2xdsnaDU6NJcXZq+087g54ELLqCslqc7DisiEzX1dhDtXcBhS8lkdhitQQo0xJcf688X6+R22n0/DBXmP0kA9cq6P98/bezDgOeI6Q4rnvwkLxkjginvv3FsYrb019rHTbKclrj6IbsPRDmNChDnxyJxWCT21Ugs1jZfWwlJCyKLFkT2lltGahIxJcZ65ptP9EAmP8eO28VqMC5nXSvjLq3DX7Pzq0O/OmxnfpISTj4DplnTSvKWraDXgHUnDZVWSgivJakrFjzITXlk4raFY78WhH9+DE1JHHve3W0+DmepuQuQfZnSZDCqmg55Q5zpWyk+smq9UuKglarK0aD7OQxnE5+3TqG8J0kgUjU/NP5NjeAQkeAwk3QnF9wZyI3UZw3DJVAvJCGzWHtjdkz0ZxkuW9zSZZZmvy/qeiaD6KTo1zVusoDOvNoyW31tMuPYeqUkNKG5wyXFZw3hoODtFQubLOpRLGGd1j+LoYdlcsrNJp4hTS5yjmYT8GFmpTThcqTlB8Z551Xge6tNApeORzkMIIk/HzQ6mnITotETVM3gJp4rBPpzbPhCDaymIzO8KBqvYhAvJe5jqKFoo2wvfv3zgc73RvGP7YCSpRXcJFmhXyiZcauS1A+mblHIlqrQ0x6JA2cNhUUnBYUCcIvUQzy9EITpxvV0iGrWEe6Zx2ehUH2xuVDO2Mdi6UFul7Jlv3Qq2f4NfNtiUuk2Nty/DnXPuq9JPkZmtZdAS34s7JWy0kEJDVu5xGq74VGr+yztW6vcjrm/ZplW3HA0rPtWjWO49yvs50poGy06/M4+b+yVWO6yz951v7p/55v6JT/fPfG43Pu133vY799bYbWR9FatNhqezJh4otoqkzFGllppRV0gPBc4eiu+7DxqdJllqLCmgKwRcVRwp5RBsVUGr8HLZ+Hi58IOPcLEWRcZV4OK04vwYx7Ssuuxf751vuvM2IroxIuKyjChUgi2lKQrr0pNyP/UMPQgNFbZrFE6HcXOG9RCXbQPfZLUxoUe+a9Yl2R4GujFgi9wHKhQ7B8sRPamCZU5t/tGnwsb52ZLRbJEQ7b2k2rwEtKbXazxoE3q/Y9KhDEqpzGacVoKhd47yJ89hNpV1c2QnjNXumdNyrIM3oNtKcPfmmbgkkJq0QnLq9jyN8syDOiMLlEvAvDNHUtaNiTxUskNHYZVBOIM6bhl1BXNOuGJSsZa4b1GoFa8va6EFEhbWYFhqj1tlUDPauioInS5CG6FSMrupmRCq61lUPLtoQ/SaYj6DEozAKBPwSdOICxq2rrNIlIfriAt1Ndw2ujmfDO7daX7ne1Re68br69eoRD842zuqRtmCtdv2wY/edm63H/Ej+4S/7Rlpxly1MrB70Oy1VcqmvGwOGtHGMKfnMm5krlJiIZf2lmrzHcdQH8EyrHGvJY1VLWkGLHQ6jYBFg7LewmDRuHhj88FmjW0MqkDZFd46SEOkwcsVK45JRy+GlheQip9MzWGgplHcT4bMMioFQyl0KlcEuPGaw/4MO87fJfbPnLnLmnjvBwo/xfYzbrgeVqEv/3Q2RtOVmUV4qYy+qrzP9QeP8fGXEOL5q6eX7T2Kjdudfb+zt52977QekVa3ELs1Cb/Jkh4+8zET7gqK7BTR1Sgi9JTGEV1tHCw9yp7MsKHjyO3U9OimtNPJSG/XysfXytevhe2yUzxEQdngrkugnU2cMULp/dbSC2XacM/Y0oIJKCmU6hbEhAK+yYrgpAp6LeiloNepQE8arCQvlFywK4FrdVm6dAynW0CJXcdSaghCCMuZcFjRSirtpNGKQ4dj4EFnz3NWPQxXKbHSG+A1iATuQWkeNcknJRb7Icnqk4BI1/iRBIynoK2BDXmof5E8Hz+PL/cUSP5yzEU+7uQ9TdFVwruPndJQZ1NIcQ46vpyGrkSZgtbI76l4wE30qInqMyrvIFuQJlzBaqhHLEVmktEa+Tgh7kO5Voo7JbtTk9FT0WB9qiekng3MJg1bPBbN0PgjnbdozAgjSROzxAKqhmagJFVf8lq0ZPTlwZs3FcyiptF7h5syLopeL3y4fA+VkvyMT1iH7oZVaFMYoBc294g0S9bPSYLDI5AAMagmbOK4erQesb5iDwjWoFu2UzGJ/Kd1bGiQNDzzXBpjUU0i/1ZAzNZy4zaZgNE0U71TfKAWzSnFHOmKNEV2hVrw+yd8u+BbgbEtXVOjhjFdS5pzVDYeNV2VFmIEK4qKwTmobOwcJcznpTGg4fgeS5IN0Sxz7vT7UOFP2IQFT4ScUP77ucr7WSHj24yXPB87/mZuabgarYXB6r3RFmkiJZ2YC+7poHKiv7sklHb01lKLKMxVUmwzYMHJHhwaBIBYJYjoJmZ/eNrzZxWul43Xl8qHF6HUVBUoERE1g5aev7jTh/PN3WjdUyYpDUYSDhBWHihuVUZ7Gap5/tRr1jpdCvoSUZB7dJf1zI95rE8JC+YxZn1Wd8bd6BrXutpppJEJA5VTJ915H9PzSwgpH/vRgDKgLyklYdlgag5LyKqA+Z4yXB0vJWufiOuflN80BCQjnTyXaImSBIsJeS6oeU70c47h9K93HdPngTg5oweK4O5HUSgxprWA1NxLjuEvmhGTONXTq/YBPpfFVMBQj3xbdNLEpeJaEZ/QpK/+WxCEjuJBm5+9vpZgg2UptpP9pw5W28P1zflKnvAkhHBch2pGCNP6L9ZhRF4RXmb8kGKYNgRpDijXWnjZXmL/0bJeIcdhzXyrEdGwaxZrxyNUmfnliIKwuFdVoh4zmI4j5K8mfC8D9YF5x01hdLz0eEA24vRF0nh5FOKXmAuS6QHUIwxlKl6EkK/4CONmPWDrIXhXvFe8b9h+w9oNbxe870i9Ip7EG46w/Eza0Dx2RF+NbTENj3q1adACQXqkCMrT8SQ9GJlrFMJ76OHvdvsZN1zP4dDTnyasN+fBNExnPa1nba1ng/W73PY2uN0anz833m7ZKPLtnrVbd9rYGT5SxNXTCJCTLRdUi9xPSLVUNjaKV8qIKGVAJp0Hu3W6tkPWCU8jRco6yTq+aNYbXSs/+PiBr14H12vAXlwjOuoKrYVXeHXl7UeNH70Zv/XNQHp41o4v8oSXyICULVQbxmjxvUXxLbXllFBEf6noS4nOv1t4YGNE4ScvExrzI+kPsQA3x1tIWDUNJiY1ciwuMwYJj1dn4NHC0DFmxBGGpdbQPawlO0STsOwl2o1oCZ0NsR5KIxfJtidJadaAU/IkY13UhIAmc24QEZfNqCIcgIfk1xlDRNaC+6BIMG1RRmLvj/f5+yRnpGUM3aAFZZ9JsGdHiwGlJxGAqCmKV/Rw81ym2shrESHCuTAibooXXRC022SXQimXiESl470fHZwJUWTJ8529LuclRQRJKLBo+v/7cQ9q5nJESCjbs7bLYGTtYSGRCWV4iVoqqaDGsIa3yEsqd16+p7yWCy8fvgLpeNlhb9zbSMcLdgKWF/d1X332yHPDLJ57HUoRuIjwWqIcw3wqVIx1feayYGvvs620Bgy9BcwpGmUqRqGMTtFxAI/qqEW9mNKTeOQcbVuiVq71huw7Xu70+w3Z3tC60d5ubOUFlYqXULSfUOFRNxckjZpG68LOJaFDRxc1vnHJ2q8DSjycsveG3Ryz34KS/RTbz4nhen6dFoq5278KUvy27ZlNOD8zgziPqGG/d+63xu3zjdvne8g73Xbue6O3EQWxHjkKXwvg4QHXSX8n1d+9UFwpFi3KGTBKRlliSc22xM4jQpgojmz5c1rHItRL5cPLC19d4bJ1pO7IB2ALQsQ+Bnq5RrTT4Ef3wae7MWbUkwQKL9HuQ0uovNsYqYgBMxRyC4MlWW+mqpkPzsUtVQHIYsu4/0kkSQr8IARUh4WY6tCIDKWCbiUYen7UfXm3qJQep2dWBClZTvAS7VBm37JS9CC7pPnv3ClfKeVVqV9feLtLPLs+Uk/SUu8wbVFGoMEy9EMSZ0J0djJadho3qde3xuYcgyVjqDlUU0Ejxt7ZQMWXyDpALoRx0cc4fXbUlgqMJ7lG2F25URkuNISCYbrhGe0HLCY0V1qf0fiIxdNGRLOpKSlacBdaFioHFFvTmPhxYTNsgqxF1ISsYvEcHPnNmhGUiiMp2TXEoQ20eOS9NCOEjL5UtrynEXGR0V+UpwUj9XbvfC4DvTiXC2zXV+pWkEvButB7ZwxDiydLldVfbI7lYHUOfBhmUY9VinApwfIL49VPD9ojCpsOxaihTEIBbWBxH4soVhI13wrFofax8kQ1jbVkhDgQhijdSxgyc7TDKE5rxqV1tHV0b9z2Tm2di46o+fsiyspjM+u6gh4/I66BZrnDg0vEeX19XmkPd0s4634++GQ/5fbzabi+MFrv/IRjITm/3vvc2dF9IOQkG84GfW+0e772xt6CEj+lh9yOnNbhjcfys4qNSQFdLVmYGxCimeASua0vjJZm3VJCnat1+4SFPPpAXWrhw1a4aKdKJIFkE5gqD2NQ1Bgu3Ifz1pw96egPCy4JaSRpwkfkegLNyEHpE5IL43UOY6OgNTXscoFffsXp/g8fdB9ZlxbnOEkmUyA4lLdPj/1ktFQUyXKC7bpRLofS/DS8omAygvGoIEWp3yvoa0G/J/jniPjsHuQR6xlx9py2D+c8PZnTWJlG55nYM+U/JuPz7Di9RxSaRZzIoRyScMuj/+pP4/WAZeZOC4UzsnxNaKnCHixNwV0XC0zmSUhKG2W0NmWxlCh2dpkRKUxlc5uahvm9oiUi4Lx57vNU5tV5BqE5zjyUI0oM0zDd6TDY8JQYS/9+RsLmoAOhZO5V1vgKsk7mBi0Er5s4luUPVQuqlW3rSW4CL3aQkjWN78xLzyJ4IxwnkWTsRlF01ahvjDOLeKN6ZyDp0DTckkLoDSxISzNV4Ao969lqGk0LjsppRk22bURzI+H+OgKi9m5IH9TeKa2zt07vnVI71TPDJSyDNY2XrN8fX86MqZ4Xxnk+XwYIq6btW/7+XbafE8M13facVaYsYP08idc9frp558XDeHweDwvO07c7mBn7vnP/fIvOxm837m+N/ZZdjVuLiGF66+fcVhovJQenBxmjlI1aNEVPJ/suoq1eBk07jdQ41JiopEeos/ngPGFRLpfKh2vlB1flYp/Agh5cROkJM4bm6eDNjH/52XnrQciQNIqSzIExYmKpC3ZLONAJ5tkimkiqomf+K6+BYQyin9BRWxaRUzC6k2wxLLtB91jUCmjNWp0tGCRSou/QXBUPllxMja0WtutGfam8fO/CyKhUazK3bDDGTvc7lw9X6scL9eNXXL8CaufT+MR+vdO0M8RjbcnC4RUpEt/NzKFN4+nEe12+HEs+B04afofVPfBhWM/V8tGzfbBbp2Uk3otziTXcV+5lqoys88qgTXqM+36JItugTxAtQVDQI0grEuLKg+gA0JyAaMW5jhHRznRsthJGAme0INMUDaWUSBLGYt9TVzLo1GUtonMxdo9i3xT/Albdd8hV2QiHSbPYPfOu5i1tdcB3TpA0hAw83VDbGfud5sbd4avv1ThHKbxsG9tV6K582ltAx+rRBoSAMYcD3VJxJCBj8SPSvGhEwCORCvFDiX2kCLaNcEh9ODYuEbm6R5QpWyjNqNBLlDyoOl7SQI98pIniWEybeFpDokVKD8Mr+6DcO1I79/3O3m4B4fuVKWAc0OBRfDx/Tsmng3V4jqwOuvwxFuc4nRxFWf9epQznufAdt59xwwXvhkbvRUvP7/2k7dlDfv66iXi4Mdpg/9x4+3Tn7dOdz9/cwnjdg1nYxlgsQE/4Yy0+lgKzXijUSGxLjX5NNbxFJLymSchoRCQyrDNKiNoFcyxo26ukTILQUVT5ervyVRUuNLyN/LvQP8G+lVDNlo0f78anu/Gj+2CoYDVulg/LKCBa1YcCvEdmekuZTvEUbZUgY2wlDFcJfpH1WKTKpgvjR7LW6fRsrIeSdxsjpYPiz7pE6fz0+CSFdjMCTPUHFeXl9ULdQm1EVdEaaL71zr7fIlKtjrwq7TJoegd745u3wSjGXnfaxULe6YWlEUhn1WBFB8iILtw8GmMmWx077WfH9cVPPXJa3R/H2+SLt/x9sVbOBzqqZFakd3KGYhWT4ziax7rnDhM+9IiUeqlJLjm6+07yiE3GpgxGwqxbPUdL0PqIsSCeAvR91fBJTWX8VPHXHJtWC8UUzOltMn/ySvO560Qn8sYPgmgTUJ2Ch0RT8xH1e2msS1WwhmBRTpLzVXXn6jc2dq5qVNuhd7p39lIRDeVkN/hwiTxd+8ZoAotIks6GO0FSHiANvFk8/2uc23UbmTdVtPcEAoJK3qlUb7QRJme44WWDHkzCIrY6f2sRsBF5Xg81GyyL/AdLUslEFgUfF/YkNbkO2He03tBS2e+v7PcLpRQuo1NqTb/dEhZsXLkn/eLIkczMV0/wdi6C57qv5INycBMPpOAh0nqeD99h+zkwXPClhZoji4c5vazO2YjBOe5+DOLOhuudCNfGYPROu+/st5123+n3npFWj9yIhejrTFAvb9oPqHDpr0k08dOMnCSVoE2C+j4wprqh4cvDXKfmeaKDiLqKspXKqxauYmhaiZASkmiTYcIocHf45u583qOvliW118tjKBDNHTKfc6oTcmAKx0nmtyYV29wWPVxG7D2hQpKQAbEIjR75wJcPL+y3KCOIaCxlocj7OGErWMXWuiULUzPaqwEXAlgfobZhLaroCiFAeoFRgjloEuUFpobVqO1xIhfkRQ7DJRlNZfPHM61dzjZm1hYs3Z7p8Zz2GQLnsZGflwGk4O8cLNNEPYzdlTybOa7zWI6xMIV+6fnM5u96fJ+ljNjDAuPHN0ZQGL/H8IpIemnfZa7XSChLSfKFZhQec2+cfcs8xkFome3sfTlXiOc8cYIyEJDmJIOYhGhx1uvmdx5QlrrlDHOKdC6Zr7lkCUDxUNLdbxYsPj3IO4JTNRiFIyFMzejanIi+nYAnncNj2RQtARVe1HAdqZ8Z868kEw9XemKfbntQ1WcxNSXo/RRMwzBLsSSuxJjzVewvDIJsJB6R17B06AaRruiN0XdGa7TeqSNyeKV4RtST+h55rZI5relmTy0MW0YptrPSfOwna5w8G6+Htff3uP2MG655F85QoT/+2c/7+TGh34um5qHOrxlhneDENYH7oN137m939rc7+9ueea49WsT3vgzXnGyxEnp2Ns7arUzI6qRlzzyVhsRL9BIa9CQRLGneZBEyWf5+/hnU5JfLha+KcBEP3TYlMXngBl4DWf1m7/x4N+4WNF8kAgNzW3Tc2SAwi6KgclKG90WGkJKkB433zWKyiWdxcRotyWNNH6PfGz17Sf3CH/gBP/6tT7x1p5shaykZyxEIu511ZCpsW0FlwlRADeabObS3O90agw4fNBiOL4q9hP7g0MFeBr55FDi/GBd2giiSTKoerelRCV3B5seYGSxiC6mCwRtH7dZ5KBrLc38YZ8t4pfPhpzfnODwN7GOk++MBzmN8kAxNQj9ROcghSjgbHUwKJhokiBldLK2q/GqfHaYkiLgJAW7iYJHH7YNU4JhK6eFAaA3Q0Vyyhs3wFPYVUUIJXTDLGjHJb53OvYcyhSZ60dtAdWTeKcjYonFSy993R4anJiZcpHGxxkbjKi0UPrwhtnP7ZLAJUgsf9YKP6DBQNaJREbibUYYsI+Vp+KUcDhmAbxH5lwu8ZA55iFEsmHoxnkrY5UiN4eMFtKIWEk9agh5sEvDgzD15sVxPLJ2ALF/wdBTT6EeHhHAYSm9Y37G20fdQ8yk98l2XGgZ7Gq2guPcltDvZgmf6xrlua/b1GpQHQ5VuKqfR9OgU/R63nwPDNY3W9DxPv5+rU9f+vwurPyf89JTnYR/Yh87e7tzuNz5/fuPt7c7b5zu3zzv3+wixWOuhU8YU2DzBSSYUSkwqlFormxa2Et1/USLSMqdr5LcajV6CVWgz96QJKXoU+83E91aUj6XwBy+VDzLQJDl87inlJM5lg+7OzZwf7caukcthI/s4hYH56vWCjYB0xm5H4qMT2D8Cksr1NWC5RXtPT5xZy6QsQU4p4D1YXm0M9r2FziLOj3/7x7QxgiE5SEgxcx+5OLulTNNWuJSS1GnmHzKP1djbHu1XqiDXDXkF34xRdnYGYzPs4vhHKBdnK41XvgnDRUzaJhutbuzlwr1cY+bcOSKXObwmlHg7/X2c/n6OztbvmQN0Ho3Vkwc1lwBbg9KfDiysOoDs0bUirJbnNCPcST48OWQAXlOPTjyhIl3LzgEQBZw4LCDAWjoXMUp1ojOvhcefunvaCWNcr5RyAd247wTUhSDblZURsYgOZ55rbBK0e90wj6hYExIbRKRnI5w5RRhD4HJBrKHeKGIUbxRzXkrnRe9sHvTuKg36CMO9D/b7HVdje6lsBITvCen17tCgD08jCjZ06XCWCxkhRyTvNahV21VxN7oRfbKsUwQ2lTTw8b7YBRsaE3gYtRBNNEuwizeHrYZR2z10RMWCTei5zpllWjUlomRG7P2OtUqvlX2/s93ulHrl9rLz4foS5y+hlnGh5Wt/MDPTdPaMyZxwEGYrlI1+irvOo1Wfonj+tWw/B4ZrTvCFO51e8K136ik4e/jYeb2Ax2Au/z5s0PbOfu+0PZiErQVMaC1p3DahntOa5JnbmoXGBINIs44miicTPsEZfrxWU0WiaDcCwdN/c1FSlFepfNTCR3e0hYpBw7lbMtHEwZxP3fk8PPD2iy90aBVIa7AZV9H0DBMRUpwgYiEtScgImA7xA8qbzsJanGVFW/3WQ+HeLBQmklSz31pGqbOY1ZLBFccQiZYv1+1CJcgirp7MNYlFZLSgsLtD0SSKBGQzgddeHN8cvziywaYxaa/sbDl5J1UbYgLv9Ro9sp4h5hGLm0+19wbSJWrUOA2A56H58PNp/AosFfgsoBeytcuD8TqfjKxxOiPTRQaZDtmMCicEmlQ1z/HuIpjKU1mpH6zE5Vdn/7OkhxcJY7WiDzMsITysrXNT3Rh2wEiqwfgTCSoGJ+KKyzz9WAhFCvVyoViqaWQUN0ZQ6X0MUlYfZVDV2NQp3rhqRFqVge4ekHnXIPVZqKXcx46UjYJylS2O6UQTSmMSGBnmFAsihCgLPvbuIZZcQIZQTDMvbKHBKeDqbNrwKH5k2I7YDcxD2slK5LqoRCfoQByseDgBqlh2dLYsNZhx+KTIq8/ykywp6Z3RGr0FacxGw6yloowtIxTw31y3pqsS0sdH1daTQXrazpGXz7z+e2vud9x+xg3XkTw8Y/1fGq93tvd2O8M2z+/nz0lpH63T7v2gwLdG2ztt5bbGKgZc8j75D3EQ11PRZ/SlUiQSyRPlyckRQumJ6VvKI8l52Mg69xiEhQ+68VEKL+a4Bch4d+fNpu1xeje+2aN1eRNCzrEktFcOQ9UtF5L8qsXiI42WZAuMScYoaWiIz4tnPmrleJJm787+FoZrmGejRkXEGftYXvfMyXiPhVccVIPm/lIuSJfspuzUraIqjP2+dBBdFa3h3k6R3m5RVuBVQvrrAlota1bC66yEEoF5GI3BCHksYPHS53XNB5YGa7YpWZHmF9HR83iUp3/K0/sZ8/jzcSaOfd4SbZgL/xlBWHktP5iFnVWrNOsTgiypqBzFs3HZx7kH0zQXSveQayphJCSdLTc7wI/R41zU0W077h2Rv4yG1EE8WRGoxbkdacCI7uv1QtkbYhGhRG1dsPisgdARbwg9GHMyqLZz0Wj+WOjBuuuCN8V2Ah40Y7/vlE3QcuGDXJl6N32qyhjICINhNun04aTI0p/0rDsUigvm0eXbZ/siderWmCr8ze5ZYmLogGKVohaUdd3ITHiQipRgNqriMmL4PfgrITElHsXKw5w+BqV3rDdGb1mn1nBrYEop02DF6xhbcCgYTsM1Xw+1QcfYRU65sH998OB5+xk3XPDlguAc2Ex59xNr98ni0qf339vW5I+iwvvtM/dPb9w+33i7NW6fJ0GjBUwYy26Ua5y8tKhnUXQZrqDAb0SXY9FgnA2Piv3unTaCpDBSJgkOb39SdJP6hAq81I1f0Asf3fHPbwzv3Nz4kTu/2eBahGuJS/804M0Vu1iqUQR+7uIpoiqhR4eE+s+8Fsi6sdBWi/xAJvgd+ohnIB5eqGRxsJthvYeyfDfaPQxUFLAm7b1mJcmInkrsfnT+bcJLrVy3Cy/lCp+Je9Jhq4rvLSS2Rk/udEGF8DhnD6+LxzOvAhfgIkiF4oNCo0hbPuWSkkKYWgI0h10CCtyBm8MN5I2AK3cOVuAaaO8NrDmpy5dvnRaO4xjz9zPD8PzBdxaS+dFnw9XksHmT2TBPs7LUPUwqU1roHN0ddTzznUjd9xHntym8KIhGTrJbFsprIAKj7dT6imqhudDuHR8e9XeUBa1HfulMrh5gnfF5R6Uja3JFjm1g7Hvjqp0qDfEblSBlvEijtIia2BV5K6vLtNxGCh8797ajW3SK/gN/4PshFO1w73fKkMxbB+Gia0a0JfQK1SPfZbtjRD2ZFqWm8zbSw3RzuEPddjTzVqM33HdEdkoZqLyg+pI94gKZiaL7KD4enUgoet7b9V8JI5vPSBrB+tTBNjqXdsf2N+x2x18/IVqom7AlBf7Iax1Gq69YrLKnCFQIPj3GanaKyMbZuH0bp+A7bj8Hhgu+nOS/y488Q4LwuMY88z1GkBVG7+yf8/XW2W+dfR+0faQnk1CUZG3JrKMBRJYCYerl6SqMVWQJsIaIbtSqmM+Xr6BSLER0lzLDiJR51cL36sbVnJrN9AbRzftmHrrCAiDcc0FxyFZPs37GF+EhWFZyGJ0pzSSgm6ShEXQjipk9elS5enj1md+YTRR974eSyBhBcJAwkFqPnlmGrc9PD7aYcqlXXvVKGRoT1w5DPvY9ipvdYStZMhSLTLMetT/F1sLsc4FOwsJE5efznhUsA6VRY7L6FkZrGqeT6rs3oMmKYk5FXadB9hwhxQOdMOYawWs4zxA8PYIHaNCPw51b98waRjkdaEZgq6bLT1EZGa2fxvs8ZT1/35wWjwbrjHNM/UA3o7tz0VQsV+Ge/duGD4SO9juoUesVvxRsEHJdalnnJ0jNTscMNjE2iTqnyCcFJBgq8zFxHcdG5JZFO+oNkY5I5+od6UFbj95n4VTpLoy7QBO8Of3NkFdl2zY+1o98w47Ynmr9c/6lQzrtvUgWR8ty3nAw62ip2RizUBirOzfLdzA0r8esI7aFsszouDakFJQNJGDJUoRqQq2ySgBt5rM8EZ2zEvss+rceJI3RAkbvN3RoRHeuEW2JpQvkjFPEdVRsyRqjj0SMOXZnNnS98W8k6vo5MVxy+vkedPK8H48B2hllfHaOJyKU0IX3wWiD9hZQYb9Hrmt2I44F2VKMNuCrlZchobUM/IvqemnWyMxEvc2cllmK806pKBJqjGhmdvXFgqRRKXylhc2C/t5HDMBmIaJbaxKxzNl7wjk50XwxH4+mkEVD5NfcIpnec9Il5i7ZzkSnyoAFrZ0JI6VBlFQotX0w9rxPqZ0kkH26YhVYyu+pORi5opiM27axlYCZxhj5fGK62EgtPQWvkRQPbceo1bHMLYThkkOOQWFSMmeh5Jy+03Pc2ehWGVaP9iTn6Gq+JhljavydvCNZg0xPQ0uPITvn+9ngnMfu8qLn32fx56MpeZgGz60kHgAKj8T+eR74437uM+Lx9a2yzi8L1M/fDcwElbmBjHSCCmX4IuuIjITyPOoYS0Uk6fJZZqECpRjFR7TxUGNL9pswkMSOQ1n+VH1ms3dwGEisIzIoPiLH1MCbLmhvRvLsYbj85pRL5cqFCxeqFTRr9h58h/PtSvj83O0h/mYLUSglok2zgFKnCsg6nGdZgRmMkaoug2KhUSjp4JV8qSpFWXkuO90HdTn6mrlH37EhYDuMBmOHcUdGQc2oXlAZJ87gs0l6f019f99/89vPgeE6z3rlcdae99EvP3qGUU5z7ottITPOuHXabeftx3du39y5vd3YP9+4tzt7b/Qx0hPLOis/vC+BJGQUqiq1RIRUJcBCIFUyZsNcydSJZzHuqYFg1ujEh+J6r1r5qmz8QimU1hg2MCSQLIuixEuB3oPJdOtRn2JZoOrjqMyfxctFShicBn0nep9IEjBco0hSgS2p0qkgwP3J/lsoBLTmtPtIKR/hWmtASfvAd4ui1anAkEbAdxCi7Yi60HdL+jHp3Q6st4AGSwjiunf20egWtVlLUHnjgMLOPdnEE4QrmeXqBMpZ2H3jM19hreA34BuC6n4/vyQgxAnJrW6Oh6GZqh4Zyhzjcv66tAR5HL7T1s3DDT3dXOOL9eU8Jb7Nj5veygNa8XQcYKqQT2jwcc9ZIPx4wpJXqwQpwAVUnZdaUTNuNriNTtFgLqoZul3wsjG2ikcymSLOVaL1TvHORYIwE/9uVGvR+sONrWabGgTvA7PG0JAL9tKxLCWJrtOCtI63Gr8PQZswbiB30Dfh6x9+xQ9efoB9NurNuezCZkofCcvlfZ3Fv64efc5qDEHJGkHbwLagnGsNlmEwJ51mMDw12EXprilSEEiJZCGy2KzzFFQrWqJtzGZ77k8gD7YfhguP9jKW5QAWrVa0FXRUdDh1bNQGtV+oviVpJYqQz1CwnwZRlAJOWn9fgruWYOKECX8ydeP3vv2MG66zcuhz1HXmr8vxY/ZOOlOYB+/atePOZ/TQB+02uL919k+N/a0FVNgyiugJ6VkIKZmSDe1YpAklILgi0bSulJJqD2T/QKF5p3tMtU5f9HfDs2bT01E/vOWihY8vG19fKpcSih7DjObGj7uzi3MpESW1Ybz12RcsoxtPhYxBqNRbpVioTuy3hu0j8EbTNZkq8XcpEvVlHhGPVsHbCPUPVfwuIXdFUN8tIcfA6+Mm6xKjDZye/A5MwsaULVQQtKLZvwjtmO9BJHnNuhcPtuDeO72e+mapQPUoOr6CX4hi6aC7RZQlSvctp9xs4VDYqfRW8KYHJNjTsHbHhyxizIpU1gA6u+jHePyiKFMALOl3T2NvbmfE0SLSXoSNuf8mzHY2zK4H6jnm/fjbe37ee1Po6TyWvSPRA5kFpxNLyAjtJHEUkFmwBUWEa1HEk0gxBqJGbQNsp9aN7VJSImxwKUZxy4U6DJh6Y/M7hVDHUAkSgiQcMVUfJoE72n4MbB9UIrIL5DWWWJUpBxX//fp7H/nq5YWLFtqnhpsiGo1dLbj6IZii4NWxKozZ26+k73TqPGHFkvgkOFuQx0sgATMWj9uUrUJHIAMyDFVDkwiiGd3O2s9NARGGgGi0TgFDsl5sPuLNOtWUYhtiG9pvaCtIu+HjEt83OPLl727xt3PBcU0a/CRjaOb0pgCvZETuc3w/+0i/B8v2M2643pt5zzOQ4/fnP8+Ii8fd1s+n/d2i8LHfw1D1+6DvIxXEI2djWYjp4itKk8QEQkw3JsjMbZXVOXiiNzl4JRbgwQl2fD6306+1Fl6vhddNUR/ZX9XZjSgqLs5WMnHr0NyxqdAtqbqQ+Li6UqwgQ4LGuw883MMFUQbH6TCeltDTJJ+4jrmMxXe4L4OUYVLm0+aSR0pBcUQmec9KiTq3WmowDw3QyB96sSh8JptsWsphyWG0UIKJOWvUrkQxbuWM6WQS+tAKMA+OVfcSxmnCgOf80Hxys9nVw2IvHFcHZ4bg0T79NJsfgpf5gE8LyVM0dRD88jgzait+OGjnPnOz+Fhk0d8fX3OO+OP3LkN7OsfjyR7o4wm2fSw5jYnmLkTGUNgkxtFISyjWEbIBVb2kMTZqFu4uCoB3dBXIZk7Gp0JGPMgiPeq3CH0/cQMLiF8nSlAkYfxwFkSJDshS+Or6gW2rCE7vB3lIq1KiCDLiUDGkShTxV1LijDRSpOB1QtBTh5MCGaEFSdEzT3W6U7PAPktWsKxvUyelSFOkRpYIQRzPAzpNWDQevWcz9BJ+y2jIaMjYwWa+S6NH2CoijvD++Smy/np6HgwqUzf+5Kyc9j8Nlkd04Pew/YwbrqeZ/C30THjHy3zOaz3DNecFIo3bsEbfd9ptp721eN1bKj7MvE0m5C2x7hEDS2Q6wEHIqCesOjrvptEyw3Rg9JAhwsJjy/5W83rk6N6HiPDxtfK9V+WrAnYLYdBuzieHUaBW4cMm/Gg4zZ1GXps6U+Eibs9kORasOXtrIabbiWiLUK5XUWREFOq52EXbe4mIiEnUyD5BWUZQXyp9j1yYWigMCIJ1Mqk/sVVJjUFlu2xU3YiCAcElku9WdvgQ/VxElHF/C9YgFoXU2S13Lt5eCIN1zfeq44wkhATkM1TpEjktRyOv1BzZPcgiue77VFMtSZKZ0U0EnUlGOcGBX2yZ0zwFXUCOGzk5JnLYu2mpSg7cs6GbXxOr1MGarKfoq8zf/fReQJVnbsc0XuE8zPM7t3mfU2gq2E3IcMaZuYDJYGYLV444bg5bLVQJ/lpIFZZ0iHaQhpZC3Qr0htBQayh7sD7pXKRnNGVpvMYyXBudi0S0dlWoI/qs3XsHjbZX9RJ524CVQV8qHz688FV55Re271FFo3O5GI1oHFpf4rk5aQzd8eoBP2cUP6K+Ooqxi2RvvGhCOQhUQApUMXbdAkL3g+rvHigIKRrsw/CRKiFeI7oUqGUWZgeCoxoMx3A+owNEGBfLoLtShlPGHR0XGDVEpvud3oUxCuYB+w2Z1xlP8rymToZpcD+VSlvjoqajXRJe/oLVLQ+Hen9a/C63n3HDBe9HWu/s8rwrHBP/jOQ4D+mH+bnhxu3WgvL+trPf79zvO/veGHv0azKz1Sb+KODVxKg11aezmWEJozXbfgyxLIyNidLFYgGWKDaei+90iOd5ixRqqfzCV1c+FCje6TS6BDz4mRTsLAFvfDOMnTRWxZMmG0Y22ikUNja4C9aM/mZBQHBF0lutabjA6PcRsJ9AuQhbqVyvW0g13VqIoPYeTK7uUd8ihpSjLi06tsJoFouXKuJlJaBJCGjmz5wdryNgPxV8DHq/c780eolF4oDJOIyWcuS2jtX3MepOu+kkE9KJPNuUcnoiB0oaggkFrSaRVU5MwNPBYTHPDq2++VAfoxp5HtrOEemdx/GKtIhFtOgRaZ1yeHF+/mjI3nHUZsR3uDPOM6MsFic9Ie6zOcn0xT2XrTjx8NSzNg/D+kipM2FTpY2OLzi9HeLTRcBC+uMqHZVYGDeCrKFYRBneVuS80aneKL0Bd4QGKXLdrePiaAXZop3LYFB14/X1ha9fvwc/Djk3ktg6PEB7KpRtQ7WwSeHHe2he6gW4KnYB2WBUoydkKAVIYVq3TE9GDx2oFmQvPHt0ZYTjQeAI6uKgTH1CTVg06z89JDhS3zCQmwn7F2+LnF7ds1jbgrE4dqxf8Dbw1rEerU7ML4xU6p8D67Fa9IAL5zvznKNUutOop3f/NYVX72w/44brX2Gwvm3XZ8N1Xrj0y/2DzWf0FgXGrTfaLOJrEVH48GTmyZpAR2SXidVUyAhR3YgSJBevg3s2GYXRsmRCXfN1IDmx4BUVLpvyYSsUenhoZFTlTse5aAyhu4XE00wuH8xHKJdKqdHMslCwuzN2w+4ehaokF1JgqjDYSA1GHEl9PevO0Ow9lqSSPuL+TKhxwZ4SsMi8eB/Ho4luKNk/a7H+Yicv4SmXrQSBYjead0ZxvIaRkiequ6otO+EZYbiAp3GaNPxVKJ6ReKh2HNf8MBdPz2ZBRGkUJKN4P0OKMiMbeRyH54Pa6f3nYb2K9955TSM0DfYZIlxGyR/hwjWY5Mvv8vlDlkTXVGeI0wzYezIwheh6PRfeE8cvUcyZ1bO1pEmqxevqByZgTrSTy5IRrYgaWp3NEv5zp1rAiJM8cn44hYF6lMuGUn02SBRdkmHdBzUFmCO1KOhV0E3iOvK5TcUMy6irbEAtUb9IiWL7jYCgNyKKL+AllEdEzp2tMvsTSdelM0r2NjtMQzpPc+zlG5JMTRHN+yahxj8d4ESHTNJ98AkZ+pHitA6jB9tqdGyEAEAfIXQgDwPzuYBYmFChIwStJK6tPEGF/yqjNefid91+TgzXOZx9526cd3k2XBMq5PTe3GYNi0e43vfGvu/c9p17ux25rjaCAj/zOJ5fmt+lSaRQr2m0ApITCYDa0hi4hVIGnpGWz8iIBQkIM2cWh9825eVS+OqisGfdF3Bz55bKHVpCjeZzj9qaqfy+TlWhvlyoNZmEKPfPezD9ElOcpBIVAiIEuo+lHq+pgWgj8n4Q9VzDPLy5pLaXNFyeRAHbLeu8gqAxfXqFNFolRIcFonxzDyHVS6G+Vvasz7r7iLqsrC0jFxMklovJlJqPdBCQoMmJobmzoqTIc/sDI/SEhj0OvZJGrfgxoyyjr4eoK6HLmle5Vic/4EU49RZj3Y9jaJ+MV6xeYXzOUebZgCFHNLcir3n+abR03l9fi3VcA7n4siLP2UjRdTbT1Dydg0sW/bUmuywOFLcrPISFEKXDoOJc8xY2GxSX1QG51Es0ZqxCbQQT0Z3Sxyp/VUlJlTxgLNYhtbLMRkLZZCFw9x6RvWh8z6ZIhSE9rcWxppiN6KGlRr0U5CJQLxTuMU+r41fwS8iH2QZWJSFdxUQx15CttYmyKEWFJoJLKNC7r7uUaYNsK5OakGJR3qEeq36VYAQvUe4knagYNdXvq/cwXO5puLImbWx4v9PHK30M9qy7E5eUoZrD7NEA6dOC6evJ6jJc+rCgPm6/F2N13n7GDdecofCtxutsrM4e6Pl5nOtXyun33McsCov3e+d+36MZ297Z95193+m9PdRauWXNFTH5pGq0iifgD7VoI68e+F2oand6TpDdB6MOrETCJHob5blZ5l0SVvm4XfmFlwtVWtQqWRQcf8a5JSQSTG3jbnasSj6jjohE1AabXhGUfjPaW8f6bIw3zz3U36N8JsIReclJY0RfIslWEz3uT9sbo43FuptKUNF+ROjqGa36EgwuRSm1oCVUBwIuvAEDvwq+KVacITu9Cv2SFQ0vINWhGFsmqNUNkcNwzanYqYiFrKgbi3ix1sAUQ36Iss7Da87f8bRPbv48QR8iH44PjNMH/fTz/Dp/38P35wHLfKDz734yaqf953vLEsMjlMkyog/nMnceT7tq5ENCpCkApE5ntiZUNoS2EHhOccd5QXTrkY4jKhpC1TyZc/uNUgu1Fq4VLnjIIBWQ3rOQtp/suUMWofu8FzNyEtZNNBeKeVDxh7Bdoi+VjaDw64iSC0dpKQJtWbxersrLtWLXK7s3mg/qVRkXY2zQNCgoalHCYVRMQhl/pyxIYBASTuahOGIZdWaVWqQcbOQNmXluXxByXcgNFDW0OJ5ElGIt84GDgmQtl8fa03ekb1i/Qb+FVuOujH6N4+kxzOYgeKwUlKeoSpi9xh7rwP7NbT/jhusZL3laHb4t0jpv/vRzLlbCYpBZN1pr7K3TEg8es7/TbBK58K6c9ctJDo9eXShOVqgHJj075zqkdxXKAiaTzADU9FKy/QP5OwK1FK618qFW3FL6O5O02R2CTYQ9FTL6eKKmeqTaVSPVVTw8vd7GIVGV8IFMAeDsg7XkeFreVCVgOnFcRoh49hGtw0/390zhX516Mx+oVSi1UqsiW8A2UoSQNyC8+01CK5JUBRfoMlaEpTpQGWySk8iTmi0zeR9RwQNV9wwFzl5Y59dTXgtPI70KjiNiEz8itGOevwOZnBl7ehzf5wovpwjPnmzM+qg8OmBTHXmcjjkj9gkFTucnW+Y8hJFLRzKPldCBzC8+G8D5pfnR6OUV4FFkVaJjsXqk8D1RhvP0Oxsw8cygSTDlyin6kyEoHXVhuwibDmr2/yL7UvVj97VkzkhATicacmkxuSMIDWsmQ6kRbtHGoL21UECxcNp67zHXxULkXoVyUTbfAtZ3T6hQoAqmlXn3ZpnF1PrrbHgmWk0KQ5yhztCeKYL4nHmagDQ4ksxCz67RQUiKXmhMoYPZmVstBHp9RkDkPAC1lsXIDcYd7zveCtY3em+UMpO0a5H4whidmww5UQpzjrYOZuGXxmuVUvwerdrPieE6J6ZWNvqYsM/Ga77O+QQ4Fpx834Ho0DrYW+feOq0PenbpHT5bOyar6rSyzLkXiVMQgzKySaRn9DKmNmAs4tN42ewzpHkkYeXC4uCR97nUwkstvFRl7D3OQqFp/BQRNhXe7uHRjeEc7LAY7AHJhXcY6lRB+T8POsnrkGm4UiaKiah4NP/jApOmPvYe8KmRDMhciLIhmGeObDVKVNBNqZfCdtnwMpAtasYYDY/iFaQqZjvdBrt1LMWAJSWnlBFKatJOgcXsDZXP9RRwBN1YyCK6gC2nwWocArXO8nTJHlcy24UsI3coK8gxFNbYOrPh13jLTgAPUZWwIgXICHDuP+/7PI7mfiWeA8WPY9bTCUgaq1nL9W1O3FRimQZsDoDzcdZN9Fz7ham6XKiMWW+EAfUhmc/pUkWmEp6Dh8BQlaits3QI1TJaGB5OjTpFciHVWOBdiXYm69ZM8tBcB8g6xamf6WCR7xKHMpRKhS602+D21vAW46CqBGOY6Ik3ANeAFqteloSVbQOqhGILW0RHON0P2HR2vDIq7htoiU7j4phpFGsTZRjrEcy8lgdUONVgzEE01PhlGi0lfo5wzw5eYEZHDmINscZUFPCWLU9aY4xAbNxDmzSWz4MCf64+nM6fJUT4WAJxirieA4M5DOZy+R23nwPDNY3WKRt9Tn6fbdvZgNnTIZ4Wmfnqo7P3zj21CPfdue/GvQ366AwfONG6wXKCcJr4ilC9UL2iRG+dYpPWnRJJbvQ+UlR3YGU81G1FkJU9SIXA5FG+d7nwQWEbjdYj6uvmfDMAdYrDcOHehdYllLBzxIhDvQiU0E4sfmF/C8X49hYrthAsw9kRFvOsVQtTrRCwTInoQ0wwjcT36AkLzohh6ImlVwKGsbH6h+kmXL4q1GtBL5H7C1mfSIz5VjBxht+4SWOI0wWonuUGHrJA2bICmw90LmhBJTSUXVIfwOuXuoOzVmtKAWWHjCkKD5wMlT9IPNFBU8V+HWOexnns5WmJ5DH0KZo6j8UpRoekZE/+fdZhqRxR1hzHM4LMBqBUQrX/dD/WFznLMDOjkPMcUTmiufMFxKqa90MYGo0oZznyXC63bOluFDSLVSPDGMeLUTTSVjuMEb2oxJeKTCa86Ledei2hjRmjBlUo2zUgNxOGCeaFSQzZ0nCGsUpPywQZTvvcqVvlw+sLxZT+Zuw/7vS9BVFnwM1GFAprJAJsNJCNetl4LUbVjYvAj8cdUcsr76siMPp2gcglXzke3QgFnXAIuxUsHcf5lJSQe5OhIYAtShs1jKIE+cO1pkp/R0sLSnupoUJClJeUGDCAUhxsdEpvaO/c2kDboO7G9R5QqFwElW0ZrC2KZ9a/Wf86xtLRe+t4Ta35b4Xbfw/bz4Hhgi9CqljpHw3WTF6/5/WuSXt+Pxb40cOotBF6d91aFLhmMnNMssNqactaaA5Vwlmwe4q2svDSzfA+NQktoceImCiy1pH5+Sji1CiULBubGbZ3vAfMMBz2ZO+Zwb05o9nqEcSQZAIaJhKwRyloV/a+By15WERhHGXGEz7yPhLaIQqN00CIEDpv5LVkH6zp1U4kVUxSbSLurwNalXqtlJcanYk3CeWBkeKgVQM+9WjQOSRIJ0cE4SfvMB5i9AA6TSY5KlDMFOsKXZGUbjpgv4zAhp8Mkh+w7ryWkQSOJ8Pl58/kIhTRaXlwks7Dj8lenCSN9YeMe5dBO48xn3KQHOiCrL/NaFjm36ZRm4ZqMSQ4QqA1B6bxOic7TucxH/iEszOB5CqMWZN48s8LA/fBllng1NBIxy73lXTDEYZlUChHG0KHHFcSTFDJv2QxsbTQ0gzYsEE+7RntxOxJqTCLXXQIl1p5LS/Y3bAWdVPmluM1tDbjnGNs99EZo+MMRIVaSiLYA/Noo2N0GAaW0kvXaFBpEjmonhVQGnIVMWrVuetY8m49b8dwQDqMgmnFRzpqFtlDYQvFD3GGjHCgFdCBe8GpqSYftZ/iV9QulLHhPea9N6U05dIUeoGxUep10emdYA1K/ns+39kZfDaXfH6ZZ5PLc/rlvP4+5Ux/mu3nwHCdX6f3n42WnH7CMQnH+4eJBcUDEuyhjBEGq2ddx5yERMEgSS13P+a/nE3WswkLr2uK0oYydC72LCRm5ZgmLz5IYUrVwgcJDTIbI3oJ4XSHMYL+6oMQ0u2Od2P1i5rfUQjiyChIF8Y9EtPMc5eT4Vr35OkRLJFf8JayTmPm/fJ7zEPSacJxfUYRHv2KtkJ92ZbRYnPKBayFx2hbCWXrEcDs5KdMNEhysT0W/FlbUnL52qJlPMLwsroUy11SZ9APyO+8uFuc+5QdlOxxNOHDc58rSQ/d83NyaisBIHMS5zM9Rpkc0cthk5DzeF550xOLaJIP5ni30wCff9gIpuUUFp6HEMkSh9zORmwuMt8yL45zyu+d552Xa6VEdJOGNOqs4iOTMj2zW0dv5XXAOIW5fwaN869zrgyJLtuzsl/0oLlHbthQj0L6M2gmLgcRpzvVCptUrnrBd/DuR+PRWQjvkiSmuO/DBmPEOlCnXJsKF6mRQxshsyYtc1M4ZesgMxINdvGQAdZRnQX04GJ0DSYuHFxMsxF9uCyOOXIsDlfGqRawSw+2p8LQkKoyCkio2ARM/0KxjToqjELpgnZh68q1C9oVGZWtXqgefcx8Pa+54h2Ga8Kf5xaUU5jaZ83Je4YL/m03XE9WSfiy+PLZgJ0//jwhTxGXu9Hud/reGHsowffeaaMzaKENlpHW9MmWAwyLyV6JSSQJumk+9sCrk2qbZA+bNR2nNUrG1NQDXNi08LFuXCWil7EHq+pu8JaNKp1w+nqLvlfWPSbmPQyuKFx65WKVMpT2Kaj97p7NHEvQdkViAbSczGU5xkwyyFwrx240G9ysxQCfUe84DID0jFQEpAiv37tQXze2l42mjmxO2ZzLFfaqWLZ4qGIgRvPMqWiQKw4PcGo3zGp/XZyq7lsYy2y/vlrZ78AnjvdWZJMPcUZf8735PGakM/efpA5nRabn6GQGLPOWxUKfkJC/B+E9fv6A6tJDmFHO/Pca/0DPge5EzrFn9DTV8ONL0/KzjNgRcR3jbJ3Smbx73ux0vZPJ2MN4hSPhARWleeonyq4yWAT6JM6c28q4O12cy5qj0RJSesesg29oic7AeA3YrEAorPeILiT73Rmoech23SVg7Zvz1YcXvtJXLlxWp+AwXr5kl8LQJku4CN2NfQS7+OMv/AApFtGXO3UIt16QW8vcbjyf0tJ0lntOBw2pKwoankUYWXV2d3aARAcczUL9mM+sYmQi5VAiR4YKrSjmO71URhqvYR1PVZEohdyotlHHRu8VaSXyeTvoLvRdGDt8vFS6ROn0xk7Jiq2a1mbqeM7+XDuX6KBAzdad6ahNctN0eJ+dpO+4/YwbrufEAcfEW/9+ep2N14nR9bBoeXp3ZlHceu/se6OPPfI3BGtqYJhMNYDwLnwOEM8CSmaxYCRSVQ1VwTWgj5E4/hgHHEFO3sNb8dXwUlzZivJV3Si9Yb1DDxZhSzmnTWA3kpAxi3+JAuFhWQwtSJpUMaXtd7wnKWMLSqwUokbEYiFxsZBL8jAU5qlWPw2XRA+yx0U3GIs+PCISg1LCEMsm6LUgFUwGehUoA5POG4qVoFu3vrPnvXJNqATP3kF2en4z1a+YCH2kxmCbBkseW5CEsELksh5weJ9hXPw/hXgXBMc0UoeNi+DjSy9ovTMNlDz+W1IsNxb3R77QOh1O43SJ2p5H/Yz2Ax+UGSkMZuI1bdysyfITsQZm1aqQEYk+RVLrdY4C53iMcbWmT94D84NlGIu1UyhHy5o5+RzUs+eWRNHsQ+7EkwcqMeZGzgntIwuVAe/0HvncKaNV3KljUPWOtB4R0F2j00ATtlH4uH3kyhXenPZNZ9wG4z4CMszoawQVL4xFntkwY+89+mGJMty41oDyUDn6xA1PeG4gw2B3rnIPNXkAjRXCtaBcZ7egfGThgNhs4uLQLUgqURYTxI/iMdZFCkMLoxSaF/YidGt0jS4RM5uoCBdXNg+U5d4MaYZ259IE3UEbXExPa2UIT2vChtM5jLar2zJcEza0Zy/n7MiN0++d77z9jBuuJ6t0VgB4NljvGa55A8+1W3b8tB4Cs6Md8MCUZbJcLGYeZ8EmxHJ1znCt14Q+JmzgMx8U3p1PbDAXnmfYxj1rW0R5LQX2llGBpwGMZLAWYQxPw8U6jqcyRNymODtM8UFEW7lqSskC0Fy0V+8gOEbMXLByBTebhncu1/MD+XP1Xnc8FeVl0t1TKkm28L59YvUEDBucrmibEo/54GkdS5wsKMaTlWVDj8hqGqhJwJhR1xkinOMGmHmepSf4TOCZ94qnz3H6vIc5+tKcpZl6isweDnMeo368edTOPH5YcjzOWrWDHeiHeseUdn+gvp8OY6fX8/WegrrzKfj5l2nM87nPvKJIUOMnRDhJ0+uzHMKtIucEnKzDLi5sDqNhBxSHWIhco6AlwZbZMqXHYp/PW1qwCK965aJXihVstzRaFvB091CgSUdpBQYSpsvd6ZaEEolYsbhTi7IJFH0iV816O0tna44tkYjYiuGqdEIvs0hO6zzAmj52/kcE0yUJXwh0UYZUuhZ2dZo2mjQGUzPS2Wb3SxeKRXsjHU7pzr05pUPt0I0ovwEkDVHku468YV/dkC+07JQ24fkviPDncXYeb99x+xk3XCcM42yYnnNaetp1/h0ecdczXJIL8dgH4xaNIltr2ZBwZ/jOkL4W6sNRj/43Z9M1xSgLStFyIDHDGKOFsbFMPGsqZnDy6JPVhoMUZSuFV618FGW0qJPy4SwN2JwU+4C9h3itW5AovMcSEGdWUKlYM2w3+tsICn0RdEjQkFOA1IUgi6jCheiX5R76gknEGH1Ee3YnFNxzoi5jNXNc5MVVRa8lkLgi6EtB677KAKSA9Ya7MdTpM6ejh6TPpFl7en9A9DRCUwlDYPcgYNxYRmwSKFan4sXUO42ZRVOPxTGHxUGJN5ahnyvUY7ZmHvA0xvJtNTA9TWx/+HEseGdj6lHmO4OgR5pjfHpJH7meDMl0HE7j+/mVtsInAjFzkdP9X/PGj/MaM0Z8NFoLhlRJliHr/oUPpnlnyoPhOnz4Hu94KE6cPQLN/ZN8GHkuJwlUHaRQVLkU4SLORSzU0BsBEe4gN2GTyvc/fMXVopv1/XOjfW6p8BKRkls2cnWibc56GJG/bSke7VvkwFrryCV0Qyl7ECQC3Y6o3+fZj5PKlkM1pMLl9c6QQAsuMouQD1xtEjUmZFgNdDhooegGWukadaW7DW6lso/GLo1Regj1+uBqPQyyEXT/hNClO5/bQPZB3Qf37jGPveBS8FBOZQp9RrRVuXPNDl4b7QQVPvhjZ4fo/Id/e3NcT9tztAVfEA7Xq/AQXc3FaNGPh+FtpPpDKEC00ekWgptGwGIufkzAXPDUNTNaCRWmerNmUBhTIiO44fQR1HGfq2LxozfO0DQ4MUk/vm58EKX20E6UhCM+9RZpGolFvveItpy4pqkVWAbUqlStXFzZ98HeDWuESoVnofNcWJWECYnRciFgEyGhN4EeUJBnSBcGO4xl5Nc4uthrPqCM5vSq6FWQzbls96jtEcetUTwEh9/Mly3Rk3c+p0fSSWLCeK7pO2GsbsBnovHj7Fg8IbTJHpxjZptj5jSQxCN3wun8E7Z9wOv9NPCEWOQno/IprEpb/u7wPZTg3/ljRlIs8/XOQVbYc/y66rLS2V7R1HLc9PB+y+n98zGISBcCtjPRg3n54F17jDfSeKWb1Jl9mqYpU5xYFCMXbPmaUzC+K3IlqaOnR9jXAe8edPhaV94UBkWMWpxNHL0pfnf85vhnZ2sb1+3C9+pH7BuiI/cthKKnEPSwMKUup1yCyNL27D5orXHfd671ymu98FuffxzU9hLEqehensc8FbOXhIYnbMdFUpoMLtfwanoN0QDFM0+Wj8FJPUehDyiDkD+TgsgLo/gS176PC/fSuZfOPnZcOuod5w4WmJHooKTAtTTj1h3thjbj5T7wcsFKYUuCynTMDhdj4871BBdeF8Pwi6jrNAYfHKbvuOm/epfH7R/8g3/An/2zf5Zf/uVfRkT4e3/v7z383d35K3/lr/Dv/Dv/Dq+vr/zKr/wK//Sf/tOHfX7zN3+TP//n/zxff/01P/jBD/jP/rP/jG+++eY7nP7JEr0HE/6E3b+IxJIqP2WQFvV62Ok1VqX8yVwxUfvp4S61ifm/XKTnCjLzQ0cx4RlyPD3uxdiTKIx15UUrG4KMqKC3ZBn1yXIzaFNHc0w37fgZKh5hUAMODaVuIQMMk/V6EJZ9576FvBKJah5MwofbPAdoOgTzfqhKGMqqodQtqSsns+9So/gelf5+qsz3FFCVR9hleuLzXtEkocD8fY9XtGjngAknnX1CsgujhPfzPKzn/u7Yet5VvtzpASY8G7bTMD5Gz/HR8zGPr/Pj8+ezOi8U5wT5s/e71IbluHc+x8LjoR+v2RcDfyq7fLGdQ0hJyvt7m8wvmF+SV3cyunPhPh/TjJxHEcIEizfyySGqewJqHcSF6+XC6+XKVrd1jbMUYcpEPZRiPtzaOCe3KJO57YPeY071AWMYmFETcXCLaHCiGpYGlDvIDfQO5Q51B23pVLqzia2mkRP8DTWN6F/W82cbSjelW4moRy40vebrhV1f2fWVm7xy54W7XLlzYfeN3WvkwoZwn68O9w63fO0DmksaqcrRH3nLLuGPr35iFX4xxudYfH59x+2nNlyfPn3i3/v3/j3+x//xf3z37//df/ff8Tf+xt/gb/7Nv8mv/uqv8vHjR/7Un/pT3G63tc+f//N/nv/j//g/+J//5/+Z/+l/+p/4B//gH/AX/sJf+O5XMRfTZ4P1PE+eF6Cz0XpgHhrDO23sjDFSPXnQzeiTJODLXAFhNA7aNMtABO6lp3NMTzKlW2YBsiV+HBGLJ/U6jciIn8WVD1q4ItB7tEToRu8enR8GyBBueySIvRNRUZ+Gi4iFpFBEsW70vTNaQz0o65IQQsgYyYJQz3Wp0yKFdlrmMhJa8fOCNvc/eVlTi1CroBelXAqlgLBjPsCi6LjYHR13yrhHiwqfhNvJFcyi0nMJvrGo7txYBsp3gknWQDI5z+747l8UHJNEUbHz6nWYkgcbsSZejoV5T06G6LzcL+dgLsg5Zubpv1c3D3L8ezlEevrryRwKEbEuMsZxTQdtX07P9jDSYo/7H2PZU2oIZmLez4vRnEdT6UU0SxT8weAczpiHXNOKBv0h+jzEgqYLZ+tzZifLJRGPhfM2EtWIdh9hsPLmlpx+CqUWvvreBz5+/YFtK9SqlCpoCWfVpxU7PYBICx5GdQoyWzM+vTX2PaK13qHvjjXjRSslle77Pug3o98Nuxk+EYDPUN+cyxtstyBFlAbbgBeMojCV5VPnnoHSLF77UPau3Edht8JulV1e4qWvNPnArh+4l4/c9ANv8sobL/m6cGPjbhduo3DryqcufG7H61OD2wiSVzAGj9eMsBpbGMITTDg86rcOh4hHQ/XsRH3H7aeGCv/Mn/kz/Jk/82fe/Zu789f/+l/nv/qv/iv+o//oPwLgb//tv80v/uIv8vf+3t/jz/25P8c/+Sf/hL//9/8+/+gf/SP+6B/9owD8D//D/8B/+B/+h/z3//1/zy//8i//7k/myQt+eO+97UzZOu93JsE4QcbwEbJCSX/vFuoU0el4TjyJBW7K/cycjhxK6puE4rom/GRJtZ3amZZsO+sJvyVRRGwaiVjNigqvtfChFKp1WtsRi8jqPmnbHhJS+/0Ezw2iMLiBd6GWIHcUCvdb6glmq4TIXQWNVVNlw92O9iA17qH0WHl9DNp90JvlLS2nHFBKQ424hpItXcpV0UtBtxTRtQEjeiT5VqIRZ9+x/Z6iw/CSLeoeH/1c1nRNbmY0NckYdyKqSuMwZnRwdqflyRhNSFPSE1f5Ejp7YCEmgPIe9rcG2un47+323nv5ffEj/ns2gSKFmfeansFc8qOb9UB6iYh4GvPzOZyjsXy+okRrDovF2WuO7/kVLe/HtJuTXj9ZiMAqds7tSBt6pu59ceWyJSMONDZCqLUtzOE9H9Q82pqUUzNNayFyKxhig7oF6agP2DZBX5WyKT/4g1/zsX5g80q792C66og2PHdLEVoPFur0KCZMDmHUhVTVEPrv7Ay9BNx5F6w71oWvPly4WwvptDfwN5AeEa21o7Ow4UgD7aHTaRp0jK2G2LC64FZIETN2Nu5eEauoVppfKXah+EahYH5lmETdpkmwKW+Cvw265ROoSrcLOx3TxhhwHxe2/QXfr7RtozeldIVesLFh5WW6LESJw6yPjBzX4VJu6di8Y7BmLnkarnk/v+P2U0dcP2n75//8n/Nrv/Zr/Mqv/Mp67/vf/z5/7I/9Mf7hP/yHAPzDf/gP+cEPfrCMFsCv/MqvoKr86q/+6nf/8vcQk/feO/9+Nnwz+azJKci6juEhfDtOckez3YAnG/B4SAlvLL9YEY0Fe/beclgNFBdEePIkH3IceVyxUIJ+LYXiMTlDdy3aGHSmQPg0gmkIB5FonlETqSadkcNoI71YQUullJqtH47bc/aU/FzIPMILD6gxiyPzO9Yif77tQvTOuxTKVgIiLOkdyyQrSCpdh8EUN4r3BVQ89PxJt988VTKGHtHWhAI7S6Fjlbo+ROansGFCZfOZ9oxIThFLEGVOkegJUnzwlVZ0PS3l2Us6vPf57xnFOmEY/Kzq/jBm14FZoURaHJGHC1vckohwzmP0FKGu6O8YfzK/R06RHhl5nc41BF6PEo+SL02YS+SsZnII6k4Z3rMQ66RmWOa9zhd+KP2dleVPkLFnzy1rqOUYEU+2amW4oi+F69cbr7/wgn4Q/OqMq2FXZ+SLV5BXQT8UXr5XKB8KXCUbc57GyzL4Rr93+j4YO+jQMHi7UYYvgpNP9MIk9C2HRq1dEqesOSOZjDGWAmmZa4bLk3yth+jSmGuUOzElk5Q0s2dWohmnJdkqz6F70OWbV3av3K2yjwkZKvch3LrwNpRbvnZKwItcFoNwRVgTQvSK2zRacixkz47SNF7z9R23f63kjF/7tV8D4Bd/8Rcf3v/FX/zF9bdf+7Vf4w/+wT/4eBK18sMf/nDt87zd73fu9/v6949+9KP45QwTzW0WVj7fMHn6fW4niq8nlGeklFMWCJtFjsunlJFZRkqBaa8kfEIJiwYvEoy5jDYQCXjQSWaPLyOJHMwlOefrMi9VED6USjEDG7gZKrLGgUpEbxHAzJqppPXmIhvCmbnAWTR4tBRd1Vopk5Qwjhg+CCLptauncGuEAm7Ty7Sk7B+G+4gPIi4SASkBDcqWenNpuEzBVfFcdEoSG9STxivh5U2pT9Kri2sXzDQM1+5Bd58QYfYAWxHUCQ52Pz37ucOE7c7jJhmOMdz80Xu0+XzWEQ7bMt/wdwAAd/xkGMJuniKZNU7PA5m8AD/d37K07w5P4dygNA+XBmpem/j52ZxOME9I5rmonU7+0ThHHd3UzzzwTl/x1XHuq3zBsyNvtpU/9kravE/R1jGf8mm/2ccrxmYxmLCeAzKiprBojHNVQbcLvVVer8LlZePley/Yp4HtUcsoDqZRj0ldriYXBb/1yEndbfkMCyo2cPFoKns32h7FwMPAzVaRfdToxWCbELxYWZJp5g6atVndcIveYJGrKyDJ6POzDuB8no74IBN90eersGo01eNqCmm8LJVjtNBL9OZqZtERwhQbwmWAdkG68NKVWxe2Lly9hCABUcuVbTkZXh7knlYk9Rw4vAcVOv/vMVz/prb/9r/9b/mrf/WvvvOXvBsOMw+x+NtzkTKOOi042rbnogQ8RF4uHj2teqftSYXvjZ7U9RVlnRMU+UAEwgMVDfWJGmxC0ZmXsOUlmTvNovZqzIVISBLH6ZwAVeVSK1/VioydUO0kwv5h7DkA33Z4a45ltCHZnNKHUzxapG81+g51y2LhIkiN5SM03SQhw4QxnZTgYDHqos24cb/vjBaQi7pGtDYfS27BqJbAPrbIf+imyAVUOzstnqIKY2/cR6NZQ71Rs7/PyP8aSve6GkAOV0xqKiL4wSCcMCFPz13lqJ6Y+Z3z5FkiwGnw5qI+We3OymXqHAJL4um44EWTz4VkrTYPPta0pnFuMolCHJ73+m47TuXBGgFHgvYUPU7crwgUO7ozZ0PSmBt5L2YjrPn3C+GcFA7JqIQSfUZaeEJ9oVans9AQMM4JemU29Cg+xWcblZYRdD8ZqSPp8cgc7ad4Y6xpoUioqRC5nzJu0QRVFO5G2TYu2wv7ZWdsSt8qfIiKDukSJQmfHHsbjGqUjFpVlJcC5aa83Aq//SNPON2PBZd43v1ujLcG252XcuFH++DujY+1I00oo1AJhyyeVMyRVaMvHhZY07Ow/INGbdbskj4NVohl9YA0ZYAXZDREC/gtCFdlQ0rFxhbIvjvlFvls9XmXD7p9dwEreBfedsc3g+Zc7852EaQql6GUUlNx/4DnjcLOdtyX55zV6X59EXHB03z46bZ/rVDhL/3SLwHw67/+6w/v//qv//r62y/90i/xG7/xGw9/773zm7/5m2uf5+0v/+W/zO/8zu+s1//5f/6f+ZcZb55M+pQmMn7y67wdeAhg2NgZY2dYOxUJ25JkikX+WI+mSyupl6dZRDiJCNFaW5j5I7NgBbmnYGh6j/Lgsk/3N/pubapcVBdsiQjNYeQCNiOtMaWNMiKcUYf4UQhtFo0esYxfRMiqlfCeS17h5O0mGcVy0SYjObNocT490akaP7fItnjQ+1OFQ4vG7xKTz7OA080Zs9zAMh2drMH5EyIyWeKecqH3gjUNQ5WCudxZ0Zf0Yzx4/vr4zPMfMxoZsbAteajGYiSemYneJQzmmXlJMuc0nAEppBHwx15YkmMiBguLlXGuI1tEnjxNeXytavZ8Q6blS3JENn97JB2pLEdFopdhtIOpp9fp33LqqCxpH0XjeaiE4YkMTGRh6gnSLYtScERjZ5bkegx532fR7O6YQwABAABJREFUct5FZC2NCS3KZJweCpQRwQ029vx3o3iLFjYW0lB1u1KuH5DLK7eujCLRN05DlHbowOrg8r2Nr3/4wg//wCt2Vfy14B8q+pUiL0QZyHZ2AGJ876Pzed9jXKVx82QaVhEupxYynk6sbpFzo0oSWQ6z78mKEZFooKq6xqcaieh4OkvpSdlIId28ZwK1CKUqpQhljkV9dIzNZRGOu0UE1kYgMb0PWh+0YTSTdDNODEKPJz3z+48oBMec8Hd+/7Z1+KfY/rUarj/8h/8wv/RLv8T/8r/8L+u9H/3oR/zqr/4qf/yP/3EA/vgf/+P89m//Nv/b//a/rX3+1//1f8XM+GN/7I+9e9zr9crXX3/98IrtHcN1XqHOnsD55p1fcxPWzmYNsx75rYyOIic15Z1g0X9PPyQpuaqnkD3ZTlHMq/mSIzeztOrOJ3IKt4CqyqYlWnWb5eIrUZSbsEEs/Gm4ThiyjyP3NKEQt2hfMuGf+Ka4IZ7Gypft9PVXYEGcS3vwdOY+le3jSOunFIJFWKM+TCYP2S0NF7gNzHqowfuRz1jn5XG2Z2HP5hVriu8SFOM0Wr77YhKeKe8zOjrgwBlmzzHix895D7vgLWpdPGWjHhpNnsfWOUI7M1bPEc05FaVP/z5bqPNQeG+4Tvq3zGg+IcI51pQonJ3PMg3XZNjJ+dzOxivfk0oYubn/fJ1USzTT9Ice+GMeUh/G17yOOe6P23Vc7MNerEaT6wUHaJbf449GUjzaiUTPt0HdLmzXV8rllfuI/JDrKQ3AwNUoL4WXry58/PqKbQqXgrwo5VWRK7D5ala6IlIJBY1b79EziyMqn/nk2bYk2pKAlNnhO57VuaHnpOTjnjkuSb1Q1rUfUzL28+zR5WnExDPTVYQyS05SYo3Mu0rmXf1suDwkpUamRYJJbfRumUMrdC90D+ZgqL+XB2bqu0br/PpXBRA/xfZTQ4XffPMN/+yf/bP173/+z/85//v//r/zwx/+kD/0h/4Q/8V/8V/w3/w3/w1/5I/8Ef7wH/7D/Nf/9X/NL//yL/Mf/8f/MQD/7r/77/Kn//Sf5j//z/9z/ubf/Ju01viLf/Ev8uf+3J/76RiFwOMdmFOknBalE13wBLmsbd7Mk/l2CwZOG0JrUa/RxqDZIfO0+iJWyeQ/SaaKYsBSYpGWktJGOgcLmEXEZQc8/ZCmi2X8IEggwlW3oNhOodyc8W97aBEqzi1ZilOX0CYxwVIWRjdUr7gFVb43x8tU0UjwJVWqI68zjZgfkUJGX5aQJ5C1Z5wW4NBxRFiFu6UI5aVSLkmXIgxUc0vdtg79Dawj3hN+ioflefBZqb9z5cYLYyi2K3wS+Azy5shngm48ZZ3ihkbqLXNKGKGYYbAEdOdDmDDGvPd2HCNc1Pm3zDI9Qx0lPzQXibk9T+iJ7M1jP6/u04DFHeaLzcPzPj50Othkf04jWf2IoDY7DFW+fCPgwbMwdc1nlxGZqCN6REB1Ga2j1BSMqd2hT2d1OByFVPNk1vsBbKzMJY8yXnPf8006XHh3QHwNPTyK7ks203Qp6Hbl49c/4PW6cfutf8G+d/oYwba72SIx9aY026hyxeQzL6+CvAQZorkwKgd87MSir7AXQ2h85E40ZlXu3UI1RAXVgkRrcQxHi1JE2EQC5lZniIERjV5TtUPVqRIvSWdPLbAGYwMX3CLqNIvrFktjRaA9UjWasZZCqVFsPKbBIgxp88iB1cx5tx6vfRi3HhqG1wavKVqwxrNzlJG8M0SR09/nvDr/hP97Ddc//sf/mH//3//317//y//yvwTgP/1P/1P+1t/6W/ylv/SX+PTpE3/hL/wFfvu3f5s/8Sf+BH//7/99Xl5e1mf+zt/5O/zFv/gX+Q/+g/8AVeU/+U/+E/7G3/gb3+H0Z/HNGV5zlntr6dItob3T9mzAZtRiEl5GH4zeaG1n9L76ZZkYVlLef5JDymmCqSSTMPFsTTahz4LJjLaM9JLyRBZc4KfzCz35Fy1cAB+NINFO/TRb1fQzX2aTgj4h0wGkgSpEkWS0QYn81rw3Jb1xJrty5UMU20KWZuZK3IncXObaSHgMDqFgd5ldJ5ASZAypkgXLA9TwqoF/0BGLyv6S8RTpbU+/u2cFV6NiXfBdopjzsyNvYbz8TSLXNYcFGVOeIseVx5r3fjo5LqvW7QHe+OKZPA0lOf+U0+I/jVck5j0nsBiH+MX83AyyTu+vOFdzp5FOzYnBGGb9dALTaJ1hvy2jpwq++XFul9Pf5vslIrWHyEsD0j1HUkUHxQz1SZqwdT6z8ug4M13PYaxkcwjudibTcHy5EM37ua7yESZZDQ2dVdg897ZhXK+V148f+Pj193i5CFU722ul3nTWodATDhYr/H+/d2Wo8c3nT+y9E3Qo407HtmQpJslirhfgeDGGDt58rPYnn+93tst1+dG6aZAwLKj10cfPZnY3HBGL04o+b44UX2STIo5OR9znnT4YyWqGjGAIz4iLFMfWiXZ4RIBLsBTHCAYjnk60hSO895E9CDPiah2rA/OBUr+MoJ7hgPz+BwfwvO/Mcf3fSc74k3/yTx5e9jubiPDX/tpf46/9tb/2rfv88Ic/5O/+3b/70371O9u8GzOcOmMw+f5zm4nH8X9s0+k2kp2Xea1FgZ8RVw6byQKc3rPN65+elqxwP/4wq/IPNqGnmvzyPtcC5kw6qUqQKqpENBjRVnyiSETqIKkTOOEGOJQqWLCliAQpw2If9clsk4PJqODqj/mRIkeeRmakmLBG5mqkCJPV73m9E7yfRJWIPnOWqsesZGRB6oR+kk7NrPBhLYfmAUZZlygovoPPflrZW8unWsZZymmx8zjkj957DTme5TJqfoyV+SznqvxgtEg2ni+/KRiYx/4TYpQ53k6HfD7ejHxT8H0VLJ8u5SFIW3BgYeUUHyDKMzT4YNz8ESackGLur2Kh2j7zVpLGy4+etzIHWkaisXhaxlHnZxi5uNkOozCIpfAZEDwmp89ndr7apRs4729G0znHzCOyuV43Xq4XNMfc5WVDe8Fbj+GRy4dY5I9vNhgtun97arSN4uEAnMdD5jXdw3B5MZrYov93G1QC7tOilC1KPObYi44NFoZ7lhmcIOwpHix4RFBPvtc0XOALntdUEAluWsw9mTm1QjIcg5SCPwD5CRn6Yk9PlaCADLN2ta+amuPWf5vhktN7773+n4i4/t+1PSQYeIy88u8zRJhq6+8ZrfxsRBKGjR7MwmGrvcnsk7Vy8Qqu6S2JZk5cI6F6HjRBLYtBha2BNhIqdJeYcDIXvnjqIgQxTIVLVWqB4S3yFwK4c62a+SpnHxZ03JMBxo4820zm930wQo13KXxM2EmKZq8fZzUfrOG1LeNFtnsZlq5BQhk1c0HzEZS0W1l0XLYSihkl2qC7OrYMVwfrWbN1JODDK5xLY4JUvgX5InUIZeoQvjncfGkn0mcuLYbDkqBZj/tkhHJciAmzC/GEDGeLkLnrnJUz2Q3p8U/DM2G5i4dRyIhfCqlEL5kfiwU+ekjJOqVgrOYYVkGyXm5hL1nuEbZQjqFe/DHSmr9fjvekSvztBbgSxIwtoi9fyftjGkmNouHKoEowACdBIs531mKd706SN5yMWdIYyRGHOSURgHBWZtZqXrcga5E+GzRH1xGXkcTD6ZFjXzNHi7C9VK5boflguPCDj68wbgGFWRTQM0It5tOnBsXZcF6qs70WfFPUSmgfTUOFHxAYIwuync5OIUSFO6GhuBVF5QLaYYB2p/fBbs6eCVclqOnHoh66jO4j0w8llW6gyCnnJwfu5j6YkmuzYATJcpMaEVfxUBWpLRCaOeYs77n6GY3JiKt1eu/0NrCabYz0tNael99phCZOfCZrnA3Wv010+G/f5p2ALwzW3Fx5YH59q+HK3d1WUnL0IDxEhJLwoBxQjQgr3zX7G4sQZIyspVkTylnwoNs8v+lGz4hrGrCIFAvK6+XCpUBVA7NI1pJeZa5b7nGeQUhSJPjqsY4mRXhSWcfICE8JOMRzAZyhY/a74kyhLhlJaHiTs7HLvO0pfI2UXMZycGtVSi3US0VVU3bHMS2hhM9AbI/i0VXKOAHBntN6euwn4zMXjtmy5Fx0fNYfXFHM4SlGlHNa8Oe7TlKeTwZujpkVps34FFYkf7JZMy90ziGdMUCZIXKLertwetJ5gayHIkNaiVfxQ++xy4qk5ymsMTif1ZUwRjN3NckEFw4jdp37ceyXn49bExdexB6YgsHcO4gTMQfSAJ9v50P4eJ5yksvql8nmo7j4IGW8tx1RmR3PJSOyOYoB3j6/If/C2e+Dl5crL9eNwsZteIhK20ikIHKwP3q7oRdBKry5c7/f8Q5W80rWojvDa6LYXxwjDKM1D3k2JNmByvVSgvTg0d24qdNLSMdB9BSLOspZm+eZ5zUqxlWMTaG5U32wGUSLn0I3BRugA6wh3hAPd6GoELqJRrlMt69jPVTePdMMYuGQj6xrK+70EYpBlz5ou9FujVEaTj1oA/PxPBufCXydE53P/LmfsP7+brefA8N1jjfPhusUrz6ESk+v3GaDu0MZIwb3SCFcTwHZVc0p58k62V1kuudgfMXX+4qEjtcR2h8nQXr56XdK1G/VTLjayolNlh2nurD5J8912pkQoE6oMD75cLeWd2tz4faEBGVhEwnArLbmE66cSCykaLAc74uCVE2VjNnOJYzVXGidgUxCxtIinPmUsPSGZO5A1r07R0kB9fgJ9uHxOT+uobHguE/zc4yPb3uR9xSWp79wmyzUPZjovgy+Fxb12IkFchnRGVQ9JLvWyR3Xd9ZLnH7ZJJWk0TrgXI46rBlxZVTlVSL6uxD5rZn7mky5GmSA1ZFAJtznFI5eTufb6BIR7cwhzoT/4v7J6caveykgluN73lNWTD1hyMNN8WOgzkN43reT0ZJ0LiQfj+OM3rnfdrZr5+VyRV24ve30PnPVyXYlYW/xjJyVTup3qHCpF7q3df4lL2s1xnbWnPBhaBcuZVsTXSQYfsMTzVHHyhzIkszNkGIbxZY2YozRiG43GYuo0RGEns6C4N7BCmodtYZajbIAHFJ/cVMLWSuN6+6SwsTngZ7XMcyTXRjEtNFG9CXskds/3eTTQ3kcwj9xPp1f//ZChefV5SiCPO5IznTXg6gwJCb4s+WfAz7rpMaw6L+VdUWWgrjRCZXHD8uJVCce0UVQ2XJQpwitL18nqPXnhTgnZBSyenhhUrheanZdnxqHlmtaeEzdnDamYTxJSM01Vlg1Q5LXiLNyb3MNnq1PXOLzszbLmfVaceaDk5BuiVyiezR7BA4yZwkRXd1KdFROum73gZWSUdqeXmJj6U9L1AWllgJ6Su47EXH4hPbe0UTzU35qLbR6mKnn0bOMnz/9Pm+On8fYzKWwop3JwJs5pZkb8sJi24MngWcuxMfK5zq/Y66Ip6+zvKFpxCRlgdw8HSNOhsujWPhCRFyVgAQvJDlDAhKc+1zzvS2M1hIuZiy2XqCHh7zWvKPhuMgyvDNGOoCquR8Pn5tGalLZDwDwXNI6Jms7Hh1+yu2cnuLDwjnHe4CJDtgYtL3BiP5bivLbv/VbXKyt3JSVUF4Rg68uIJsyijJ6tv65Vl4+XLm3G711cLgmh/Ke64kTrRU399AE7cq1KGqO+wCUUqJLcnQ8H8c4SLp6UeVahVahq0VRcA5G9cFFOk1mAQIYQqUjbgyL1ESxjTL2JfO0+TXusQ6u2ZwVZr+/rK/0YIJO5RdPg9UGIRrcgnjSd6NdB1vpXMQIEPjpOZy35WDxvrEap9+/4/Yzbrje2967U3LcyDOFc75XCJzYOtbHKoTt1qEPbETktaq4viCnxORUlIqm0jpZO2hEEZDj3hnjjo0WIb4n0wgS4kvDtcL2WHu0d9wbtPCKVs2yBa39vnt0bh0cKvXE4uYS9FvMaCkVBaFcH0rXSf0b4C09MY1jTRgIorZqYOzWImlf5IH3YhyLt25QXwr1WqiX6IArPa9ZQV6EgnPdd4wdzbLGmsrvkiBhPxD7I7Y+G6TlxbMivTMv5znSWq8zVX1wEGxmZLPgODkdECC046RYjBk9rtkLmTPigFN0neSKYs8J+BWZPBiGucg7+CnOGb7yY2IPux4wX6pdnCOuBQ/OnxW4ekRcJXQG475P4xF0TPEgZtTTKvNclXVE7wdNY57YES/NcgvhqP2axcuNKH04Pk0+7eMIyqQvafIQQREqfjJ2PqMbCZKQuCE+KCV6UI3RaO2Oeg8WnhLOVsK0d2t8JcZXVYiAybC9cTfH7yC74rvRMipeJRVkeYjB2KOTsF7yKtxpfefl+orWjZ7R1hSfdss5pmFwg4gnSRzpIA3RPRpLSsFVkHFL3m1BGHRTXDyJF0oxy5KzyNcNBq4N1UEpBnRcYi6PvL+Wd3SkuDLdaHuna/QeHFvHavQg9DI4dDHf2c7zaC4M57X2NCV+L9vPkeF6BxMCHozYGS58ImpMJfQohD2J6ea0mV5+OPPTgB3r5dQYmziCaC4wGp5XGMaBe89/LwsTZz6ymC8X1RjIwuYC06CMPPUJaw7BGtnlmAWVeVKmQ+x0LiSBszsxSVQJuj4c0WhhRStMGNOD3n80LZnRVvA9xsIGWIWrchHKq0bEdZEkcBiMgahTuCPeUHbEz0oLUf1/qGScW0ZOhujp+wRWx+QJlw0/Gj/OMXAyWos8wgFXPXt/J4c3nqsFrW9FUFmYuyDBIovNN42nnIzj2QZO73YxBZ/m/1R6mgZ5xjThdGXxs/naN8J9P5iAJ8PlWUS8zq16FhazoM0ik+Z+PIPlHLgtAsax1swLsNM7kqbrMHHHE/A5EY7ISk6Suitn5vHs17XH98wZIhDSYetbSCoEyDJnYQi2UlL02VDboVc8qSJ4jP/LZeOmoJtwKZX/z9cbVSMfPt46Wh0tULpRGlno7oePMRfiHFOWMLu7cW+Dl2vA865QaxSx6MytJjjkw1OIf9Am3OiZn7aBahBiNjGGeLoQnjmukfftHkuZB0SoXlHv1GD9UMTYZbBJSLxVdWo2wF3+mcNIklZ0bPbUIHVGTWb1EtO2ZAa/M3gfBvJ6TF/GEQ/R8nfbfsYN19lYnd3p83vvGK5TGDsXhdVIzk+Gy0OAc3nJMweUEJLMhZ3ZIelgRC0cX5wQxY2Ox6G+MftvzVbs6UkPUhoqCB7Flc1gthI/oMe4ot6d0Vg1QrOKXTxzFkkOYSJqbmmI8viadHxnyk0vo5VzPM5PNb87zzdvs5bjIyLTaIFchfoilAtohTIvbvRAtWxHbMdtRzgKjs9J+UMHPKjTU/tuagIuA6T+SAWvB8x0RuCAg2VYmHd9wRqP9bzyNLkkouCToTxgQXmACHPXsOriUc/2NFQFDkh4Wqf8sqh9y4PMiG1au2xVIyOOLfMQehivs7KDPBmupTuY0dmjJuDJcC2OfpAxYNEh0qidLb0k7DTdI0njG7PiKEmeT/CABwtTqDcdFmaUJUlYmSYzM7YyxQWMADIH04MoiYcIAfNZdlZV3/FecGrMiREm7ONlgy3aDn113fiD379w35VPn2H/9MZlc0oVtmpsTbIEQ1enhXOQLBozGgcz+Lx3XrxQVBgZwVUkemxlNOLKWgGGw+6eTbPj4FP5vtK5MJKrE+N3eJQRBLswe3X5ltFkR2xQvGcaNQzVUMPU2Aq0EZDgXKsMGCnEq0k48Z7pkh5kjTHScA17XGqPofu+IXrPeJ2N2Hfcfg4M17Oh0tPrKeqaN+ss2ZMfsaxXaG1ks8jZdmRq+M3RmoczfYze5lLrlRDGBBOjiEfRctJXLdukhD7vmRE54phdoQibVa5W0QajWWiRKTDCGFWE++7B+tltGbdzi5RZR+UukXTt50jFoNi6Buuy2IGUiOKCIwtWMqGdNGM0E9mFXGAy0f2ilAvUK3woqWrmzpWOagNGdG/tn/G+Y8kmPBiFx+J1Fg46dBpOMyW/P0RiPUZyzyuveQvk8T6sa59/d1myWASK8ujrJEro+b6cDeRkEKbxPNdKeWF6LrFI5ZiR08RekZWf/zFPkGNxCJbA8u6pCeOuA4VBXoZ8ql4sWrufzjuM4dTUnADfbLZ+lCGsE0vo9rgd8+RSp3xFWNO8jYyDNPeId+0UlR2STbKIH6z351FmLDW/O3zFo9y5RAyDrX0Crus4uifVXJ0qgveQcKtAHWHbXwX+0P/v+2wl0Icf/ebON2/wzRv4p4bXgVehXYwCvErBauVzj/ZGjL6ea/h5howwbPfWKD/8wOvlQvmqMjRyx9et8FkF253eDNco5BcDm6Uk6/FPHcaGUCjiq21M95gTiqEGHaObInahWFL4Z8pB4FKjm8VIZ1O1hLEdJEhcMBdKT1KOO+Pu9JIMyN1pl0HfUlrqd7M9R1fPOa/f4/YzbrgWJeL00m95Hw7jJYfhSpvh2SByJIliZE4n8uMx8MLjnMYrF+xlCwqzkeJiFIqAj1M0d4Qx7meoJXDuoKfGIlZEqArVO27xiqBLVxBwb87enL508w7jKjrZhGEg3SJXNxdLMxhj6dIHa28Qq2vjUARPSZop8aQpEhvInaMqIdtUDDanVONFOx+Kc1HjIs6rNtwa5oNm0PzOIKLPSbMuEounrIWz4KdlbdVSKRwK5xnpTNZcPyJWjKizE3ICH4ZkroY+o+fM8cG8j2lkfH5GTkNLDqN0Ot4ia+gKAtbfBD8lpOUwYqdgijzk+sw0kLDYe7PGTCaj8TQej3/OA+YxV25hElSmGTj6YZ0Nx8wxxieOejryEzNAnIXGYTIOioWm9ZwA47nr1uOaNU3TNGJHfD2ZhdEBWE6fOGDFwygeRjPBCcYwaok6qqJEhGZCVecHr4WvVPl6K1R3bp86v/Op8elHnbZHF2PZnWaD3aCn5FIR4XItbFW53zufvzEYdpCC5rM1wTxUOcydly3EAToexCQ1bIuofbY68RFzSWLYR27coLgBLZTr3UECremidNd1Z2LIVDyhQlLzkxIQgGadqeh0OpNdCOGyWKwpqnOtS0LWsFgXJ2Et0yczsl3bt0VQ50Dhed/fj7jeM1znn+dbbDzUdeXAQcPr9hG5pPlwLB9wpFZO7sPitB/ncdRxyXE2MheSE+42F0ROugJymtL5a5FUDfKOZV7MjCVvg8Dew2jZuagvFxMVzXoyWcofmAXckm6ijYAUw5WWjPgIiCknlAxfkIYLqbYRq5dJTjKFUUCKU3TwIjsfdHBV4yKDj7rTpdF9oAPEB92NwZOUEEFYmdNiKsc/PMvT45XnaKeyDMNB6z8Nh+Sh5Lr9fgHktCImRzpF+XJ4CY/nw9M+M480/5Dw6/ruabSMByOWrIjjmRDXKDl8H75n/n7yYBdLPI1WDNtTbobDdMXHZz40FspH+nvIPU3jOp+7+mPdlYlgCeeSNI8we8fNOUwO69+PrMJHduE0qLOxpK9z9YwYZ/HxyYTltB5uVMnODBiTm3pV4fsvla9UeXXhdhv8+MeNf/kvb9xvvroqaI/IbQC+wZZKOJerIl7AjM9wiC1nq59I/cRcaT3qQUWi39xwj0LoRCu8aOTEluHKMZDPVhyKGeINz4S5MDAZFI8O5vOORN3YhnlDbFtJb/dwJM6OtMt8XtFOadjhFM4BNA2XpcLHkrtLSbnp/z8ImLwXSZ0NlP+E/b7D9nNguPT0+3ydV6ynbd7I9vTRBt6IJoyeJApa1j4kGHLWZZlPzyPW0vRsgldYDtHnuex7YuDeg+mTT2/xxjwU+cK4Voo6pQ6chnHPY2g0bzQN2uodrPuhrmDHSCka3YxFfOXsZlhQJJK2D4Z4OPiGlLJa08sgCJHdlhGnCvUiWaMUtOKZR7mw88LOB7nxfR28sHP1nY/jjbsZO84d2FxpDncPmErkAATnUnYUmh4UPRFdXqlPSaWNWDy2fK6zpgvivOYQmX3Y5pCYhuvoT3rci8M3OMbMjDbO9WszQX0O8s/1VOXp81OGajIDjVDrONODz8bPOHJU07poGJD1/RJjcDktHsdcF/A0w6ejdBinGX311apkUuAfi4KD1hNPwii0RaIxFJMeauFsKxrqFA7axlTZfGQfzi2ivaWPgpNUdcb6/Hxwj3HYvKoj82YiaC3UrbLfG199vPDVy8YvfXzlaxy7G//Xv+j8xr98o90db1CHMEY4gmPMYwivm8I1OnazpYoGI8bZLHZvAnt+u4Bs8OmbeyAQ3xfspWBiNAbDCt0qbcT9KDKopVOko3Yy7Q7YoNg9SkQy315k0BDayh8K4pqM5R1KRe0CFgbPSj2GrypIjeaZCh2FdiLjCHiNSxvWGNboVhmjYf9/9v4dZrZtu+tFf631Pqq+Odfa22bD9bF9RcAjIQACkBAZYAQ2EgF2YskBL0FERIAEGQKJhAgCyBABxIQgJGSRWAiQuCScwBb3XqGLLweb/Vhrzq9q9N7bCVprvfeqOZe9X4ejtTdjrZpfffVVjRqjP9rz3/6tn941A/caSyILn72n3YtKxZ738z16WfvxA6C4doc5Td1dkqR637L6Kdx6xj0M7gM7O6OvGLIRFEhphbA4BhcX4LqG9LIkCOVkM38t2ijY9NaeZzCBD0ItNtE/Y9xZDK0CEedvJh6OyDYmfnPTAu0EqgqNmi9/PTsxuyAcsfYCUWkFG+JtyDsQbeRHH4sGqoNQUBGa3UnGfClwkcYbOflE73wiN17GK9fxnuP8HBXhYsJh8I5L2MDjQThmd9Ue4m6Gf7Z7k1QUU3kRSmt50b6f0xOT+d6JOUiPLOv6jCkwJqAj3yfxPcZDuDFbh/h7NSzV/Hv8LA53zwJvRrJusBRnC8t9hvTWMt6R8lK2y0rlSFjSfbvYsXlU09oVL1hNPYcGWtDve89vlWlEJImuIwtzYFxvDyr3CahImtxVCeYZqAnW2PaHX1Lsj6nGnPV8QeTTCfCrS8/qMQGQQt5d4kEWNguDwXEcfPr2hRc1rgqlN9rrnXcdxqvx+joYTSM37Dnudno374JSiyuroxaoSjmE6yF847PG7d49WtFxxpabMe4yadoQeL2d8N54864witIPoxSh9YPbUG7mfmXl5CKF66V754fw2jAchHMDC/YUNUHvBBCl80ZxbwwYdkG4Y3bAOJkwaMxnVgiWDyEYx2YniQyNW5R4mC1P0J23YKAPBvnrQ23j9nQ8vvzB688e2v8KFcKjssrneTyNphmrsBNmY8Tu4bNhlvudDSL4eDrLN6TC8muZVfwpOcx/7r12HiuP0zpONFcUhKoHWsyymVRYV3iB6DD1kGYU5E6IPrYxdvh3J6muf4+/x9J7kHUtFqFUS28rwoijedW91VTC5gz3JC7Sr/nQxkVPXvTkhRsvvOc63lH6tzD1oKAYtECFpXDbH+DqbA3fztkQGLOclyewhJW491wGG8s5ZTqca96TRd6ehL3IrAvai4hnREU+8sjXP5ZencXeuzUtU5nN/GSChXJd9Xy7uDJ8khcfLHFbU7wHBh5AIQ+Xa1NxrXBtGhN9yzKmulnhvTq7F7tgTCXiPX93hOBa5zL/3Ycx/S//Tt1gowm7kA/ev87twxUDnYrZHHp+qconh6LWkD7ot8btLvRX4/Vms6WJdWjdwQrW8caL6ryjyWDjERTjfnbONmYtliTt2CkL2Vmh3TvnHe63hr3xFihDjDYO2lBOU+cMxChimOrcyzOtEKQAOYcyBGmx9MWol0a1k06hWGN4Js1BX1luYw5lSWM1A7HD8BxD5uiinnTShw2mfBlB4D0yjTJi780E7eZ5PSuu58fz69/l8SVXXM8xmvy5K65drW8jFgwaNgzaoEXnz9471puHCjUkeNDBiChiHiaYvHb414osQ9u798qc2Jz4bEr5IGSYUWp/UQZakv7GIOCtaVlOYWG6pc12E8YiouTJc/PUlocqVZC8nwy3WF/CIxVYM8Y9zql4qLB0hpov8ru5cH/x7xbpXLl7bqvc+bTeecvnfGKf8cY+Q+SbDFO6CaUbrb8FOxA5pjDKw+loHtXZ9MlkicKpJFJpVVuhQsMFyGHeVyyLb3cnvIkLG8NrnE6we/w9vNihuzLzh808mc3XdjJfn1RZy41Hz2nfvBJKy0JpSSguyftrc3n5SYJtXrLm7vmYObAYg+DWs+Q9tBFKbHm67ukEkS5OdKzZSTeKg4WxfalDtS+c0xNLCIZBKLT04Dy8FatkrvdChigl1jRT2W3DFj9lWyPLGwQX3mv1SGqtMMBO1Ar/j0+/yutnRrsNztY43xn3V+Nb3xxYi754zfe+DEfcVS2rAWTzfTG6cTsbn79v3F+H57XuIHdDTpDTZcQIsuNx75yvxuvtRO+Fcwzeyxkl15VuNewXY4hjO5MWzSJ0b2H0MgYSUHVpwS+qg6qdWk66KIU7FuE9Gx36CVq8YJ7KrIHUKDUwQ3r3MHWPcctUgxh2CWN+dPo5/NHGJB539haW2NkfOYH77895ru/x+JIrri8webP6U3DpM0cqYYSbYIkk/JgCHpI6qT9Im7G8G8Nh6SN6CksIIS/dp9T1LWfms2zMwmNjTKsmt7BvQW/ZXYpGF2VnfC8B+CgIQ5UxhGYjenDlWOQ9+jVk52WnOwpvzDo55RKewBga1+REvKkcXLmFJaYgRb0gs5bgdfTQKdUo1bjInU/qjU/LK5/qOz7lM77CN3nLZ5y301GMZlRxo+Dg4MYFV7HLsxIujBCQNkVrpZt6Zf+8TXnwuqTgTRFzPKohO6ls5pzS40pCXjHPc+2KYPN66OmxuGC0BSNdy87i/UM8BhPaTvZ1Ft2TZ5wGV4K6u0OptPadned+enkKAyQW7/a3NKh0e5/FmClQhMLgoHOhUydrSZuKJyHrC+mZZEMe0j0m/XdmcSUyWmMSJFdOz6PE2dIMIbyrCFrFK6sM2pGMqeiYHIoStZO+y/OGM/O2wB0Hndtn7/jvr6/wjc4bEy4oxQ7G+057hfHOOERnelcolOq1jVIKfYA0uAhchrO6f/0bd/q3hncheAWJhqWWRgdBXNsUa4qdyvkevvIjHpJ8342X4z0qhYPKjQuHGIcYindR9vAs0yP34JCvLemC3t2YyJZKl5cGopzcGZGoH+OOjeYeVXEYhjECkVwdFCyZRg2TI5SkDUdg2mnOCJ8RqNEYo0Ffda25P57s5sff19L5MJT4PRw/QIpre2zhmakVgIc4zoPQCas34OTZviBsN2aRbk5uKrxw6xM04JDTR3txhQXjaVimy21IpWXzmrNweBLg7gESE8yco9C285KLb11I/G2toBVeiZ/JqmEyCz5hycm8B43eRFbWuBi2Cll1BMdg40LjIidXbhz9Trnf6TdiwRuqjUu5gXZEetjfy/4fJrQt3JSTuGwI265TAjZuaSguOPnGIiFXkKs5Ok9gDFkgiggVynNNV4Z9lgyNuXlcNz7Gks7yI1JRtvclY32PAY572fXwfvL5ei6fQabStjnfv+jxRYl18lFLV1KV7PyAgz3ElwCIWRgc3kCGFmVbT57H282PZ4TguqP9e+ZatHg271/WNt4uPlk38vyxCEjg1M4AYufgfgrvzhtHvXAthSLKeeuMm1GGt/3Iq5hF+cUNolK8lVBVOF87r/fG62cdu7mHlV65y4FtgtxGDaY39/QOK4gJxzix09netfgWrSIcWBBFWzSG9Fu2XO9mi1wg51NdYapFqNe6R4Pmw8OE2e9L03N1W9aRmZLrMNYvRmIARkQZR3THGBG2HEEb99CT0b7NB9vP7/H4kiuuPMLTmuY3j/H/kbGaHUaYR8SV+8B6x9oyIZyDTKZgcisiFlkIoZn+EpDDm8llUSSWdV4rA5XnsLGFhObl+C+uCDXgtX4znteSqL/CYfA2MHu8F5dKTh9hEGHPUFwCKVl9QTvUzkxDefnNSIUEGwwxVCvUjtVBS5oqEaSCJpCEwWGhuKzxwo16u2Pf6tg7jcarTl1zvL2jx0nRk2i5xxAPWhnQ0ZnmXxa6beNl3gfJcNDFPo5piB8sT+sN6CWaIMrgzuGF3gehuDYhn61D4ntSmSwUaIz0blFKKi1zHE3O+5ZLndDpPaQS8kVCcG9LYN6Lyfb+uE5PTW7raa6BlHZLkVpc11Jgu4IZiHTK1sRzN403PRc/FxkvJPnu47ErpCwsT0pdX8n525hK6yH3F08SAL+W9aYMzddbvnMAYqtMvdqJdGE05bx37KqUo3IthXfvT8bNyXLJvTrr9OKnDd4ewsuLYtr5//2PO5+9Oz1EuLfOaUuR7MFQujkh8gn3d41LPzjUaDb4+vs7WuFyaby8NES9i5cEFP+RwQaXFVisL6dlylSFRWmJms4xzYXlZAjB14jNqHqVaIckvocfxEcs7JnXirzfaIPRcdRlcLmWUqNGLh4PJTlrOX4/vaz9+AFQXJuVtsy0R4WQm/95J8ZhsDofmzdTc/g460PJ3N6FJDyVLmTSQ6rXbKgMRFMhCJ0Ra3H3mNYFSIYGgsFdFV5q4VChaAA2Ih5uKOdQ7sHgnBRMCLPZoIhwBJmgoyA9VJBhNUMI85LU8G541WWOFXB+mhAuOvyzqfcT9aa+ciUElHtad164cW0n5Q68P7DPRnSU9poWA/RqXK8nJt3DkyKcFLyxoHDl5JgAAZZw2eZTEuKeEdDdm6lgb0EunsR+y/vpWdy5cK8Hp16wq6y1cbJSpDBDNcjydKaislQKvkYsjAwxR2JaGXCHbEQ5MQfkNdpaWpvScoNHw4AfmwBjenOmeN4q17jl9eVrm+f8bMTFLyJZcLz4AW0z7FJNDykQOS9XRTm8zrOHQQvjI0OjJS42zY0S6s4LjNukMSqBJpRtc+r89gSORL6WRD8ubstcDg7mWd6jdIE72N24n4P+psFL5dNP3/BZV3r3cR1mUL2LQdZfIfDVTwujd77x+cmvfvM95+lCXBp+3mbQVihYVOZ0zjpBC66/98b1hJfjwifXg89+7X9gapSLYicOsxdhjIJ1WZ7ScBShL2lHsCp4rmsUysB7emVeN1IPvmYlWuKF0hMeyV3EtzeRr52RaMvv8g1mIT+c7ccjFdO5TONuDwF+O96VPr3nuzy+5IpLPvyZltNj6QcrDPN0GAH3HLN9dbalnyHDQOVZWhVdomA5zqlGZtbNPHKcwmi20w5rd3peU9HadmluCmVOyy33zd61CPBYp3+MekWWnJprx7INiXsPc2Ox5/TAa4PCFIsNLFHA7Oj9QDhp3geRe3BLvejgUKNqJPptcIgi9eDWb8gZIRBRuI91+2XExheqeIO8GvVEVfoUVNk/11RWiDA3wI4uDE7HJJqV4l6CWnTwxYKlo9Bl0Et5QB4+FDO3HEMeQoDCHKLpeT04zXld87nFeULQ5evk+2zbx7EmYi08zvLmmWycUQ8rW7ZFkNM5LzqF1A59mSeMZzpX78xJJWIWN9Q8pxWkTnEvK0dJnKEH1lAZCasHVLa+a/ZINbU6A+xWZnhvtsKMU0HFIEtMTiq4jGi4lzC43Tqv1ujXO4w+96SoBpuEhzoPAZHBu5t/5nZ2zrMzuoRnnMZGur0uZyzmw6YFkRvMQU7nq/H2WvjRl4NjfMOp14KlZhSDZM0hTxt57/i+WWYRXtL8TiQwF26s2YPcSo/WZhBKcD6aEvbpNHLCKpvk0qn0bEzvy2ZfQj+nJLLw+bCPPH92Jp7F9ndxfMkV135so7CDCvfBeva4Yh3ORpEjmyWylFcu9ETSRMjHO5VIyI8VtvCfGRhZK2EtqhQeGXlOGWRkj6USG4lhQfXiwmggK1w4VnDC72tZzklsarl799WUcHhzIPMIC23mWMJhyYUt4lZW9gLzFWPzXLulexRPNB8MjjG4iDpFVLujWdRsCrfMzwnUAcWQ4pQ8XQuHZNfdMzgMO40+GQcGMjc1EKzwrHAFtlp4aNIY5WMh2GYxcXpZm+KSrA/DPFmdNVhEAl5ClFtCmJcaELElBTZds9bnk9EhDytlGRdPiieBYftS3w2RuRx2sO32HcQ6IwwOBzuY13RFDHJEiNqmKkoLIaDhU2UJuQJ39Zqeke+KHiOmLAbDpbgqiWb0HmxV+kQ05misNc1DLq4GMaV7ObJuMQSrDTc0xxjc751XOzlvN78mcfvmqBL0NP65EqHk//bZyfubw94z7zNzjdu6SYWTA53h2yleDOw03r8ffPVT5Ueub7lSsdbp9xhv9eaSiIfxMuqyPJNUhuk9SabSoo5QyC4Ku/kxFUzOo/ijxGxoGKZTTGl+MpZtyEMs5OFI+RiGwbfjNe3r8mOPjym+b/P4kiuu/e6/g5F4GnD3plI5yUZWG0wOXko+ecXS+vbSK4MSMeQAVeiEqIUCi0WfnpbYo627NqezbxxVqJq5BN9oZhJcf8o58GZz24Y1a2RMwC3mDMFkvNuVRtK/TIj2w2i6RPYiRAmvYtG92PAwgw1X3MOc7DcZvqt0Dm1UObm9O7l942R8Y9BflYsEl+PZsfcsJXORzeMR9DIo6ii3I0OQ3GO7DVJVGuo9ig5XKlkkPGVeIcoK/CaHeDgLjMYRSMUyx0DUr8EuLCvUpWUoAVvWqLHWWoRM0jGevbI0Trorlvhs1p6nce46PLwaYVFZBQIwheSDR5gF1SKJUme6gc9VIjuRjCxgRom6qaXjXAX1uR6Z6ilrtZQsB1+GWea+EhLvXbM6EhmuIcoIBvc0dA5uHNw5OLlw48pr9GRr21m9NHnHHB6ZY0tDSMDqilok2bAUkEM8r1pgXAuXTy98ondKM973gl41nKbOu9vJN943Xl8bt/uYOaAZSs/bPfwX6eaApazBO1mjJmufyxh841uv/OiPvOXTT97wE1/7Eb7+jVe+9fmN8/VGxxlRVWoYUOKIWI29pswbFVE3qHKSa6dpCdMu1Lpb4uFo+fo3OkWcnV5VYkmJA0RqeHY7FB5f336qAGT0VGQTw/bx4yPG0lyTuT/zuXzw6W/7+AFQXPBgXj5bmvvxEY8LbIUAYkI8N7pyUVmniy1IPD2t69zua5bEEnpKgDuIEy/FKttFWP4uioinUhM9mKa4DQv4+yr+9WveLPu4lhH5CyfXDUkuca+pMkUemJ6TRmgakOJX1s3rOYzwTsb6ztFsFiWrZosKC9KKsALFx7dFnmC0vhLCOVdj2daMBQAotoWVxOF/wxxW7YwdYU9G+BCLjY44AXBY0J5rXMmrZtWDhvOGw+sN5TWVUyqYDUwxUV1m4VfknLuVOjPfsOwo2xdeaiqL/3W+TyKsMzd6YVNg4H3AbL2eod3d/I28xX6eyRwfCjk9k4nOC09hKqO5pPyJQ4VceXg+KZVZsMSLTfRhCYE3kYiW62BMPy3bddRoILo/qrS591IlrmdeYyZeW+GgKwkC5VTOsPK0gTiVQ+AQPsN4LUoT47gopl6X9No637qdnOfwvNFGLOBrI+YgPC8fr7RUcp1seS58LVkoPzWoohxH5bd89Sucd+P9u5N2KhqcgkS+zUqALrLuMOJ66R1ZTq4YHIMhx1RaPYqazaDkxQxX4sSelzBcipq/rkS4lGhuGumMuaTcU7Pw4kZ0zZhh0Wd0x8cU1wbmnn+Xp/d+h8eXXHHlsS0ieXzp4djlh22v7YIkN3EqhbTIbXtbLoj82odJkCX4JG3Q/NLdI9yTNLkRXHElijBzT+DX1aNuy8OYm+KLNepCJFWTuzQ2qV9g5U6exg1h5lPmn6OWrXtthwgQvHoJOJgIqBJpxe3UGiEM/07v7dPvw/NkxZankHPhdACBIUkEWY/Qhgs6v7yV0zFL3o78rlTN5KsuZMXhIylwGsULuMfjuknWgAnEiCjrpGTa1pAbDpHXsXUav/kUqsDc5LhhsrTCGu99zQYIRoSNozCuawPOegI9r30zf6d3JetvKfQ0n245rN10tgWLAFj0tOvIDK7Pks2x9k9JeHLrEswGatE5Or4zvb1Kp0qL9jcn1dqsAVuKUeZcFnrAxsfy2GVXzHPxrVCemnsVVXgP3IuP3VGEcwzuvfG+dd6dLdb2tPGWEUfORxgJu53a13s2MeKeftoBI8+r/MhXvsK7zxvfKu+5vfdO5Jij94ga78kGV2L31zhRroPMVR/Jpx98JxapBAKckWHTWCjOAhIGprB6yAW921zjeS/bsszXXIHN9rpMCZXj8WSjPRhi+7jtJ/4ujh8AxfUxVf7h04cj3dXt1z6iS4Hh9RD06KHlimEgYAVGbB6IBeCSx1uIKCoFtDBLJCAsNeWDAuj43EQnSUGlIiTzswsDvxrz9ghDaSO9wk35SS6jlKwen05udxdBiqqbX5bWPSWuTcKyiiMUVosmVaGDGFFIK0HumxviUONQ89YIA5iEwUK9KNKLK6337+N7Q6CmZyNANQd6kDx6Xn584ZyWfpcSBaMuzLLtSSboU3Ft8oTJOxlGxUDd++2yoMc+FOtn7gyRmT+zvM5Q4tPCyQ0fEs9ccq0NPacpTwAfrNN8PFBtpnclCzwSrSmkJJQ5pEEISlMmXx7G7EptKciDZVzCE9YtN5rH2F5tOFzbG8VrKBx/T/buWuRdPtpen6f0UaLEzs0QyF5cnqO64ijUCzcuvFJGhw5Fuys6XfPmQ2OrZKG5BzDzTWMT7vi9Uh1Y0Mugl8FZlVLdy/rsPHnf7rTeuedaVDYDJYyLEnu9KHp4g8pJaB21f07XFcZKsqFImqLK55/f+cbXb3zzf9z5iR//HRztDeV943//9ROlgBm38+7sLQXPzZFrMBSKeXmKHhLkBMpp1wi2ZqB2hdEzSZCpCiKf6YBh7+4shyA1wp3NorQktW/zCzBPk9vIQmZfIZMZOsc7Rdum8NZcbH/biad/eHNcuw8KifL5wDV91m08/W5ptKa3JRPyOaOIxuKtjLDRbC4ZntmyVlNqLKW3BKyHUCzCGZaLi40fTVKZuOntBX/+3lSuuwPgl2QcUijoZH7PFi1AIKwHNrqjBVWi5miyDaaWxfBmeT1afNeqK/wirtAyJzhMPIdBkvxoUN/gDNRiYD3gtBbCk+XZRSgsk87eckFjilLQQYnuiRrj5yACCft+AVDSWvdPV+d0pHjRMaGwZz82W4XByXoxHdTl0djDBov5Sit7U3wSa8PWW/15hJI8bDcgeyntOiwU3CQDzrBlurKHbeEvebLV7MHzsD0ntzOhzY8sIdeloL6YgVTyaRYs72yYAzNSfC1FxXZGYmOA4WjTea5A22bJyIU71e4Uu3PhdPBO5pAV0IHW4TWEoWTnnHWcrovwalLpZGw996i5wG2t8Sp3vv7uFUbz6IXhnR9yPCsrZbCXVSR6UJj57Nm4k5VbLSZB4SX0e5+wdBtwe9f4tV/7nF/5f/93vvaj/096M3qrnO8HL5eDy1EoQzlHi1D6CIUZ393V83jY9LxFYHSdIdUxH8S+9EtvBmJRVJI6MHPjg+mspzNkWdulEvo44uTxxh4tToyxxFyur91a3I2AhOr/L8WVx+aLyraZf6PH/tFc+HmkDLLt9z3/tbTTegMsQbZ9h29Wmwpn5czsQVA93I1KKK5MTKxHXlemW9aF5MXZ3MMZoLT593WTZoucJ+PWFsilEO2uuCxCAmLewmBzFEcocRthnUvBZFG1GsVJRctgFLfyg3RmgQVm3ubx4WG9sgnFhVyccxAitEtAshNuHjhzz4O53+b5Qg8LWozRRCAm9mVHJAZv2xzonWbqNznm2rFNCMYKicGfP6fwCCUw18NueFXP3xFgg9Vxmbnkc4lMXbsbbbY9Z+VyE2wxKHQraOSRFhhi3wJKYgRTPT0rrTTXIFP6+bxvn4k2HJFbc5qpO9WcasoLcMN4UJCaAANXqpKLf587YpukwAzDas0dMIzeOieNm56e941pLXv+r6TRIrOswrbxc+M1dlVstMxhiQhVFOkSLe9jAOJna53PP3vlV///3+Drv/YN3n3rPbfXznnrvCkX6lEph8J58w7hNqC3FRYO0gNLcZWGyjb6u4yZZVaxKHQtgjxBrIf1PO9L5jlTEmRI0J7+Y2m9zHXt4uZjj1Rm6X398CquCfn69pTWs+LS8JEEb1+ihpijfGYeKYpFJUgKZ+w3GXWfD0nQwDNc3Wcu48QU24SMLx6tBOlFmM3DP7NUVw+i3vyyFWsWEoywLb15jzKdUU+9yNygOyuIkewakEFGbOBxhXkjMSbqRKMIQyrUK00unFw4ORjaGUfHXoz+HvoZBMMqTr90AFeDF/HnF7ArdNVgzUvFYxRODmyGsCqDgdBMNxo/F4fZT3dZoUENOIbffAvQSyqshhOpNnMrPr2uzmJJONmdOg8DpSE611XM0rQlbCEM8zG2BZObVnzNUEAuMgWwFQJx6WvFijOV5NJYn80n25x/RGllSNRM6FY55SCZFgZJ2ZRnSdXkcPhUrM6jJ9s7XHv6Mtspuvwsupvz2yEYRyAJL9wprXmYrCfiNuZHoei5PthtkSOnV5T3n0W4qTTamtveB613hjWoEv2obMraobiHY7JKGQYzJZAGXk/HNLYP1ShHoR6Fl1q83f0tcg73vHf3TN69u/H67tf5f+n/TjHhfmvcPr8zygv1Uvjk00+p5zve91deR5wj5rOffm+liKMpY18XNffyLIzFIUESJHTTpUzEDQcQbxw7ZU6aFbsSDCUVRivqYK8e0ZsRq8LPkZ7Yb2LcpVEBj8rqY0TR3+bxJVdceWyK6/nY466y/UyUVRzhZ8TCjE1rK8eVBYizNUkmZmZC4cDzRWX70u190ytYhvcOQJstjyuopgJxKiS3tIZbdXG1KZkkvsMALUKprpB6W4tpDU1aX8tSlRmMYy5hLbEm48Mjk+GRT1jy0KbX1TVt6IObXfnMDi8ufmnw1gWnR4vMqZiCR5C3zJqrVgunHNy50GZH3Uz4N7KfrUXGy6NDC8pxIjhA38EYI1BWklRMWTSe3lUwIcyQ4T2tfheEEkrL26GFAZN6Pqd9WpDm8Oe5pFYGbi7EubljDQkrBJsbuoayyjqyGBvJ1iy7R7YsDv/GsCfmsrPlUUyFY27Bd5UY0SUClt2e4mm19HRLPhGdk8+EGeiWtJP6w3mWB7YrQwsYfKPaeDAOHgCYAVaYkjU94DQqUjlPTzbfZwEkkmVcmcBLdVQctgzMLf8i0W/Ow3OunZRAOJo5JVzMmwTK83gRrm8rpVSsdBcHTRBKhPQiXB8lJP+f/++vOeEvQunKefdi56/96BWtynVc+OwuvN6N3psX62eIXgZy+DrSArX0WQeX5MiB/507ZY4Rfk0IjgBWQ0uiRnIdSShlQTTy7LFU01YVOhahUgugyBz3fQ5yDnfQjPAoGr+H4wdEccXxMcWVrz8rtrSacjtl3DrlfUJAn88VyisVgXsz6wvs4csyg5Xb28+Wc/1wfTNMJCvvY4JIdaZngbLxjH3sJtObm1Zr3qTAJN7NADkyc3Z5+avA1ZP/eyXPDJ/Z8iompN88xNSpNCvcrXCzg6qNcnS4GpaG88AVVwrmC1gRTJUmB00qya6W9r2mcrY1igYZfApHZu2O2Qx+S5avwnF5zJU03AsL5SWNUF5M5m8LI2BGRub82dLuQsRn5IvX4Uen7dECniHUyuzw7MXQDoWfgnZfQbugSEG+5RhW0WoKeKOH0sri+ZXZym5oPgMj/r4yXstQMBZ4Iv+aymqiAKcXnz6wG4AHjWKGjjQWLFxjmQpqNekOARye0LQbY7h9nscc+yQ7dozVrlgj2fI8Xsqk5Jpzp76+rnp4R+Q+6KPPSxQFPZR6rVzeHN5xnEIVp5wSVTd8NPoohGFip9ED3XutB0W8/11vRqmFazkYxwu93WFAb+fq1l7CwCLQtzIelFaWo3g64JEIOZepZq3plAkblHBbhrmw5n8hF4JA1Xv1TVEny4B7PN1SnM974mOvfQfHD4jimmbFFx9fMHheXiVBdwTpIRmyl10xhdNmURN2v+wnnpn1PItbqXuB6YxVP1+UsIpLuyMRVWvcXqMo1DIofS3GXbX2MaBBrSUspWkm+TXpLA7xLxt9fW9lhi+HgFa3NNUEkwgRhMCY+Vo0hLm3HrlTudnB+1YoduVaOqKd0kOZlhBOF7BdcWmhTU/roHNMbwsIsK9E5MMvImG/fVeuIVAd7l4CLSUr1NdBTluKKS33UF7cWGGoHvItEFfA7uimXbItJKblKmnJE3aDPrx5Lac4z2PBsSHheef4EHVIKFv3gSfD1Z6+IcAMmutWvaYu3+giz8d3oBRZVLhqIQCn9+VfkCt9lQMHUpXkxsuh8fq5GsS3CbvfzCkvNO5jjr1kfSS25RZlu0mbymq37vf79xh6DGp61D1wLiJUK3Rry9iAxR4RDBqM2DLDa68+vV45b4N2b7w28VZHKlCV4+3B5ZMLl0+uXLXM8Hc/YLwHu8F4P+hHd8++4i1Rwug7qiK1IiJ8/v7O27cHx3FwvHyFdp7IHV5bh5vflwB64NRpw1d7rSeHCAdnzIgv3mIdzfE3D/cJ3rSyBALaDe6MrS6DS/baH7KB0WAEWMt0rPX6MbGbk7Kd+vt9/IAort/kkO2Rv+9J7CBK9f/VJ46QRTmfMwE5wevzdL6lgxkCmUncaE38UGkuSR8D08Pb68FUosg0PD56D+SaxCWv/6Y1nO68BRAhlMk63Ez32LQnSlxRZ7gzfmRuRUGqugAbQst8gGw3ksNoIA7NYlAZemDHld7ecOudboNPrgPa8PKmExfG1X82PchalB7ZrHNTXC7yHc6f37mwahk8XCUFUzxOaz0+1W21omhC8k1y4l7WfNj0yJblvimeSdGwn9/W2sqLJJRPyN+l2OKuEgmX+avpZeGeVpUVTs2Q4TPwYr+OvCyJNZIxack3RZIuFp6rf/e6UkWlLzXoUzV5MHqv2fJTNjxHpgGSzz3jqrJPL/lDbkF/VM7l8Q5WacJ+Txmjyvud1hOs9Z2LP8dkKedUYN0GTQd6UUqQSXfOidh0lK2vd4fvl7kGvnW7UYaXuFyuL3xyPTiuNRTW4cXNCmzIX1X3sNIrKVXxUHJct4XBGzDU3gff/PxbdN7w8nLw6cuFT+sVaZ2z35EW+HhT98B75MJNOKRDvXPn4M4NFeWUSuVOsYJaBe6Y+A66bfsq5Vj61kICPHytLjH5KEAnelFtcYbmHO2h6meZ+31UYD8ciiuPfZDnQMYop4CR8GU2hZIhxUlUMGNFz7MSNC+sMOPY38a27x4EX77gClAteeGYbzIjCgzT1wopNuHsseFmzBFW11p/v1fol7whV2BslryCJGhE855DEWyh1OkpbHGFQWEEstDwGhwZge3OS5Xt8iJfYzicvifDQm6ebYgmEAAh69WyXbvtE7d9ek7Pc/I4LPPpNe4tatLS38sebDpSDzM1v2CuIaaVswChEpbpJpARkiTYC57X82QymPmziOzmfczz7od89Om6ngelumm87UcKrBGCVbbBWoFDh3FoXL8XvD6iEt2o6DMvlF+y57xkGnQ2Z8y/aR9gYRn9m5Vnj9f+UWFomeNZ7zG8E/PZG+UQNKjRtaiHxDWCD6HQj1Ji+JRLPah2IAPGOajV67mKFo9GzH5VY9HBde8WPDpBMMwDK4tEn6wkr8Xci+rW6ebfrajLgab+fhWPiJw2lYqoIDXKC6rDorCKRJmBUtEIKRheW1qpMwjvyjPlnG0GkEdZ8rns6y/2YIYMPzTYPjI38pHHg+z7zo8fbMW1D9I+iPFzKqakz9HcRKGEUgjNcz1N1HbCtZcW7uoBPLpJv6m8BkzqHnMLCnxD5LpYW9truNoIxFB4gIZ3VvbrKF4DptXJgSHCg+6NiS2p6HJV49rw8ORGk5MFtFnv5UonILOptCLuaSahtOIhXo+m6qFGYOXPJhDUx3uh//Z8yeMj68Nith6gA7tYnGd7yvEs4S1r3BMzPFgNIPv+N1nPjQWL34SmzI0c8z0VuoUhIO7BztoVH4SpjIK+KT0uK/bATehVETJRZA/CIMNq+XvqzlxjHy7UpSgsBOq+JuPkY9rf+TWRaRSZdrmnOxf/hUYeS/A6sGJ5hj2InnMTyitzVXlPE0SVm3Ifb1vj/mAwbp+f47DvRx/LMaDZ4Ha78en1cOJnFKnF+fsEp1MzpyU7qmBaKFr5LS9foVqFLrS7J85MQ1ndvNyjq3eX8AbExrh7q3s7LUCFMThFZsRFQlH5FAqX3IvYHH0JFKxYrImTUFxx6yrQHL15Ke5zgUbJ+IFSKRyYNQznQHF6AyHBTRLrVbdoQMq92S1iGmM2ja6ZEUmZmEwxeXws3/U8Z/oFf/82jh9MxTUHlTU4+yBuVuyz6rcyQujYFE6SE0TAZdVWS5Nt4xgjUKwejhMkSExtgxtvkmZakkS4zYVvFWeg0Jj8vIW7CedwV111kFznCEgHqQWrzr8ko8bSXKXPupnwzu7gIAwKAYoMwVmUUnxB2wB0MKbF5cWbYlCGrQZzCF0OkBcKjevlisirK8wh/j3VPDQU+jNzVI+pZInpWnVhe1GxX8Huka0NozjzhkoSvj4J7+lFyVJWp61w1RZenAXn6Yn1+YUTvTc9o6nNx9rQcb/Ti8rLTGG917JV8yWT7BgV5Nje87FcQsab85wrFr2Efi4z4yNCYoUAtzLhUG5lGmAjtK4sf4u2MlsQIfLMiZQIMGpIvwXn8Mc2cQshiO2p4cf5mkWtz/tn3vj20pNCKzL3fbfONz77Jvdx4fpSuH56QQPQ4c5hsEpIod2iPb0oesG7Jp/GeNcZ1t3YqEK/NKwMV2TAuA+sDUYzxmnRoVjcqxLzKH1VRjcv4DdDtVDl4HK58sn1DS+lwG3w+Tfe8/7dK/3ztpSACVTvHabpuYnnB0tpvKmfc9CDHK3GDBlQ6bzlZHAwqDiQRBFEkudKMu4PuMEpOJJxGavE3hWvL9yBSLlOV0r0e1ZOv9Hxg6m4PnbI0/NE8G1VdxIbKFsALEYCmxOw26gpFYal7S+bQozDEk4Le5wwI1gPujN6MYwg0QGjjITzQh/b+TPhHwJMVDguSj0cAr6ErIaOzHgUE9pqQyIc5T+tSCgv6JIsCYT35SIuvQADRtLc4GZrZkUc8+DsHz6Mtq41PBEEB1CklyVzBiLMFCJPskn7Umr5nvxcKtTcLPnpZTHaPnFLSYWHNVFq+yNDU6nAxgYgSO8grf8NmTAplxwRMJPYHyBBt5Bp0jlZgjOCTy9DuLZ9fvrfuZYeQHK2FNU8lqGUo/ewfvOvltyAaehk4bG/r6PUKY2WJ+xEFzZfnewpD98bBeTdoqQEp1UJnePDmHtsU0QTjJHWxHZX2x57fJb7gmUghHGRtZruwISijmEookHmL4wuHFo5pHDeGv0V7AS7RYsjNXqFPhpWzYlxzcLLGl53FQaPDYmIjpGQ9gzDyVCqFA6tvFwvVIXRGt96/57Pv/XK/fVOv3Xfl3j9mZyyUX8J1sKgvMOhJ6pKsQO4h2/lbb7FHJpYJKD4tpbtsgmXITzlhMR35Yu6QehTju7rTZ7OuTsRz3vgezh+QBSXfPTp3BUfG7BtslY+iaiEt4fJW5OQr8f7M/8DZMzeLTj/UvvggjahMeVGCH91iZMWcBou6qeeHZSRLSG6bTxBKIcrrntjCkyInMosQmQJTfPvndDWCFuhJI6ILiGImbfu4wKMYUESKpg4cW3m28+h6BBHQE1hYtPbyjzJVFbfxiPP43om72czBli+WLZAWfOzPaLOZ/IU7jmt+NsGwPO5TWj9zm2YYwnMHEAaRLM+K8E2jx97UFwZpi3MMO0MI4bSmvmFVE6hjB+9yvySxwUvc+JSwe5qxdfOGh7/y+ool0Ag5dE3S3CH574GaXBFnnPmuBJRGBZCyL3du3WFL0zy5llHue5nMdhsGzqWhGzPbbsxmQZeDHmRFWHY9g4GhdWjqg3lKJWDynnvjDte43d6I8Uh0IfRRscOg+I9q/rZvc39CRrIVRniKLy4qOxqQBFqEUotHKVyvVbog/M8+ezzd7x/d6PfG3YfvidFfT0kRVkTf73FGJxGPTqqJ4U7MmGMDbOO8682z3vZNreyjMF9razSGFZkIWXgNAzkUSA8y97n3z9cmt/18QOiuH6DY0e52NPfchCLRE5GZ+7GBIfDZ6xQDNT58nyuglMwlYIkNittz9gTIaB24T+RpsL8hLft9jxU6+JCPzb/jAIhUGLzmG+yvTUJZdX5OBPA9jnRUEq+eSUsUYtiV0lvS/0+2jhnXquo15J1s3VfUy65sBkDuhbOUbgN4342ajPK8OJkK0by0FhxmqhuOguNBwu51qc28MPZMJwGqkT6P33cxQ4Asqkz2Sf7QWk9/b4/Hr90PmTe5/63TUJuCmh6ThsaMA2NiYnJdVFwMMwMC0qEarfz7Z2Zt3uwnaA4lulEcuU1Plm9NoWNLYX7oPzSmFheUgT4gMWWsWq5IqyEUOZ47Kt/k1P2oeJf+bi4PsMjVZvi3k66rPf5obifHCfZ3pzUT7GGVeDlpXC5FEop9OHOg4pSvascQkG18NVPDjiV0YTWRoSThXHC2bo3f2zDf5bB0GC0aeFVdnWWjfDereDGoY7oxCIUKVyOgzfXK2/rFTXjm+/e8/ruxuff+hxu3RGuFsqp4OmA5sX0K0yNRwLEoApFB5VXChWzitmJSaNpw6RSx+DBFMwcViz0AAj79WbYWm2tQwEpunWP3uZihjT3ufiCOfyi93ybxw+Q4pLHp180KPvgpRIqMCoLCq7B2m4SYUNWqGcKgLA+g1fQ9o2bEzkgWgxvsi4CMJnb2q8thOMKC9mDvLwUKD0/E2I+haIJZ4eR8epnCyf1byiv9LIsrfwtpyLFgsDWBaRZR0RQSgA0bDIIFC2ozp7CriDV+xcblcHBzQoip6+24WO2h5M+8KzkGYe2xmon4N1vULEg9wjrfpfayUr8ALpwpSexYR8sdQvjAmFaDXuuNNdPhPbmc1Ufv4pz7R142G/usvgu2MKJLKh7scmeMiHxyeyeJLkPCjgg+2nxaoSkc2wGay3o/njMPXlXAJm3muOazTvzlnvmu8SwyGtJjP3KRiZsw+LrAiyTLOpzbyyDjG255hq0VF7JkG4yvzsLvafw3gEwecrnULDAcSkcx4Goc2nW40ItSlWFU6laqVKxE/rNPSfuno8aQRvVemf0VFzGkE6XHuwYwz3K5gX3qbiGsvJHRai1chyFl+vBlUIdQjsbt9uN+/3uyi8UssRqXgAuvy9JT0tCaZ14DWIBOdzvRRomjVOSQTTMDhmoBLt/gi1KGNEBBnIG+rQw1hqSEkaBjBXVedpuD7Jnk7WPE/SR176D4wdIccXxPID2Ba+n9Qlk7iWR4qmo0uFaIUIeJmIWdG5f7nIjgy+w27PrsPVjhnDs4W87PDjflhEDz2sE6Ds+bh26eVimyHPlRVzdFGB5P7YW31PoSm1DOfXNes4LiAtL4P6ihvGLHBJoAzkYeqDlROihP7K54CMo44sfH/hQD2O+/Nb1ysPg7cJ+hgk3A+Njxz4lD2tAlgc9rVOmYfDgKc2HhHDevjDP8aC4/LlNT0tWmcJW3JySfkXNwjLfogoSJu3KU9ic+5RD+wi70NrufT5dK2m+O8PW8Wow5bHTLC/vN6p+dqW1acjpBeZa3gXdprB3z3p2691q4ZYnJs9bcipwUaHWgpbKEFyBqHpBbnEMXqVwax0LgAXNgjVjOFx9dMbwwKgFK8ZghOLy8KOd5g9PEE9EHiqU4iCpQyuHFTRahpz3ztkbbURUp8TFpyG726IWY5CPbpN309sNERlKTzzkTs5ZfOY+8brCOK/KQ9832ediLoUwwDTTI9tYf0xx7XPxfTq+5IorzQA+/thk7Bd9fEK0a0dKQJhScWlCUzfvZs855ILSsDsfYkH5fBX3eUgxLJbkPMMcQBGAEBFmayFwd11HQFfLFhcagZob6c0NRKJtis2UWV4MIoMV8jSkhHApK5SReRYrYXV1o5+ddjoHm4YnalJ8S7Tuj270oaETgnT3eAt0TDrl0rFbj5rOvhUbO71Twqp3GqGFMHSxuIrwx3yWOTuZ710CFkhNuoAYyZSRRLpL/26LJmqMsnN1WgZ79DL4IDOcNcftYs56cYBdgCtYFg+LX+c+r8y1l89lKiyKn0d03f30xC3yHTgHX3JozsaYqSQeaHnMFaGAZrDVHNO57J9dQuWobFogjaRNaflMtuho3IhevKxGoN61eP/c/Jqs1yr5N3u85uxDlgK8EIXK7OWJ4ZnE2GR5Qx7BP2jA64AfuVRergelFEpZocJLqUhT7BTkNGdYad4S5Tw7vXVaO+nd67MWU3yQR4dXPwYeyjv999TLogUt6iHCfuHaL9Q2aO3OaXCenXM41F4PV3DWPfxoxBrRmNcMw4xQjhJr+vQ51hNKuHsW/45QNj5fSkWo1r0dS7pYOV5J6Fw0HkQqQVaO+jGav+Z1V1bPwI3v4/EDoLhYAmB/7O5pWtu7QlNAoz+QZciroDUnRiKOWyIYvjbUQz3SUwhmxX/8iyVCMX70UF5M9F72rtIIKbm1HRBy89beGvBt60qS/IqKW1mR1B5jMcWbOkw9wz9iEdKcQInUq4WtPatbZcYsjhzdLcmMDORmIRrQUdSb3nW364LTdJLPDFPohc9ugrbquxoJWtAyxd4I0ZciMOu6GiWY4r1OzEW/S6VkKQh1gBmcVJqUKTZX3y1Z3IRhrPstpyW6/LURRaiJLgXWBoww6yTBzTKCY/OSkvn+ArxhPU+F9eRV2LaOUgGqjqDmaaucgsduz3nvQySQl8pIwVZyMtc9pKXtat1HffHnp7p3EyBGeHt/nMNWAFdp8+GdjDvV+jRFapgnqeLmPiQHN1/O55uEy/yrGEPKVPiFPm2LBcslcojxTTOUH4o+WObB87bvXt8xhlMrvX37hloPrseVehdGgzaMcYsarbPTWmeM7uS8EiAUMV/KY0wPz1rcnoE0QUaJPePcgDIc43ctldrcgHy1k2YWuePuM6xGqQFMUfO1NuQj3J6hOM0SjLxCiNFoUy8DpNM2r7iKcejgEKhqHGI0UXopDA1i4DJwfjlmmUaWufpPzwc+WnNrb/3POL78imvfBA/u7PbgC17/2HtmfcJuxeffhZnYni58elH5GZdCEm9wLyg8IRToc3PJpvASzWfRxiKLFRlh/URlvyArvzHzWzEUc+XE6pleV8CQZxGtzOjSPpTz2KDgKWvzXCYEzDfeFxBxG1mXpZxDIx9SMCvcRqFaJYHtCcjom+LK3x8zJXvgySd3pprESwQWv8jqMTUoK4e4Qd8z55D3tbM7LCNoH4h93uOtTyHVWWCcIb9DQsCYK6wL3gTywRKVuV6luBbNMK6q5yCKDCrnFs6x2bJiYVN9fS1MhgtEixIPyYljQSqyCHgS4IZCzJtzQysukywYHpvSWteTpK6FHjVFYXLY/tPXiS9DW+OYrkhcdioxCe82Q4i2boTpAOf+y/PE6/tsPu9tt7myXRGoKsdROWqlluL6cAx6cy9ntDD+uqNnk1V+modzmUwLYX77RHGqK6y1hKI7g7mx16zRopyGMpimWGzxBeqJEHEaO7q26Jz8NNKSVHoQbWg83zgihpHxjSxayFovDTm2k/BKIJgnl+Y0NPwh++D+Tz6+3IprL+J8EigPHteeUM8jV4jA7Cg7/7ZpwLlbYjZVYMJb2RLJoYm0+PdpmukrUC8yEHVUoL+sa2HU9Lh8EUsNL6h7/ZBqfHUTr3JPhF4I42wgKTaQrtGnByYwJDbsZEJI5aWbHNmE+Ao7dhdTw/MUWssszFVzy9M6WDfv80TnboU7B2YXhh0Uu3CJzbIrqL6FCHdF5oqteEgslNaQvEKH15lJKMcAFoisc1h0PE5IciNaXNgkXp1KLI4HyqEYul1f+fz7O93AYAvrxfMr2EWWl/WyKS9JscTyEgSkMAOjGjD1HIVFoOXKx/OOQoaAMlQ4GAxJESQxVlBCussUYIsv0NnEB95/Dlb9FWQINvNT2d96BXE7mb9SW7MnMYMZKoQRHj/TobIcWFj1TDkm4t+aebmsKEvFOnB+vzQKVwmmrK1q22v5S3y3p5mUWitv3rzhkzcvVC3oEHr3Oqz7rdPP7pRNLaIJ3RVeHz7yq7Ypzy0RvNDHHmxj3dcERkmUD/TBvd8ZbGaIrmsXW+w5266M+4xGryPtUPF1fbAiC13R4V57D2+u4MTHZeDM/LGbnLSLmHNwZo1lBoJD+C1yJCMV1/8NCiuPL7fi2hXVs/LaLVxY0nk3sBN9MZgw8h00w2lIN6QLaoUhY0UCM+wmgJp3+i2G6EDKEd/pYgjxnNIK1cUCPJg5M6r/bhdBX4JDLUhfpfkiPopRC57QjZYb4MJgxEbXEaHIyH34DTtnoZgirS4Y6zY+U57M12QWGqsuTEOzwZ4uoxl2F/qrcX9zUBQOBqd+4tB97XQ7udviXegcId7KJhqV5s0uQmQ/pvpz6tJuNJJ1Y6ETO9W7PNnhbNzB/D5rXzbvK/NcoqzyhB0qn+Oxr50UhLvBVEM5pbK65k+DFxZBrkC29UhspIo9jcAS1ek/PthT806Xmi0IjcT/aWQwfLxqxEbTs9rDg9UDsNNYaaFumKIqr2OFB3MAHxWZzZlcXlyGyGONDtvyTtsdjTDOVGauNj0SUaPoIHNfFvc/52mHXZftd3jMYRqTdklU+eTywlcub3iRwymaIt98uzXu987ZGmfzrsm9dXp3JeagjD6jK25sxj6KEG2yrSRQggwVFkXVqdjS6xtmtBEGZVx4ZiRoK/wnfduUiuexhifyTPH0AQGUaHikpovLrdEpds7Q7fK6fN0dDKoZ1by43I0nDUW28dVIrKkA1UgYfrvD+8Gxz9P/BceXW3HJ0yMVl2w/bfs7T8/neaIuIWJ3s8bO8HAdm6jQOIkti3E2VpNVR0UW+YWLnxRLj4rTmIWqAYG2aljdAvX7tZQVWc74+YNJu1u10xrae3Qo1osv6iJMBEe83x5PE6+tQUzZjYWX1WzG1u0+aK1ySuXUC0PfgDZMT87xypjVWTI9qh5CctgSukO8JYlz4oV/sCvTKUZXa42Vuan04Xm31crE5hDMUMrIQYr7Cfb9D/DZZkubP3vrzx7+VkCcJQZaxUEwMqYgzy/1j5uDFx7uKD1fe1iyeanL/1vXmn2zdHu3o6nbw2jt4cHs4bT6caXHa3PNsykuL1reybeWt+XhxMwsuifnrVHGB+uLbQzmMdJNypAiC7+0uWqrcFnma/n5BNLsRcWLEWXto9467WycenIUr8M0M+5ndEkeg2HRe6t3WmsOyJiAl/Sg5KHGzrB1Hd3rJN3OFZIQUSTCjsMmfN6JdmOuN8abByMrxy17jCHM0odcl8qMMGQ7H2dz8lBuC4/YjZrMZ8pch+ljL9E5WIXqezH6El1rHng87OnBR55/7HPfwfHlVlwfy2k9gyZ2152n98bv3psmPmDq9Vu2ckxu6NkHCtEgCgtTecTa05jYIcsaHHH6CN1Nct0HpTWwOiB6YXlcQZfyki3UnJQyYlvoMuqrItZiIc6NTpZH2zimBSxY5KtsMqNbWsoYkvBecwUsSUI8Is5/GsEoE4pLOEvhLFdGMSiNXu7c7cVDSCFcZi7LdlEaXpbtnti+xtfEpY+ycmLCyGLmwWwKOR87ge7W3SN1k4/vUmTCmsupvCQXTwjTDJ1kHdzMdVk8/Llqp0h2BZ5fsXlcHkIVWdBxmVe3FqkLtgyLRgBNXNlOQSLJZeHfUqZy8nNPL8uWzyviykUjROvbSuZ1rrwp8zwZesx8WfaBmp5XvmZLcU3EY+6jFIp5ekkP3zaj0d+XqTEGXmz7IARt9X3KiZ1GXezBifgb3F9PXvH86MtxAVEP27U+FdRUWr1xni2+LxT6LmcuskBWunK90g1qgKtwIJPEvTlPYSis5ozybjBa8J/GnE7PzZWxqEQrnpiRVBolvPIWciQNyVj30g2Vc4ZyXcqN8KBKAGMtQoXOHK+yrcP4GjGZou/BeN6G/uExnp7zG7z+XRxffsW1h20yULvnuFLZ2PaT9bpErHYmwW2gQ9GuzqfWBG1K6eqQc3X3yUrE8AWPpelgohSxaFUxfCHPBKcGxaAzXzxY7dEs0A7oxyBSSpSLv8c69OEbRMRzXr3gG3QUVzA9oggWizPgzhYtVF14Hsio0EqgGmNActFbbMYEhoTVaOKMG1plhToYvkHu/pC7MErhtVS+1TvWDsZ54a298KJClQvn+fkDCCOzJXvQKcHVFomg9PlS+S6lVaJ3l+d6zNQ7LWdzyPw5tse2aaZD9bymwmqe68ce/z4LgjdSXA6QC9jV55GLccidIzCUpOGAowAzX1QjSOdftUis1mMHpIdPtV14Zv2Y47MUjHtZef7MJmav6nM2jzQRSra7SOUIZM7Lv2kpwEKj2kr01/Ch6zaTk0sxk6h5FymwHtxIWV5WGpuekI2wf1hP6RVnyD0F3+aRP3grYajIVHjGeR+Mqnz6yQsyCufwMOF57/R7p98b9/uNdnbamfVZzHyOFo+Rj2IzTGyHMTzdOguE1ZKIOOrjLBhvRiiubtirG70yQNoSI4KuVjt5/QpaxMl7hHleSWi+yeqUfLNg+/CIiLdRSRMxvCYT1EbMW4nsSmNyx8s2RUM9f9fVqayarH2Vb0qj8Gns52t7uL5vn/kujy+34toV03OI8FlpfdTjErf8xOPfGuHCMAiX1fOU+4DtvER789hbIz2q+DJHi4knzwirKcly43UrghbBCowCowi9EsQBmYALr6+EQpGM/se/JhMibvFu30luBk7rlgCHDJv3YFG3NFFMaR0HinHM9wqIRguE+M7pSRQsQiBtCK/Nm1CKKOcoFKkgg8aF7LWb3lJi1WbmRBK8+9jq5Ln9yXg6z0MoMBsTDqbFDOktsUBgc11IeOi2jJw5jSEYElE615ixF3B7mFiiNk4mpH5BznNW4q4t7kZCuMQFJX/cxJmJLKRgvObeTi7lKCDmQT2yCgMW9EUZFAkYjIXiijFM9NmQIGpmsJsND1tPdqRhCtP0yLLv1kdCd7M3mSxtkL8Tnn+utRyEHL2PGSCkAt/OE3tWhs3GoJ6TMepQDlOKFe63Qete/NvuJ+3eaFEIPGyR4RLpAUl2AsVDwtWVFod5iUguieG5ZveE4xxmHqnI2qse+6zZhBBqD1SfuSKjWziRkbUUgm5pOPo09uMI9gxJxZ0e4sjlOegy6IkmNG+dVLflXCIXj6wwYtLZlQiPqnjxtEo0zX2AJW9zMr6Nx8PcfufHD4bi+pgCe1Zcu3Xw/DlccTkSMCSW4cJ8sCDVm9GY+3nKxAyJkMLDv0xzAagvfGdkjw8HnHoV/uJM0xVG9/5bIxGIeU2W3luKsFBTiRLMxRMJARcwfvP+zrEufG33eJaSfFO9iV7IsKS/GEOniEQFpMm0KDHh3s0dElVaq3TpEY46yMDZkF1xpVIqM+dleG+vGea0FfjK2iV/XUho/uMGCUseR0XFL9u87z+XIv84JN5W0fn0oPeHbWtPFjB1P8Xc2Tl+y6fapng7XGL4/cZ92H7azJsZCZKX+ckFmkjvbiquB4U22HrfLkU0ryWvaLuZ7TvX+7dZjBzXrrQeHruHNM16Wz8zJGc4K0S+fWsAuivDZZTFO2dXZQJJKhEGF/RUtCnShHN0zjY4z0a7n85ecTb6iNC6EDVxa7Zml/BK5KNtAnNWDkg9zzVZPCyAG0txWRP3hjSAFIIDsnqEBs/xAG6exm+V2Q9LB2S/NtnHFJl1l55Gd6XV6RNNmD3bPdMheD+KsBpyWkJxacqvVFwoOjuhPi3cnJvnkOCzQoMfYsW1hwp3pZWoQviNldoWUpTqHVEJBSNDlreVygtYlbgOKpA8+RAHZ2Sif1qCaS/FgtK0kI3FBF5m8fFQkDpWOCQFZdReVqAOQcvSopJEu2FlCgORE7MVJ3Pd2jC9xFgoKpWhoJMA8VGRlaimv93T2jdoHSkyO/ZqQnwjqa3iCCrv43Sg+sIIk1fGoItN0BcwRWiq4FV8XFnIQrc6bf5tZYOyX5Tfv3g8tQP761GPYhHOmZtsy1ciPISEZjhjX0e5hhIpGOss8Rsuo5YHsIyBPIzHl9LMyfF4VB+Gez6J7twVxNKL+yf9WXpzxxypPvNdK4QIiMyuA+nR7gwma6W7ErQYNHnAnGVCf9HxzmaeHayP6TmkgbMPyRyjug3NFHi23p8hwvSIM6z9IDD9/ZKI2ybB6h5/F+Em8P4cHO3OnU7rg9YGt/vNqZ36WNHNLJNJzWg4evgY2GU4O8oF5CrIlVAoYezmfUQob+ZeDc8JB82XdVkGVpRueIlEJMrN4eryIpQX9ZILiVVj/t6JBi7MtISI5+qtwUUaHtg/KSh1hAyxCxWlMjhpyIRLd7K2ULIWNQjAhUIRD4I+LO3nEOEeKnwOE/7Qhwo/Fh7cqWDyPbul96zIonW3VtACtQgq0Y7cireft+4bwtJ9ZoXbUnwMNhTciNZXOi1/ma0y4gKmxwTMsF+2NLFocyWU8BREhBodg53WRpDRZ8J29zZKGVOEqCRWbYtniYezsmjWkmoolXiMXda9uCIK4Efk2dx5cavR4/Rj1kmJKV0OGicMZZyCiHtbd4FuS0ntPscSnhq5qwUSnyGzBzs/N7AsgTY1kTHRLAW3VCVvKuYhvdnNCjRlkZzGmR7W2ZPi+sCzyjEafp8eek5Ye7wxfgyUbmWhymSpieWBshLx213vHg/ztfWeRzNgeVkLIWjTy1nfx5yDpbT8bB2Zf3XLPG7eIKHywqDYqhXLJGI6u+aoku2QWYi/t4pfYAvm/vEQoMXzJyX2nLts4jmeE7iBRbhQgF4699F4P+5hRA3OERyEJPMMEdqHQCqR4Kyh4WXFmkouSqnFmWQirDtXaNQ4koGJ7mUzea8ydi9N4cxAXXhjgsuhq6Ivih3bup/r3GYtqByC1HDJ8G4Xhe4AjSHIKOFlKcUSGu8NQPP+wYfbi5HVPS7xschI0hz3zT7cL+mDfNcHId7t53dxfLkVl3wPj02WZ5sPiVyTSPpIG7owlY74onywDCGXvC/Okgtq5LpazErT8mSbQJs/s1A4xU6cMvIJxLXYCl9OxeiKdIbUJUTYc0wrFecEF1hAuGVZbrquzfdXoEOMFapJ3PyG2rIzhEaDXjymMkzpQ1E9NqMrBeNq8b4L6y5BJGROG5WhMsIAts1L8N/tcROkpMz7UB6aOqJx+SlI90210V89rLF9GBNJuBtMcz3YHJMMeY4JMlkXmcpFZv1BCvoYF1lh0GVzpVJOxRThuFwk2DZvewA2c2q2vnM77OGsK6A5g4ZGjLWxes3tQcX8+g8l0RR02/VP+yJPnyUjeZ68zc0GmQpshp2WoTYh42Ew0MzBQqG4sjRCgHF42OxOY6jRZdDMiXKz0aRbsrGOfIHF9jen1Ypmn2R7oKI48WGGdv0uH42KeNVsDpPUXG4Riuv+U7sgI0JyJqgpclHkIrRg2JhVBhmPTWUbciwN7AXGiMLxkEGaaFQaXro+pupi7srtPKIz57XbadvkPt7qs6L6X4rr6cgB+1gocBfCxrIO8vVZe+NWilZxItkSC8g8Cb7XomTjxayRSKvPq9kHg4ZVnRscgDG8vbY5KmgQn1Oi741X7hNQWRvQuiJ90AzqMGwIvTkzTO2gHbiXmXx2azRFSUp5BTnIRDnmFExZO+bWmUEdyKXMsTFk5hPmradb30JBp8A4BFSwuzBe/X5GHYwiNHE6CZNOt4NiHewkWNniyC3upnj6B69cZxhxN9OXH+K/KRZ8fU/znhbzDB8vQedlDjwKxx7vPbfn+1oRmGzkWz5rhvlzc0a7CU6hHzXCfDpPJVO5WIBcAsBofvf+Z8WcHjzt33kZ66LSN9p2/5PS8ttP7OaCOK+s4X6W1eNsV3l5Ph7e+6jg8qvzNZkvyEOucV3709gqWI04bla27tZDjq1tj53iaEbEYy+ksjqB9wI3nD9QB6aD3jr31rBiDB204r21Uh5oEvvGpfYyolbTfN9Uca7OjYgWqViQ+okNTEbkp/uMUtgGiAIQFQ+7icscHerNYEWopaK1UIsi1IDcD2680snIjEz6pxlZKMy2OqpCyZCuGYyOmIM6io1ov+e5rkqh0fCgbw1PC2dzEbzlix6UolOJbfHqjx8fnbenRfNdHl9uxZUybQtzPQiaZ8W1h3z2otEaC6coRQtFhaLqSoyC0iLMZzMPYkEjZAOHuArAiKLH7rmyKRVDA5yO9fLwVk9pBTrQpq4UTqOfQBf6UHojWh/YpFqS6CycEHhviZ7KE9oQp5PCNytRFy9EOEMdwSiHUC4FqZ4OyL0qSDiLDns/ROgi9K2VgsFEODLwcOHhlFZSgVpQrQgHN14waQ7kqC/ejG9qwqVsBZvhwcbF6YxysZNzV6bAn16B7X/P69rmvqSQs2Wtp+ecQrD5e5M+Z+5HYWNisfn7LDQXvz7Z16P4mrQGoyhnIgw3Fe1ETUajssJ3KxfqtsFuhiRk3pGmDoBISp6MARgWhYNLqe2sGWvc1tXs8PeUK6nICovLMGdrhW9nSNHyM3keDe99hEe1neDh+Tae8TkQNLsgdB+HyY3Zcg4t8lYBQpiKS6bykoRsN9sQeso4B6c2z1VFXnnWaMJCm9rwPadrpU2DKHLjM8NtINFk1pBZEoONBX2PHJf14dftuYT5pVqVMlyRlVGpdlClUNXJehvDyWB6p1n3LguZb48xlujwPPsJxoqw4YPoESS2OtUeCMOYbXEWeW92aZEvE7S6jFBHW62Gu/se+yIP61lxfZ+OL7fiet4Qsr32bIF/TKHFz0T06Jx47+4pMUHuMrNNgFswWXBow60hM/XF6ibWFI5THNhaOIa4wlEiebk2Wm/unckIFGLG9MMgXZ6DbXtKJnJuGFGQ6rklZngnbjY8vYlO3BF38GRGO7hkxKK3vv29r/eY4kXUalHf4ugN0QrS6Ip7gEW4W3P0IUxYv19Wx2EAyhi67nUHSqgxkqSW7TrJk8SA7NZdvjc3Wd/WgeFCLeZjnutBWeZ6kce1w/5eWZ6aMmP8tn8Gd60m/s/wWjUbU+jpvKj8+vS2HjOBDqPPzNRjGG8nxN2ziFNx2VJUT8HEj7z7KTS0lhwrH7b7cxKCj4l4nOO43dU8XSh0i/X6OKkyn0rCyDNE+LGEf+ytFU7MD6cQdzUsNiIPteYn7zJ0FsR4PivdBCzkxSeISxuhqCWQvYPslWXtEQb/EKkNMm3BYeaqipZKqcVDhF3AHPjUrNPGCCCUzZS1D/G0OldIL8N6lhPn947pfOkxy7xpGfEyDY2O6Rrn1Xne0Ja7Unq0fj6usPbfvwdF9uVXXLui+li48Is8rsx1xO8aIQCqgkYfmhpu8QYFddaIMRem9QzOR12LKWaDRaISAiZrJBoz35XlpoJMPruhcJ6DqyjVoh4kPAW1VJQWOa393nwhGd6uUcwLCYsWzkwwi0RjQlshGoMxBCkrbi4J243aE8GvYzS3WJeiUKwNuBvSJfLmHsaQFwEtSDlQvXMqdFU4lLNpKC6B6mOjFva9hFgeMEGRbUeL5LWnZHTBPetrsEflkYpKmd6h7WuGXAu2PCfJ+XlaZ3vUMoXdgxK3R4OozYFyZaV+IqdnWlaCCxHx8UyVYUH/FMJnL9lWcQYMDZb3JQcEo8XlhlrJmqqd5sCWuFrMg+mTqRdyp7Eyb99YA2EzMvfM6t+lMKTFctyMoZiaOY9s8/BRpRXvSxBN3ILtxeW7Fx3eWQKIfC59PkRjbxfoxY2rorY8lICYZ2fv3nIewwgMz2NyfIJ7TN0FuJorr2T6Hwb04cTTEfr36/cN/iCeLBRDLxStVCkc9fC9HznY1jv3cXKzk9YGPfbm1IAVl1m5pHVfshr61LwIOfrMmRU3OC1Xzs5l6fO2UnfuZakIpURZ9XOd3a609td2r+v7eHz5Fdez9fuswFJhPf+9PL5PSkFrQQ+lHkqthVqFUgXtXjnuMWKiHos1Md0Fqv/aY0cP0EI2ohRJr2sgAdlOSKsBds/EObT3d7hcUY2cQ2zegltw0uGIfJl1Z60G5vty1aoKR6ncaySfBS+YrITg981bqyLXK+1+x/p4sJQVpdjwjWp4+K6Zhz3Suywgp9CbIa8dvd+pn4IcoAd8er3y2esds87xRhj3QutGp09U46jKOMLKsBRQaV1v2iZDNfvu38ESmcfcQxWzgt8i37JZMzmHwrLiC2t++XCtMMd7GQ+S36mhzMQ819JxFKJ/YJYR+FIMwewzu+Q6suk/LxrNbmVKp0ijWp9ZKQuXNH2zVFrebuTR5DXbMYDuaSXB7mNpwq5VQtFgcz3vPl124SrhMTvXpNNdPRiXMSw57A9O2P5KfmXOWUKqT5C7ONXYQ0NQ90ryKheePU5Z43zF13/C2PUFTxoXmV4W5nvKhzIUVYbEYq15CkHRxiTUTZ5St6Vs7pFpPMW9ZTBYYSqBgnJY5ZDKoYVDFE7o5j3E3rcbt9649UbrM8zhIJGMTFiEmsVNo/R4BaK7RHKFai5FQGJ9OfLQxJX00IEVoRbhUDiKN7YsVajZi8t0Kaics52sofGosIzvqwL78iuu3+yxKy3bXnt4RI5Lg8m5pJe1vK0ZHkhtuJG1mvWwYtI4DFC7pZQL+1ZWSwgM33y5ibOuo0C/mYcQkLDSmLm19LzcIvOaqCUCbHIlJosDYVEmU4Gpx7GLY91JjKSNHlacW/kDZlJdRKdTQlDWWCgVb1KZoBJhdIJF37BDGIdQUvCkF3MncQheB1PjeYGEH5NkoVFEOoXcrmjENtiyK2QJ71YEB22oTJ034fAT/ZZWoy0Bl3KhbN+TCjE/n9fxFCoxwYWpMOl6PjCk9sWY40HavH4sDNGuHsJ7EqfyUutbcCHRpBmEjDFgkG1Ali1i+xkX8hEJIMkjAENsh39EJi0GdG8CPx+2Kb59H8a+eVBYjzr14YU5TQFMmrmshuevTl8fD+1plkO4lEWUfghuMCxghXiTxNwr+yV0PIT4LGxn7ijCe8MVUX5n6kvr5jnwQXhl63JWyM1Dg8UKBfe0vKbKSb5bN3rvnP3k1k/O3ulec+P7NC9XjUfwS1wTstbnAILoeRq328Jdudcgaw7IcsH7dKnqYhbSLaS1K6WPKagvenwfji+34tpDf7te+c0U10eUV6IJiypaSigv3Zidt5OaeEyvR7iQhLlKWLRRkWUpLF3riPR4RF6nwWQJuAPiKKF+N7jE4jbFRsOJcRUZI6igbBHuGts6NeflVWEUYRzEOZxqdyhIIiOjAZCZ0c97CL+412DCcGPe09AFYHjrchpoC/AEMO4DmjG6TOU5KnAoctpEJfYRm9qWEJvsB+nZ5OJv4gqyQRLbPli/xPhhc55VgiRUDNMyqZL8y9kGbF8X4lo5PS7bzjs9OtbvoZjmmpqhkRgvkaV4FSddDUUo+iR44md6Qf6tK+OS+aoFaR8Ua5RdIWHzPPZwb/t73IhKKMyHfBr6WIw8lVPmgtJDXGfevbadancWJ8s29lN676Mv21iEwspRMJAMZZl5rWIU6NLACwJZoUJkhZCnUREwc5zbU6pONCAHAbKRuXecJmxbJxGqz3nPUhnFGSfYnB+LoEDumWnYbUaWAVp1hd6sUqxQcW/rglKiXq21zr2d3NvJrZ30EQ0nsS0aEJ7iWCuGLBieuQAJDzIuJmCIWeIz8WH4+R0SH4S8shRXKi3RdCvXvf+myupjntb3qMS+3IoLHjfGF+W3nv+mrI61qdiCBaIehXIRyqHoodFLxwW3Sghq2ycuNnhYQgOwMbDRQQ0JAsuRMzjJeDuCYkPhVuYmNxxO3i6DJsILwFCsR/V9FlNa0mGGpS2gGnUYIvTYoKrmNSDDPO6e+9oyl+IAkDEXkdHGwM4xEYwjQjNyKv39CW04qrErat3bNHR/zzgHrTcOOeCiyAF288JuVLjfR+hxFwY2BLmwFEHO2Z3Zhnz2/hGWYNrnPDUlMeZqlO7Gg+DIPsQt7Al02Y8UVEd8dxo0ydmYDODbJpxOxLksblKwZ/hqz0O6sbxRfsEQi0hULsIp5cCU7DgmwS5fsluZOIRl4QLd4FhqbNPrU+31WRs2TNh74DLpcR3XudSVX93aPosvY503ld+BZ+gaXQqKRyEkvdUduLL3g5u5ys3C3OZXTDbPG49S3IH38XsaJrsxmjIcQ4oFQlixqsgFJAvIjyWDOZkf9OLbrcmrEAohePuItRlKzoYER4Et42WGqf36HOkHIheKCBWl2IWDwmHKS/O9PEbnfrvz7v3gfG3c7idnj7zlBJLEUhM2+jdCqUbHdYFs9GkRTpwBoEQH21ohIoMiDZPCCCP+KEItSimFUg5qOThUXZk/2kcfMmQ8K6z9/eMjr32Hx5dbcT17XM9KK4UgPHpbaUVvn5OwLEqwVah47HkrRY63yzJT5okh7NHUCrgKyhkNzsBUWBIluBMBoGTfKOnCOId3YK2+EIcxUUl9Fhl7U8k2hGZEHG/uWBZoAfTw1g0Qngs2RVNSurjwDqs37yF+ylBS41mzsCY9HGV2grn3N5rXr40y6Le+zk1FzMOTMsaMvDXBGQ7SAJAYW2El323e1Tbkm2Tb8ky+WRaoIO+32GoAaODhlX2+8qhPSi0VV6wlxwrImv4cd3vagylZUibnxWwhLZtAjeUwONrL581kASP8u6LzgGTzyR0JlnJi2wwmm0Jc5m96R4+v+r/+6bFuNrStkN79Yt/IdZThxo4E+8Ly3IYoRQPxEuCXqbQKROsBV4dz6WZSiSUQnx8ZMsy1E4olQ+2EU2Cp+CByUBaeg0xWCh8KmwTTSJTFRMpAq9HiHnTCyHMS58Bva5LHeVdCdvijUiimFFMuphxdqaLwCqc1eu/c7o3brdGaw94poXQS5ZhKcco5C/AEqxN6WFZGGInz0RBzJJhYIyQM2S07t6FqKiwHqBXVqDkLKZgWsOxjwMePjymv7/H4ciuuZ2X1sdd2qbcruF1xEdbKfPgmLMH39fjftMuWx2xZzplHKC0LiLKE4hKmFY10ZljH1D2PCIeMc0RyF6SUkB82EbaWdnIRSvbMig2S1yP5/RilJilmKt3NMyjrvvJyZNIW2Qp3xMLMehSGQe2Yx/2Y4VOgqzHu3upBi2BSIiClDh1mGcrLuLApfBBcOGGB5JdtHrfVvxeGD3fLLK5jpOJIIRuTlf5E9juzVJqw2ESmVRvzutyXCWScyl2ZXrhEyFEif/iwBk1YcVXml0REay7dpzt8OFaeK5VJMjlGmNFy7aXnsHX3slV2/Ah9z290hTWLuy3PavPayublpaeXCnMPGe4Q+xrC1dJTDqVlOxnAk2niubXIx8zaQdx7mWUjzLzpUowxBnNvuySfU6zGJLyOdTYFfBhMSWBbi1KrTtCPiS2ofQpu0kZdij/t0LlWlFBaLk+qLcV1DKV2Rw+Obpy9cfbGLcl+u4OqHo1sCTBYjFTc5+RJjLdIGmoS0shSJg0sIPFsMzZSnm1GvGyPKRtZjXYfFNdvpJw+sDy/90N/87c8Hv/6X/9r/vSf/tP85E/+JCLCP/tn/+zh73/uz/25xzoCEX76p3/64T2//uu/zi/8wi/w1a9+lR/90R/lL/7Fv8hnn3323d3BZtl8NFSY8exsrZ7t1fO1CBd6BXyZ+a1SlVILtRwUXTkvmQVdrE1n6nmiYfThQtFC2RBAAZEk6ZC5QJIAFelk91Ka57jGaVgTlAMdSh1CxUN6d4PXASX6Y2kUuFZVqoZECHd+EEo5NqsX0AujCXaC3KE05UWvlHEgZ2HcwO54HuGuC0U4oJYDEV/qrbUVcQjz2MZgnDCaX4OHQ+Gilbf1wmSXNk9Mz/DPifcRuuGPPd+0F4s/GCQSITnZwjaOatvZKpTBwZ2DG1duHNxnD6kiNul7qOr1ZxeFq8Qj1kuunQwvl7V+5Hl9zYc4s8gDWSvLYo7w4cyrmIfxkq/xsdA37yc97iTO2reBPTxz+8Tt6ZPCaZXTHPre8BaWy4daomDrR+2IRukccqNap1rn4FxXZ25GpbLqaJzbC5gtvaAcrxgzE6GLd/PyEObqw7vCbLGOoy8ejad+axKP/TWWR5YGVmiuSp2w7j1l7QJf57ilMTHTnCaBqt3WWz7f17/YypkHG49UodbKUSuXcqHKwWEHl3Ggp9Jfjfu7k3ffuvP5N0/efevk/bs797PRLZTWFeQKXANYctFYW7ZSHu4mOfFAKpsqDvoSInNlM0LTI62xgDUVp9w4nIi7FCweRY8gZoiJHPo0Rzx6Xc9gGbaf36fjO/a4Pv/8c37/7//9/IW/8Bf42Z/92Y++56d/+qf5R//oH83fr9frw99/4Rd+gf/6X/8r//Jf/kvO8+TP//k/z1/+y3+Zf/pP/+l3djHy9EjltQu6jyk0YSOHDEtweD1FOSLPVZXsdKJbJbobcUJPi1qJHlxpwWswPriSKShZmChxAk94yoxEWdTaeNJVwAbt7Jytw5vLRHt5TZjvphO4qtdZVIPeNutvGCZjtfA+PK+kQ2mjey1XhjYOr+HiELiJs4FM1JZBN4q5WyHmst3CC+w9TV4jcwBp/c3K/UCoeErAKKXQhmukyEq5IG4xHc/W5cyL8Cj4570yBRPRHRaFUT00I/Lc+WsAToPl9uzGEhqsQ9M0maiRODr+F0tLXlxY7UWlwcbgBpO54CgW3mj4Ka7jlwOcaxn3TNJ76nNR+weGeZ1Uoc+yLIsGVjaV1F6jJZsFvIiyzGT23Fpfb9tF7CRQSyWV6W2NmD9f9YubYzDb0VBpFqox2VSAoTLvcX53uN+7D5hjRNKZ7WHCzkMoeSJRA/BDXy6sj6BMwtjJGrHzHj7IBucGHGa07q1F9g7h6bknKCKjEsy1H5D0kpAmceSglfC2hGIgfUR98qCPzm24t9VtOCo3CZyzA0PGAY2pjC3WIUGS7akInTJqyifFDQoT7lY5rXK3wmkXTg4aR/TJu4BcQA+QF0QumFwoUqiinlOfSXJZ4cqcr93zyqULmSr9UIl9D8rsO1ZcP/MzP8PP/MzP/IbvuV6v/PiP//hH//af/tN/4p//83/Ov/23/5Y/+Af/IAB//+//ff7Un/pT/N2/+3f5yZ/8yW//Yp6V0RcpsY8pr5RXKXeV2aYjIfGOMHQls0grmVYa7BiuOHEorBU88IeEAnNrKJFvsfhIRSJk+KtHuwV391esugrcUwCKURRqgVvzzybS1UaEKceYlFBqCr3PBG2ekwQtRNdUAtHn3In2OE7iiWtTo/e1AqfVqjqTxQ5Y8XvokfcoRRzCb4H0YvM6ttTGQywg5nM6u8LjJhkpSKZcYZjkZbDng2aoS7ZMWCooxWt6Ms+2b8I992UZasy/x4QHl517FzaRa+iWm8j5MWMy0Me6ssgBeeTVhbsH71YWauEEZa6wDFWvRxq+eX9pJqzxHcGeMAueWaHGVE7LDwp1JFkX5oOxgBqpvB55D4dkk3iQ0v3MInRJ/rx9ii2MBptrIUPUSXXmr9n0sLPzr+RN5aVtMsB1kYe5Ei3LcAMNxVGecRN7OsAIFN/s6sCC6E/lYWnhxE1IhNmYMsPbiHh4UM1rv5IMe/RBG664zt6cFYPhdGwiATTyNSlpKKeYyLW0GXZJ0eQPm2HPocYwoQ2lmdKs0KzOTuONgyYHnQPkQOSg6IHJAVJXlATNCOWau+efa0I//P3/TsX17Ry/+Iu/yI/92I/xW37Lb+GP/bE/xt/+23+b3/pbfysAv/RLv8SP/uiPTqUF8Mf/+B9HVfk3/+bf8Gf+zJ/54Hy3243b7TZ//+Y3v+lPUtjsiorteeVDBbYrrlzogSpLXq5SowD5UqlH0K8E+3M2LXQjwuaEjQE9PCnf2zIbUaqbX9TS6N2FvocrQnj5Sl0bpMG9NW6t4E6Nhr81uIrgDpGLoiM253vEPb/pcuCrWwIVKIJaQc4TT8IORh/ooY4GBOdRs+FKrivWhdEdQp1sH3OjiocN+9CANAulHlhx9N69nYxm1G5UvXh2xJSjFMbokScyklzCQYHLcp7z9Xw8bxDbBNteazXSQM685MpCLkBDFl4WkqF8KqldUQkrJCJP78m1BWH92gyLyYXIq4CN4d5vwuTjChKub9uaTA/bkolQBt2SF3DllqbAniooi+D3ImJ7GDYf3i1LtSn33BCL1zCUlw1qBBVXsnMZBHEnsZUqnRYK18OUWVdnSEDmPZQ7jYksD8EewBcfPN9BOIW1VrYcaBpCASFwcthaKEciNrbzEkZDAGWc+GIzuiTHRcNY2a5hZJzXvzXTAaJQawAbNGq0rExqKGnBztEHZ+u01uhj0KzRsQcZla1Kcl1PBKSZG0Pm6wt1rkMpxZlADkEP0JJrstGae1nNCqd5qPhO5SZXGleavGB6RfSCloNeDkq9Qrl4Tg5/bKEqP/Y5+Z94fN8V10//9E/zsz/7s/yO3/E7+JVf+RX+xt/4G/zMz/wMv/RLv0QphV/91V/lx37sxx4vola+9rWv8au/+qsfPeff+Tt/h7/5N//mh39I4bbnPp7DhM/Ka/fIUhClq6+KXkJhvVSON4X6tlBaQbui96A+SsdosyKcHzAsqREWrcUFxAbI0KOI+oKTzlzxBOtcyJLRjPM+uHfj6Ip0haaRJnBm5zF2/RS5tAiFmHW3gM2tYS3CIcJ56krUXgB84YtEHqHHzQ2H0OvY8iVmsytzegxZkCihnLNexa3VBt2oUpwdQ8XDTTNsMyh4LY832bPHeqmAEn+gMKYAiRcsnu9gDcC7JEPzbyExdXl4jVSfhZagdNWlxHaXS2SFoDBXUPMt8TzDNsWgGlXbBFLcJRp4Rv+lhzxAysaJRiVqosMzTAEp/s+O6BeSYe5JjVj6Y3n4IMrD75vsjU/W6Tw8VnmJPX7LLqck/s1Wkh1FrHJjA9hP5y+vIBXWypXJGGQjUGsgd5llERMSjwttR32w3NUAKYB7UVI9/1tqQTVgeUNzYB2RWMVz21GInx5KWJuxDMuiv9wg5GFFxNoIozcIDGpyDYpSBGfYiLd3G4zhnIN3Gl07g+HsN+k5RWH0tGhMYvxidjWfpdfIxlqvwblaJsvMiXI35TYKt1E5R+U+KifueZ3iocIhL6i+ocgnXMqVItWLoiPnLzUtyeXJz5+7Uv+fcHzfFdfP//zPz+e/9/f+Xn7f7/t9/K7f9bv4xV/8RX7qp37quzrnX//rf52/+lf/6vz9m9/8Jr/9t//2JcyePa/dA9sfO5Ip52ATiqK+kPVw6ie9RC3XRdC758CkycP2z4hHGn+2JauTYdvfZySrgxf2aUCKN2EYUkxwcMfoxi14AMtQtAdDTezdzD0nWcP++REbzILpAoIRJAsSMRcSUnzRE/c2w25za6wrNJnhrXX7EYLJEJuCFO9bNHBPwclK3YR0ueH5p25CwgJGDuBghkmmN5WCI68lEWdLbqw3TCWWxoWH9UbEjWTbbbLNlItQJxYdEVIybHGyKStMxLwQ9qWQNWT5qLTp97RU6Pt0z5+2ft+XAszw3e45PYQMH8KEYNsdPp80deSy3OWDvz+efT9zctXnt8jD+dc7V2enHiCQR4X3mFebhMBmi0g3aZSSfaSzdSBnGqbP+3DNQyiSCPNvuvLBsJGRe36DxqcSyLDis1E015lPUobIVcRBXE/o5CRNzi7IfTjEvVmn4wzvQ409n7vXjsH67hnCjp9pOK/w4PYIHkYUOoXTPMfVTDnxLlzd6qTr6lIZAc5Qda42pfh/soqmedr/26L8UGntwmN/7fug3P4vh8P/zt/5O/ltv+238cu//Mv81E/9FD/+4z/Of/tv/+3hPa01fv3Xf/0L82LX6/UDgAfwoeL6mLe1e1x7riuRAWy/J+XTUSgXf+jFvbByVLeEokOpG2TL9pw1ffFwcIaHSxxCukIPU3GpRfuQTMBDJj2tG60Z33znntPVhGs3r1+OZPWNQAeFMnCSXzcWB4INwwtPmw+KRh7KOjY6o8XnRnH0dpPgPvOst7Dgtp6fwMcn0FT9tFjkwijDN1MxL3wu4ISj0Qq9eEFnb2Uqq8Zs8rKxJOzCgg29HwKAbfPOyYMPdoOlwMiAl49j8H+E/HNva+BhzB7nltCGNrUVAeKI+rfdKyyb1S2LrrbSuHDO76902uyzHldguNUxuQvZlPG6r6k8colA3IssZRCeR/pF+5jsoIfNcN9fWYpFYGaqbCn2LzpyB+RVJvMdcZ4WIib/us/aNBxsLAUVyMBsSGoRJnTFFYvbZIXQ8mS7UkoDtKwoAAL0EWzruOfbEkjEOl+B0FyuvIZN7kJLr4jYNxE5ULL+s4aXtfJBk5jAjDaMPpq3JLFOZzCyNivZeQRkGnoxj2OEjZFGlC1Kt4D8S+bm0zMKb8uKcbeDuxVuQ7lRuKOOMk1ghhycAY8VORh6AbmiXKgWOS6tiBaPrOyglmev62NLZVvyXxrF9V/+y3/h137t1/iJn/gJAP7wH/7DfP3rX+ff//t/zx/4A38AgH/1r/4VYwz+0B/6Q9/ZyXeF9azAKh8qrv19sAZ6Wi44qvBFKG8V/aRwfFKoZ4QJjwM9hxfknuJxv/EITXJmaN843rjxADSAAr7ATYWjDs4+ZmgxYbai69qsGee90avTq67cf0DjW0BaxYkwc0H0LtNKHn1gesfZoDu1dBgnbZxgNYw5AynOvBEoByOTWlDLBTP32HqIyy7NQRZFIpoxJuxZogTBYuN0O31zVaXUg3IzRvNrW1a9Kw9SQGUOA1vGxgeTv82thGU6LVLBi9t8HDo1siuPtUjZAdYNjCSKTQG8BO3A6FroGY4K79l9ijHP5RwU/j0HLRSi0qX6Z4uutbcJwnlPIbhceTQk6XcCQrf7OJlXyrDgh37QWuS78jKSSTy8hvl894KGs4ljs9ap0NLMeJoLe7g2i6t9zivOKQVkm4fHwmJZ8PYd6n7acjGURVy8X0LkOifre5GwoNYXy8D3ZxfkNTj6FbjaKl+oOsODhCHKCO/PmGU+WZyrqhylLm8njBJfyt6Pqzejt+6P4b3Y3NOKL4k1ruFppc6SPM+IWSq+tncuUopfd/IwShX0GHAIVoTzXjlHhAv7wX0c3OzgzoU7V05eaPIC8oLolaoHhxWqFEopHEfxmtG9zx08KrBn72p/rk+f2bEI3+XxHSuuzz77jF/+5V+ev//n//yf+Q//4T/wta99ja997Wv8zb/5N/m5n/s5fvzHf5xf+ZVf4a/9tb/G7/7dv5s/+Sf/JAC/5/f8Hn76p3+av/SX/hL/8B/+Q87z5K/8lb/Cz//8z39niEJ4BFs8e1PPz5/RhfCB4sqHHko5StA/hQdWXelMuKuEtbuHtTBmr6P0vvJCJeDsOlDtG9LJcz5LHCRc1wEU59mcOV0i5WMLJD2NfizEcobclmXt1zRm/qSo0aMLpc1iRIfRptBciBVmoe7MZZmialgpiHoR9TAn7jWYkP99rPtw6hlEseR/HIVaB2d3xn3VaAfxgOjbnicRbu7oAKU8zOdeY/cgYGW9xPIuVlYm818JGZDtPS72vUBzQDR+lOBELJwUy/5YnSMCZcU8UDZEEStOiit11j3N+/vwx8w7+e2u69hV0goVLrU05muP4Th/su5lneGLx2W2Q3lSfOs6HvNcudkWiN4eQCLTKyRhJ+t7PMLAIiZu4XlNVv+8Rl9XYvu3p1eStymz0WEqkAyJSiAKsxHrzDcSSjHWusYGE42SbWGGurPQVzW6F2vxmqmQwlmk7MAt31+9mSMI+2BYj/IZnMEl1zvGqn1lvjbv21i56WmgWyAJzQmEkyh8Flh7iLyZRqiw0IhuABZ1fFIYUuh6UMLtTDI5Z8/w2lAtJWQAjzJzX5Yf+/35kdiC/f3fxfEdK65/9+/+HX/0j/7R+Xvmnv7sn/2z/IN/8A/4j//xP/KP//E/5utf/zo/+ZM/yZ/4E3+Cv/W3/tZDqO+f/JN/wl/5K3+Fn/qpn0JV+bmf+zn+3t/7e9/51e+K6IsGaQ8hfpHiSos94mylKvUo1KO60jo8VOjhgBTpsv6dSRqZMtYfa6F58rei0h+q0jWRhbKchYUfGNzPk/Hm8NoXVUa7B2pKZw5ZgGN4948e+SkZSyA74e+AYZSCF2YKjNHR0QMxYo6uMlDNRFcMZCpqUax5I0c1tzjP3hg2InfjYSvFN6SFkmm9UyNZNbTQVZFauBQ4X11wFRX6ICzJJ6t+pL6SNX+7knt+zMldc5TCP38m4EAl+w/FWCVsP+8jzuC8HxUVn9Pkgas0iqTSGxy2ulNJoOscee1ek0hZoJ55iduCnAidNPfX9ftnwmsKoZQdvJJqaWx3+ZDPszmVc3Qen2yDvXnbGQgMLpJ59g/tvVQBK78728tvX5V/LXTURnBoyuqztT+m0lqafHoiympFIrgXJfBQsyWaTZj9b9kPKxVXMJ1MgFTQUT33rEPxXNlGF1UU704sxb9nKsn4MVxBjd4Zp6MIW/d9OMsbUkHmPYXGSiSsG50xtllaklMmQPWUg2oCv4IovLjiGkROy+AcyjnUfXjbysulMtQfhYpY9a7I4oa6M4gUB5tUXcjf57XzrKzytV0O52vPiu67OL5jxfVH/sgfYWe3fj7+xb/4F7/pOb72ta9958XGHztyUL5IcT0/nkOFGbuYuTH3LMpxUC6NchEutXIphbsWaqmIVGZ7kqBzygVoGEOHiygb6IhQHcNDaMUc8UNBeqFIYYgn8rOnDm14YRbDF17vvHZXdpdDaffgL8OoxXMwIvAiSldXXGeg5ywqNUcfdFGaDo7rQamG9kE/B2MUpCtmxYdT1ZO0WdyCRaGxKzJzQ3JG5cpmJExdYg7Bt25YNfSEdp5INY7jBasedrzqlVsfMBpDBgdRazql4pOYzV+fQ4f7Gpiu2AbdTi8olEdNX0AGla153gam2Bn9DIl6lzKDgTk2viedxaJaVk6lx2rbI/NGgyH6GCbZofdR7J7f8AiSyDAudCt4S8qRapTsHp2DkYHdTOjKNEYSiRhC2/I+H6ETPprL23r0YQ354Pflne0VXfl6CSVfZFBGWz223gN3PJ91x5O3GSLcwlEiFlyE4gvPYAF6QHt4Uyg6FG0S3nwYXpEfFvN9rofGvjfsxYLtxODFZs5LKmip7s0c4h5WzM+BuqU1BKKgOBupDvG5GaM780w0fxwxtKbmOSj1rSYdZvvZVGBDQlnZLLFJhJCFrp25ra3m1GHw7lGdo3DvDoW/o5x2OBzeooGoZCPRioyDYgcHlaqFixYuqlxSaZVt06VR8e0ee6iwPL32XRw/GFyFzyHDj3ld09tagmDoSmK6YgErEnRP6h5XrZTqtSCqFdWoaLCtnHVayGEJiy9eywSW5M6CIhrkoxlmcKt/0Bccemzis8PZGr1U6uGeV1E4dFCkpzohk2NZH2biOQpnXHAl6nIrEsgavXMzBBF5ObfgNpRfhLYkoU42PBRBCTj+QKOWxhxp4kzZhKgbOEjkHPTSqZfhSD/xRpL1EBjCfUTKMCvy8+tybPO+PparfPgZ3kWGh7AJ7VZ6hPWiCaM4+ZF/JslrV8OP9LhMEshRKTYmvN7PLxFWe2TnWFwSPkbuYTgVrUXtjaTSmOs1vZZQtrbyW8kQD0kivPsv8tCSJAVfqpFdyeS5nXxWJxnE9NPs8R7mGK6zb0pqtyWWn5XvK+xNU7orLLqvlyTJzfzV3cES3PnQ4yIucHpHsT7CJvDlsfw+HRkmdBYMDTSsB1Q25N0hUA07CBo4V17jgtdCFXGEcXVPq9RQXCYzV5b0bkSn42HmkPf8z0YoLWbJR3Za3kO1kz9QJHSTbZ6JkHRSUmRRaFX/PXvuuRKLUGFgKNqQYMlwJdZHrpVcC5BAFJ0E4078W0ql1AM9iufsy7reBytmf+3RuvnwyHnL59/l8eVXXPnzWZA9K6woBF05g+FNBo0ZIsgaHK//UA8PZpiwVrdsIgSRdC7Lzw8VIgFtsEDUBarIoq+Aw2Z1tlpwNz+EMiNgs37e3CDn2WlF0ZerM3oYHDYoLcEDNhdfxsjdmg7Py3rUlfn5RYVSvGuie1C++crhnXidKTsVrwtICeYBszHzB6XgBchYpvncbn/wIIDhQJJ+Di/EVRdz3Vxx2RCkEYltIocxpqExhdYDszjLy4shmPNvTEXnci5rksYmTBdwmwAjVBZDYE2FJm6MJKHt8nxyqS0Jmsi5xf43YgiWt6d0KEc4YcasQ9qMrgRIPHa4WvVcM9MU95nfvlSGRMgqvealwP2ZkYhE5nsePbtdWT3+bf2+b8KltNa9rxLkEeMX9xKKi+aKy05x5XU+Ka4cH8tbkvWV+Rj55/hvo3QS8b5ZU3EJlDRWK8gV7AC7mHtaB6HEXKlJVcqlosXDcKU4KleGTMXqtqktxTWMbj084ZABaSCO9GtjTZstmH/8tBmizVsVUsykl0aV1ZolgSiHe4SpwCyMwNOUu1Xuw72sPjbi5dgfHgV1g9h/OrS/lILWitYyv2deazrvebHGowcmH3m+GxzwQ664dHv+rMh2gEbxkM5OK1oYdC20o6zYbWUu2Mubg8ubg+PqyJrjUqlFaerCXWo4U2NP80egyLyosI3u9R3IqpeWIMQtyhiD3geqg95PjA5WGFZR8xj9671TS+U+hKMeHOKhtc/awPqgD6NIJallnV7K1liYW4JnN0ofqF44jsJNLb6rMARK9bwVF7BAP5nh1f5juELF4/SuTxwyzXDuxsy4YJ3RI4wJlCbTgDAbaK2ICL0bpTTUPLwxArchotz7WHmGbP6XRK0xkBabwMKpfZClM1noYd2kla3xcykz25SDA4TzfYmNG6bhZR+xhuoU3SO2UH51iXWlMxPq7zyoDDlBlK7dC52TqDWvOT5borqm4oS2DlZetRs70ME/tftC+iQXIqxNn4B+NwscRzm3jK2z5D1kLuoh9Bf5PHkoarOYEgvP9GRR+C6EZaUvT+oO3NTDgu/H6q91hlJIo2ksRbwqgeeA5dfPfVhGcY9rGqmuyBTZkMYGV8E+Ga6wrhZEyhEOfEMYqwHMin58iH8Hp6/jccdrJNtg3Jxkewyb9VmphKbBkUrYp4Uk/YjQAslc/yzTrNosM+EF5A3YVeBSwzNUSoFy9fCnXQrvOXg3Ku/GwftReR0Ht6GcGBZMPK4DO1IGWqFeCse1cLlWLteDy8vB5U1F3xTkoq7h9l5juQTz9+dj98B0e+++Yb7L48utuD52PGv6TaEtK9Dj7TPPWIuPhIPGoAp6KejVGTTqtVKuCdKIKvIiZJZ9hrCIUEBLCxjGGNFY0hF5aT0VkdnfRrWAnIHoNozu9VSoe4XDaG3w7hx8otUVoQpv6oRe+DoSpgDJ3kyqxWmVzJWPTbIO/1sPyLgFp55UOI5Ku7dojW7Myts2GGOQZLq+l9fP6XuIosNh5ZmDsO5w4Nvnd7QU6qVAdaXJGFRR7mVEPsKQIzwDl6TYRl7r5VDuQXgkyc1Gd2p9LlSNoi2E/8pQFekTGKCjRydh92icNT4F7RlhRAKYcWxK5WAFB8fcnxZrLP8CzhHnM+HK0FCaFESqc/blMsLnyEOCHhpMBfXo7+yBOl/kHq721zqFNOjHXIUWEYL4mm1TiGU4MPOAjw1K9OEcPWwJI+HsKYHyvXUaCY8KuLBqtYhmqOzIwWxX0m0NZqytmVDdj8zXWcL5QzlFraKHBPMt5iHRCuMFh7y/GLx1r0uuglx1ei36Io4mzr5cYQ4my9OMjATU3dqgnwFzz9eLhwQVplc4Lztlky+YeY+TXWTYLOMxkVBahh3uGY7qrO1IZUhhqGJHxY7KKJWmlRsHr1RerXAfhdOEezDDJ8RDxVHGIm4416tSr0q5aMi8lHtKVV+boyhWw+B6yC1/5HiIgMTz3eMqH3zi2z5+MBTXxwbuQWmtkFGqlFnbL6DFe0eRbQBquN5J/3QtPqkBk/ekrisikbA+Eyk6cB5ACZt+Qs43RQerul69fmrmkPZHvD/DEa99cNXisGpRrgXOITTLjIdEB40MBOV2Dit7JAjEEYKlVO9eHJvbxDxUevHNat3rrQiiXQkFNENVfiMzhTeNYTLHkJamRTgF+jnorXsL80OxUQIk0Wmx2UW9H5LTVQ0nVp8AmoD+kqE4CU+OSFi7QivSH7ynQqMGW3l6U3s4S2W4grM2FVel4SxUMr0JZ+Ibe+ZmKhNPze2/Gclqud7t32ECEp6u13M/xl2yNmvBSvwsto1xLvzl7QvdssDasZEJ5th547NkY53pEQso8/nywj7068Z2zuVZ7kprel0WPIdpmSd2ZcfP7I/0QuKH5Fqb921zqHwJLm9FkkU9IeEaITZHU3irmot7LbzBa7euoC/RBuRYnounBhxBO/XkVlA8xoju3x416cO7geffd5mwQh9Mo480nMUDBNmjbGCrs7Gad+6OriNuwDnCGKl0dUqrXg6GHvTiQItkgL9bdWLdERCiCawLFGaAw1SMOlMkGgQM8byII2cjLdK1PCqtZ+X1sd/tI3/7oQ8VPg/UjjqLvz0nmifjdQRNboe3DyGSroJyjMLlk8r1faG9Fq6fFG7vK2c7KLdCv3dGNDCc4OPhfH5ixsngsEG36Fs1CqIlFuuI9jkacWUv4PVWFG67SsQ4TYUmxvvWeFvS8j95UzPJ6ymCi5Nj8FkDCQCBmaOghnmieAxljILqweV6oZ83hjUPb+DQXq2BWGyG3QxEva6mGGo1YvXhaYWXpKLc20nHFaG3/fCN2sPrcg1UabcGMrheXhiloAUuRRicM8zy1U8O3o/ObXRPswXPVdFVHYSPDgiMQHplaKpK4zK7Tp3hQY3gw/Z+Uu59LU8jldWDxxUbrsuNDOT5GY5ZB9Msg4MVmSG9kMFikVcfsdYGhzh6cdCjK9gj9CH9Fy+CvmIcMH27lAM6Bd9UJ7bChITX7UrX1/6wvgW0c2t8GGR8zHWNh7+tXGHblBzz/ZVGjXEt1uY4yhirwHgHX/ggpQZ6tMKf8j8P+zyo12aOpiZMXaMPlnvmqzAXJz6+glxAXgQu4WVdBb2WVQt1Ifp2aeStHGDRm8HpvfKygL63QOf27q9lhOJ8vh/XyIKEBxYWSIYGd3lVXIlJHa60og+cVLCLMEqhScUv9MC0UuTKTSsqTk/wagevXXnthdsoNMuuFeFLB5ilBiECRTiKekrkWqlvCpeXwuWiHNIjOA5KXV5Xhu+fjY5dFtvT8+8EifgbHF9+xfVFr8vH35Ob0GP3rK2p0GqlXwp0ou+McHxaON4f1PcXyttKfVM5zkJ9jRR/98DcZIofBM+azHquPrybSK9ReCmeM/GuyBaFjBUZ/vuMfatBtA0fCGc3T7CK70DlzrUOEOOzu3p1uwoXhT7CM6qC9OGCwwathTBVQ6+VouqNJcXRVeWN8pWvXfnsVrDbSbPurNNVPFzRb9EmRSjHxQEduVdHiyT1+MCazFq1fu/Bd2qUfqKXAymOtDvCwzkFb5d+BAjmfPWQnqTXkiHJMBdMAq/hCqtao5rnhYp0qjWycsXDhjcXrLJ7BkupVRpX7r4yHCniolxcYUyqHKs0q9y2AGOo62kaLePS15wXhUooLs8KtsyKBTLUTOKKArWZISRSDoy5xAULarEVKkxlMsjO0w0DjqlsFrJyqcnH8GCGCL8oOOmAi8wXM5GbVc4Jcinh6eroq8lj9IhzYIMtj0slekrFjX2QR9lCiJYKy9eHo+Ci9qgIclFvKXUBfRG4KnIR9IqHBKvE7w7A0KpRp+UPDWYuM7whanPFNbo5tL0NRhv0sznoKCIT2b+O3L8j0Lo5buKzuHu789BgM9FUuHhI8zDPv1WwqrRSaHqh6wXTC6oXhlaaXrjxgljBpPD5UN6Z8t6EmxXueCcGy9C1rLH2fL1wPYzLBY6IMF0OeCmDSyBCfR0PzlI9bFp1gd8KT2UdrEW7/9zpU35oPa7n41lhfUSx5WZf0OcIx4hbIaOuGK4Mj/nWF891levhMd9LcQTPiNBExjHGinKMENgjwgY9HgqJVl6M0irOA6bFFYyOWacxAQribHvdoItTCBVz9ulLMY7iHGkyhEsRbkGnNFuSx2CYOSjAzGvK1Nyy7HRMjHIIX/mRN/TPbxjGeaaH6OFFOdSVqTn0luJhlN6Hh1YYTmE10ZwSOJGMjVhQ4EBvnfpyIKqMJCgNYT7Ui6VVXOlK5KWyxNbCw/AwcArgk4udUwG51d+D7HZ5CkfWE03hukKIqbgO7sujSKBLKLBK46TRAjphGCcL3hyY1XjFP6+zhsr9MqfyifxifO6RxjayZJLKb88oJcdf5vm2UCFJ5xShRRIUlNVnqdomYdR8fDyT9qi49qtLPzONwR09WcwfXmRMhAblw/YkuSszrJZ7Y9u/luG1VArggAuJULjoZK8QUd+bV/eq5BNB3uj8XS/FaykPccWWhLTzSyNsbkDwZ1rwFY7uhcQWxlnvHiYcAcogG06G5ZmyYN6j5LjPCYIAkDzIqlQEFVdeF5vdFZIQt+M1pUMOhhx0iSaQFIYpNxNuJtzNUwndhG42ZzG2tBsASkQ94KhCrcJRhaPAoSvOIMCIRqamskpTnlGGz7L3C2TxFzoe38bx5VZcH1NUu9v90eRhOss9MgdL2KAwRGmX6otpKPVtpb49qJ9cOd5eqG8O6v2kvI+kSxsL+dSTyoVoceLKqsWmbpYoNsOih45KsOQ1pY8SNDMeQxkS1p+aN26UzmmDakKVKxfqDJ29uShj+Mb95CK89u5hDHPhP3QEmsjDgX6vhtSCFoPeMRqXQ/nffuxr2K9/A1Hh3hrnuKHF61lKO9yjiri9GO5SjkG5FAd0dJthBCsBADYm0HFYMAncOm+/alCFJoVyHN6tQox3YnyqJ1ftvCsnvXs1ajFo6ROEBZvC9eDkym0i8WaGSAJWbi5sL0HT5MrqnICNg8YhobjsjHBY9qEiYPrCSeWUCycXXnlxh8FG4A3KtGOyGFjQYNcgYO6DlqHZmYUnPCYfV48H1GjAmXcI2cCyJuOHJTjEPby5lqfqi80RhlRB8H7UmfuEWRz9gQLLWq49hLiFDyVLCLL1iVFn7dmgckYPKlaIMHnJxloPJEI0vFt/TVboaebCZJKKFAI9GOHBLMItqp6zeqvIW0W/qshXBHkD8kYc4l0Eqd4nbCdrdvazgDtlc+8Aj3g5hwOMLAEZDUYCmAg5MAQZGT4VAs6coodZk5UKOm57vkckwoTMnJxdhS6JjU2oS0E46HIFvSB6pcsbnOJJeDXjNoz7MO5DOUd4XCyZWMJ4LqocVXg5lOuhXC7KS1GuEb3R2BtJVV3pXrhcyscV1/MRw8BzqPCHVnHl8TwAaQmE1a+S1uGyCo+A7PocrvzXQOm1BFRZ0UulviiXN8LlbeHyVjnvyvFSqeN0LrrTE7gjCmsRwp4d9KG04UW7Pr9hgYvXhQyUMgq1WuSHHP3npqVFcSGThua93BG9cNELd3uJMNjgpSg3cSvoU1HeRfjv/Rkel0ZYMtu1XKFzUq+FopV2u9FG5/37d3zjv/0ffOVrP4JV4f15436/M8y8f9aLwCiupM82O+kSNDpFwLQgl+R1CIqbLMTskXjuwv1m3O+nE+++OWimHNfK9SqM8x1FGsrJp0fjlE7vA7oH2BYwYuVYlhDNrZ0QivaQm6l7GIvmCEPZe/juKLrIC3VHd4rBpYxALQ6SK6MwuMH04DUWX45BSfEuhWFeJ+NCplLotJmJO0IpC80mxwd9g1ILEq3Bdonnx85V4YJGw6ov9LgvL86QOW5lfkuSDqcHuohwM5ya4/mW91uYtaHzbwnCCO/jHEGcq4EmtFAGNpXR2sMZF1w/5ksjP+PWqZjfgVp4WaazBY1UX3/6AuUtyKdgb5R+eeFEsUBtpCJW0pPrYUj2RRwTSsvawO6DcTfsPrCbYXeJ+jNm3zAZhvSY/wdFYet+dFNcuv1dQ2llqPDijzPiB75GLph4bkvKQff4JyZvELnQTbmb8K4N3nXjXTduA+7DjWihg3h0B3Uqp6Mq16JcD+Hlorw5lLeXwrUqVWWWMixvu3tz3MxxZRNX2x67bN5/35frDz2qMI/0uGbcNSCfsjysPSxUtsnIbXvSw8NxD0wmykYdHnqpjrg5ikNlM0lMFj4mxC1+zAJkZkgh48vOqZaIKN041mR6gFYWzY0oTiWjxihK70cUWPYoGozdoMr14tRPrwkljtj2KIOm6WEapXhVfOmVNk7uZ+PrX/8mP/7bvsqba+HNmwuf15vH9W0wGyiCQ5jD0kruxWztbhkuifCLmNPe4GVqEGGW+71xuTgPIEWDUR5ehtMCiZ0UOxF1mHEbzVlLvEp6C30kLDwzNM/LwrbHTiAbn7Xdz1hZHgtSvKy3sZGoxb3jVHU2FGuoLMXlzkLxMCyTr4MhCy3YYj02Klk7NTY1kdezhw58hGW76/1eZzBqnm/9/fG9j+OThddj7o0qKzzreyYhKI0XbugIvsfhbBgSj2gwEIpLNuZ32xCFsgm6FWYlAVJTWfGg6GS4kSizqFic6V1dFTlDhp9PRLxmK0LaTerMJ3ptnl+vinlYM5R6zjPD1+wIg8sfIzwusGbY6Q+J+7TBap2C7EvM52WTT7MBZNofZXsEerCrl09k8LvLAVoR9Z8WPIOmB4ODjnIfwqsNbmNwN+OMqI8bzSDiIA60OhtQya7v6gCNWoIpSCYae3nbDvaRnSc07+mLarmeF9v34fjBUFyyPTbYNIUVc98c7TrzGW1u/rQXq1ycSDWUV6nFldW1Ui8Hx0vluFaOwyfcKaCUPrzdifSBdJts1077ol6Y2L3uY4g55kJCeW25Lo1ckgmYOkw/KVwovvhNjX4IvV0osclVnbdcxIXddQzOyJ1mIaSKF0Y39YV48Q9511Y7aGfj3hv//de+wU/8rh/j5VL49JMXvnF5zzlOxmjBquFmkxQ3twSBUsC8vxCnOIy+4Eln8Yqi3XI29ZDi/XbCRSitwttCL37vb+tg3E9sePegqu7NOsqwk9nJZecvIb/865CMJsj21z1ns9PHLugHFDEGFawHZBgnJ47kpepweH2EGQ3vjL37LiXCgT2gIztbuhPiKo2DwkGXGlbtoJkDPxJ80ine3HJIVBjktQtLqNh0WhLxXMTPJ/Z435M9xjI0mGjBHkjMxgpKLWDL2jsnb3j1kN9pH0DbZYe8p3ETwAX/m8yQZyquJeFZrwfQyZniBWmE0oqfwTAtQFI6ifg8SeTDRtT0mcrs+tvx+kXPN/t4XLlTCbYYj3fDcJLcHkoquzNPJXwH7svj2hXtNBFGeFKhuCQIcDMilCTAiUCcIcIKI5TtOTOvhSEVkQuq2fCxMqLx4xkBvbsp78fgvQ1eh3EP08l3oVLEyYGHXhCtlOKUdv6oHEFxV8KY3sxCdkT2g5Owp2Ty53PN2rPS+qENFaa23xUWhDWzJ4uzIPTDj+8g5Icj9pIAtVSux5XL9ZXjUjku1Yv0qjoVkwgS7cYTMeVf55DkPoyGQ1vHGIyuEdN3T+1QoRejW6GJw4YNgg1Ig5vMnEsRo0nnZnesFvcIBlyrKy/EaEN4qwW7wDfr4GYRkQnkko1O5855OI1VrYPrS+F8Vzjb4H+8P/n1//rrfPVrX+V/+21f4Rvf/JzPpPP6zpWNacP7ER2UXqOTuvD5N90qVnW1MKx7zkAziS4zL5UtVdq9I68n+iocb16AQElL4aVCLUbveLsQhU8+PfjWuxtnd7Hdt/jEvl86snFaLPTgo8eVeyvLp1egPs+Ya2QKpRTUcY5LbYwJmzf2TFGjhEILD86W3ZqeYefk4OIt1KM3rYcMLwgWABC/1h48l2YyhUeCjKZQ2bgGff1aeEzn3Asy/b/sT5bPPRh1DTFZtzxfGnoVR2nyOR9yCm71WbIpnkSdSoCClhW+meMZCrWn871u3wHBPeiZOukrwji6x6m1KXLAuLpC0e5dB0aHuwqvjpELL7ZEYMYNj2pKNejWUfMGIAlimRGwzOGmMrsbcgNu4fkl12ZaDwYzMSdMgxrDgReJ5684tiKZYYpgmjMSFYnpJUV3ZVSx0HTDvHz+NpT3Q3g3Cq/DeB2D16GzlYp3bhBQ51614wrHC3q8cKkXJxWvhSNyhgui8xEZKbgGyTdkXvBjntfHEIQ/tKjCHMld4++u+Mb7tSAZy//KaRnbdrZoDWHmG4Ph8fNMYDrFf6VWZ1AuUaAoGRoZrM05YEif7Sb68JyQ11MlUzwL2aNCGTrzYRaxb4k35f10Bqd1LsW7P3UJpF/GztVh98eAN6Kco3tk5gFq7F2Lm7gXVa+FOgrjHNzp/Pq3PkdfKm9+5A3Xl8LtrNx7o99PV0YmFCfL8zGzCKtioAXrThE1BiAePPPJsJm+M7w55jgH93cn+kYRLZQqdLkgx4sDq+yE+w3M26McYaY6Qlc3JZ8eFqFy/PeVm0lS3QU48B25AsaWIR6Y3ooMNus6LM3whmo5qTPeYw/KCYwhitp4UGh7OFIt82kNONgbMA7TeYkZ/FMccZr+ZfIvJpzdAUepxNfPHfbvYbGlxDKv5681b71jS1lpKKvKifaBpLeRrUj6CM9qGW1zD2wk+b5actPakyQM6yryY1nzJWf8HHj4dTKRhNefXI/mUY4R3QikD+gazC/KMKEPD9N2cbgB4r3VejRZ9c7EzudXE7VYupeBDCY5MhJRjAyLdnxMZqdmjwUQClsJBJ7O5eZRgKzzCvIDNm+LZI5fvnQw7kBRZ7zQQrQ78vf1IU6qO5T7gPsY3Ie3MfFqAnNWm+BbHeUC9YocF7RekHpBjgtSrx6KnPtCtzUbglZAbKxOzXu48NnD+qJc1v/KcfGh4nr6YyKuHNHlHXHTSl28BmHHJofcYBYjF/GGarW40irFXekiwT491Iu1ot5kblyJcCHCiM2hJl4EHN1ws5AyaaCKBJWQLJElc5M7vP4cTtZq6uLKkRH5vuEM8sDbKnzemKFHry8R39R4U0nVDgdUK3R1eqpvvHvl+u7Cj7Z7UMAUaqv0fnclEYWWI5myTTxXBpGLa/QzDICprDbFYuTOxLrRXhvtVakHcK3048DKCyLCVZSz37E2kNGpLsXmOHu06TFsthSYUTZ2+GxB8iwzfZBtfzW8lgj73v0hJ8tQUlygS3tQSpFhgVAwmbnynNlajwNFJbtOl7Dt08tzPygv0H25bHyxq79FDpw1W+velqpIgMUCruzm2qPiU9tLBM4J1NDRPGx341FxpS0wQ2W2tO3EGcks65gXmIXH81pT2YVXe4orrc5qV+K+u3scUWvpYU8JLyU/H7murfB2DyV3SdcGJBKvZbjSSiLailCqeTQlwqK2yxdfeCuvFd4lkt0hIFEea2m5gpasd9lzW8GQYVUmkfRcmuGYeR+wUFzqHKEpHLJh5GmuuM4e2JjdyQ2KqFEqlAuEwtLjQOqB1gulXhA9Nm8z87ZjKtF5xudQ4XP46mPhwN9MoX0bxw+e4noaqBQEuYFHoKtuXBhICBblzjUqfOoH4Q+xQtELl/rCUU+O2jjKhaqHW/DmII3RBGnGGMpsUYKjBdWMZpEEHkKVjg3P0ApKLQdmLgBPqjdVnJnplRMwCMLcwf0A1QoIzU40quurQC9QVfhqUT67Ke8x7lHMrMPDGr13TAe9wKl36qcHnPC+v/J5O/k/vv45nV/D3l7Ra+GNvnC2BmfHbHC2k8IFp4cStBRMFR3Fa2E4nScOppBx3icC7iwxvr657+87owhWlfrpwfuokVG7o/VgYHz+elIL0cXFGK2z4Agy95BbtqmoFoPDjpQTkl0iuQobVfx9Vzup1tySzv5QkWthsDbsAeXwkJLbBOvs3tZklfp67yP3vFJpDEbQdAW4Afe7Go3KfRU7J1NHBL118yjrRPXlN2Wk4VGZr9rFBbQoOMPIDAOGIlwYx8gKjeHNHlNh3fO5PfbNmsALmyUT06AceFQAdktsHansUiEFAKMEi0WVYwM0gVAiJGnOlqG+/vVQD8MVQSugla7VIwFyYBwY4ownAcJoBnUIpReO0CKCUQ7XRlmQ7AhJW9GNuDUs2oVY6u2UOuu2S66b/FB6YQpSLDw5mQprkOdZ6YwihhZFoltFL4Whbl68cvB+KK/NeO1wN4nOxzavRVBMDygVOV7Q4w1yvEEuL9TLC5fLleslaUfGNKaW0t/5UuLYnYaPxRTl6WceP7ShQvhwMGLGPeS387YB6fnMoNHyuBK60UgoPNOoSAu4FCfYLUWipbWG1xU9eqYnsVvubmUP8TzXMQZdvKZLx/D14YhlB2dYWpauUluEIdKCT7SUCLR+0o5KKQdtFI7a0TooVbDqbUcuVbwBJYkmxIVvDwsSGGqc2pz2pgqXdnB+PrjZyTfefcvRZQFCudSD+wmtO5pKxcDcSyNY4wGHKEcrCBur5Xl6WQwCZRaF3GjQ6gzsfqe0C0Wcmuq1X/jKi1B74X67Y8O9iovC0BHCzglx1VxAV2lcpHGxM8hzoz5LvBhZgw3dRKYncnD39LYNtA/0jJBVCutAi42sNzIPDZXhSFSR5b8YwulBIooYLUNbRHZMZEbLyuYBCne8WubkugU4T/EGgJmJyoXv6fadX3DPiOc79jYj7pUtxdW5Tq+qPYxVoVHMG1BmXifXjgVIQXaPK+Y1PfDcP6ahZAMd6xtK9kvcXIvYD8GAUYlCe1Oq1k1pLStVMG8rH56LvhXnJPRooH+/ZIjRRbBZcZomrzD23nK2CHUhShc4KOX0C+w4k8Xh/IFSZO5fvxz3pjzFtWTAQayNRNkqzDY92S4kSAey8JkRfrk2lMJwZumJ3kUdXDECKXm3yjmEcziZ7mnQxgglutSoJdFBqe5dHReO48KlXrheLlyOQi1u0Gdhv+E1ZBJnymrUOYGP4u4xZLi//uxY/NB6XPsg2PYzrLZhYYPPkNuyHJI4KFFbiTQa6NqEc0P5bGR4UIu3tVZxpaVRjCG2hBEwWQDckgoW98mk4UzSarlAPObtCszDjyO7q2bcf7jwz33fbbgDUJQuhVocrq6HoYfMvj2XQ7jjTeJ6bsDuXovvEfe6RhlQlPr24H6/c47O+/PGy71yqRe0CLVWGsFePzwL721OVusHJJLoRSmo149MORVov3lPNi1sG1kvY7Rz0A6haOXOQVeh2qDUyjgDkCDGtUSocrh1qKGUHESw6pF2NKnXoSwPZ5HfnlQbnpNKr2ICEPw6l+2KD153a7kEPcQI72mQ1EsZRFye4IoBhTiJouSkTfKYk2xLWieyrFO4O1RlqqT1Ttme5ysrh1WmCMpatp0JfwdgRG7LMsdnj4CJzGVFSO5BcT3sm6fNqSzFtVvb6Znl5hEX5qpKlUrF11HRuvhpQyDP+46Qm1WwK8jFNoZ1Jo2aRPtuY/XLS4Z8FxtuXGXhRKcg2j3MXQ2pQXqbPb2yEa1k5DAjDI+6GHEjKb0sibCpzI2xzVyOc3QucKozC8UlJC/UkDWLLcKcbQinCc2Mbo+kushSeo4mPKJZpCMJE5RRVNhhGbnObCounTRjHyit38i7elZcP9Qe137kIG61Il11LkGmPSo0+nTDRwiDk8MTtRu018/rXlAtlaMcXPSIPJe3GKkIGgvHupBxfBGgjMhDeYS4YR56MAdQeB42rEEVCkqtwT0wBiXrwiK858TMriS7GV2hH8orV29KWU/n3nwDEnxtb9Tvvo3BK+KeTvPurr05ozUM7tKotfLy9oXX2yv91bg143q7c1B5I96KpKuzCwxR53GLbtCFaB9ewjYrF69Oej9w0reOidAJLymVQsUt3rPPetTzWyf1Rw70UhHe8PX377hS+eTtC+1dZ3S3lH/rJ2/4/Gx863bSewhm6Q+ewyVChU68eyc7IZdYDdOz6DZDgjK9LGbekhAevoJYcO2QubW2aNmuk5sCiODkwDICILiHSu7lvs7JolNyJeOrtJtEOLvyKldOOzYDbJVOLwnhc6qb2FnQ9h3e/sigf9C4bGTDJPx7hkrxnNMZTu4zYS7MLiQGSzilZ7J7KLvgC3p/QdCLUKxQOXhzvVC1oLrdlxl0N/wylWxqE9zQ3zD7a0mBjocCW+803Gh0w9G/2ssF9suqDLOH1F3RTj1OuHRohlxt4xOM+zpBgh2+x2wWXJGlpzjHYCrV8IbMGTcmk/zAWS3EHKYf1G+iBcoFK1eGvNDkCI+rcOuVe1duHc7RaTgDS0Fdaas4mrAelOPguBxcLpXLcXBcrlwvhcuhXMvy4nNFJnX0xAJMIA0fKq+c9wwbPj+e3/tdHF9uxfWBZcdSWkoIRQlE3Wq3DsTWlfl8Kq0uj9Yly44tFKq48qpycEilUBArXsM1NDyPDmqLyyusPpcBLnCLOR97Fi1rleBf02iI5y0/BkFam0cYXEWAqlCMXgb1OBhy0kqjXodTxRzQX7zdmHdiEcoAGwHNfmeM1zEh3r10pAjHYVw/vXCKcH5+cvbO561zl460QRHlclx4fW3RJoXVQsKcLVtLWK4GtfRoA4Fbnt03rBbcs+jDEXtR22X3wf1znIevVcpX3tAEZyQ4Ty61cRRFrPHu/h4zeKnQZmJ+gRWqpEA+OcxzNvm3Qo+aH1w5nQSKDfe2oqB0hj3SWi4WqyI278lSbtXDhm6I+07dC4gNp+aaQRhJTyj7WUUuThoXbmjz2qeh0MrBKQfveeEmL16UanXmzgZCt8vcGHuIcHVgzhzWAmCs542D4a1ddkUee0KCINeyjilpnO4ZpbDwInyfKTINEduEtoQQtin0BjLcfNPi+d4qhUMrVz0mh+UQ5wd0bkzz/ldhEiQyTy44L+GBk+mK53haH96ZWFpcapgEkxTR3SD3IrItkTP0uVHWMO2Uo2/dhyNKER6UxTIYYylFM6MG8k7MvFGrtxreNGVK+BjDZt6J2by8oZaLN1YITlP3tJxo9+TCOQ7OIbya8mr6f7L3L7G2bNtZLvi11nuPiDHmWmvvc2zOObzM9c0XWJACIUu2kBBCyC64gnCZh0TJOrYElhACUeAhsESFkqGETMkVCgjJIMRDAgQYoXQlE6z0zaubXANpGz/OY++95hwRvfeWhdZ6RMyx59rnYefNe3wcW2OvMcczRkSP9vjb3/7GikOGrTsakqg7syONfq1S0GlGy4U8zSxzZpoKJblNG92Nh5nVPV8/2gk+YbvPvk6Epn37poUK77d7qGJ3YofLaqIR7OcTvVxp5uKUz5zW2TEa+AwrjbHWeR99oDJEdI7z5ReFPUuRB0enS6cRY0biv73rP7TDunijskgQPXpEXSfsWGPRdzrkqFqoYgEZWoaeIM1GFqOI18w0O4PIXk+8/ZW3rB+u2GZ0bXQVujbyJdObUW+VrXZolc5Kru68tWRWdcc6DpAMSngPWDZCTE3igzQ7O1RqgaWMfh9rg1rsx6zfOlvyRp16nVHJaJqodWLO1eEjEZ7qBua5TErsSiVDi/C+8fy47Brae1CZ8ZrNZtiAB1fxhtmxjhJH8+89ft/juf3km9caw6wefYTDeR10+bNUkhNEDpHg0javb4baSJJO0oh9BTTU6F1KyuEbGfjvM8fV9+bmkWmlcOCjR+v5/KwTPDhucS0N+vfQ5BvXivdqSQQx99FkHK6R1qS4NmCfc+XC7D6XN+dE1kRJyVm7cRENG9+JScMagxvxIFGUUHlnV31Q8+GnXTpmjS4tjHA/vI2v2sN02IhZJbJkC1zGYTSir9JOQemALY95XSPzjCGvkVEGq+h0UCzc1mh+Dup9BAI+FDPIIeo1LnMB04DshoCui+nW09/uPKPCHxR4Ser1rZQ988qFnB1BynG8h1rGmYo/7jc7FF0+lm09+113f78EFX7TZlzn7SWnNWyq5+o+TVShqwMmGth2Rx26OeP19zcDDW2vXBKlTK6xl4eCRtSQxD+PcfK9zR8wp8MHZNDUqNbdYgqoh6IkEUoqPpvLDLVE7+2QjMLQMAyi4bR6pWsOPN45aSOqbcnhwqKdi3l/TnkzM3/qgcvr9/hvP/NzfLFvbLfqhkdh08r0egaB9bZy+3Cj1RulNawtlKX4MZgLa1uh9ehFGxms7+vo8ciluOM1wzZvSu7qMI929Qxss2M1KvTVWKXSeqcsN+QhIamQphmAkjYeSsaeVta2sbXKdRbI3TPdrVFivEnZK0SedQnDMAtsRwZhgylXiYbSoDR3Dl22LIcjGxfjoDOPfr4MSCdr3a9VkVDAIFFFQ9l+gHxeZxu9UkV8n1l9n6z6h6RLRUtHkjO9lI5KOC5zwO8wM+NzHfI5dByPKcWH4uPJsdt2OjYcjmuHBg+HZl08xdihCf/2br7Gw24eNZ2zpNGACUUQSbu6e1F3XCVlihZG79YeMEQwUM0Fp836syBo1F1sNOkaWNucrCUOzpsoSEUoJ/PRg6ghVHQvi/ul39gz56hpmRLqOuyQ3+60dgq6lwN6ELeSaehdRjazN10bvdfD1oxjnhzrSeG0PGvKmCa6pv1Yd4Ma0lStWwjqjuAFP/iiSEhFaZmRspDSQs4TJU9MeSYnH3N0dBzehz8e5rjTkr0p/Nn2kjMaXKJzxjWum69z+/XjuODjTutgk/s26KgClsUneXJ6Li7Q3XidcH2i4pqKUi6JMgtlzkxLYbpkUinUFh/SbVd0H+fYVQ18gXeFSiPHEEkTdWkaifOZiHHZiSKN3pJDcMRY8I7PAYv6iqmxrRtSImbfVsrm8IkArRspK+8tmetvfcXj1qjbB/yu/+HbmT78gJ9vb/nlX3obAqTGphtFMwnhahe+XDfa5vUO1c7j7UYmMV0LrTXaBq130k51xqPFKLALC5qV3CulTtx6pVqjsvqQSfN4esTVYko1ryV0jI++8ES3wjJDSspbvDa3rcKr64UpK9sK3W7M2sjasN7QtoXjikaHkPE5BF4jbqh2nO/Rq3Uzp8EPcszInocAatQo3KHZ/riNoX8VtDQ0dbJursHIUfB3wsCheeGHzbPEQSDYo9mRsQu7iLPiWSVsCNkzAnEndIA7LQDNQfo42IeH47LI8KKu1nFiSjXYogH4XOca18j5uhhJXuzrufnbDX0cO9X4LfG3OQlJxcVccziuKTsZQ02P9oMe8+0q9NAK9MDCGGN2DLBkSFVs61gS6qZe09KGSQOtDJKCnoxyRUL3M875/huEYSarNCZdPSjMxxrYiR7dA7YmA1XwA1IJ0lXH1eSbobWhcQ2juO5hlb0UYEOBBA96nFPhrSKSFUnCRsesev93Vaxu0BRpyc/jOAuioBlSJpeZXGZKmSllYp4XyrKg84Skib1gy+G02jPHFUH+qXqxby9lWmeHNZ7Xd7z+a9i+sR3XfZb1Ekx4fu2O1hxR835g293tXs4mwkdNydmFRcmT/5uy16g0CVIlqK+2B5XYEVyNdj6nyAeEMTKzOJGSghIvhna/wFp3GKLv7MQgbuBwlplrkBuJ3jPWKvRONljNo7YlC7/lc+/xpbcrHz5W+vohn34zIZ95zeMXf5nH3vBxG66RpjlTrj6LrPdGq16XUxuRoAsOm0BdOy1U731QJscYdbz3hO50+24EA7OzWd0zlzMkJF1C6BTa1lmfmiuzl04uDqGIJRZNaM7MNOp6oyS8mC3Vh0hqo8RsqJ0h10/rYb9ZwIYSvUm2G2qrp8L6XjuNW/MMy8Z4BzigQ3C18OTfORo6lRaOyGcsdTlEgQ95X//MYYD8w8ZSPpzaaCw2JNiJx6If9wdAeQZ/DtRmfHpcOOc/B1lgMAmH4ns/WZwzFwTbs679oUGBVzvqXPHlEkZa4twLGszaAN6DlPTsfMXaGUo1wgGrHQfKLziL38CY42YNsYZK9PJZ7FNkSgMmbPasS+lgB9tg9B4HySRuwE7KGn55/FSJI2J4xjXg1V0pnxDtxT1nPL+32AhuC/YTdzSkizVvJ+mbn/+eYvbscZAHhJqG9mqo/5STRmFKUe4YNug4mLzIJLy/ndbnxzY5PScvPPZ1bN/Yjmss6MbBVjoX0+H5wR3XtHDAP+NCOkEizxQBztprRH0rJ8qUYqhkJpdMKoKu5+bIUcc5FrOf86h0qWDSMXFhWqP70MDRbyIOPSZzyKN3otdk/ES/kh0R1HBcPga+W6G3SqpGCX+YxFiy8Nt/66d5+LDyi1945INf+QU+9eY93ps+zS/+v/8XWCtP3am0mxQmVaZlpiwT67ZSbxutrXvgvHUhzQmSsLVKo4P6mAQJVRDE6L3FxZfAXEMwqA201Z2wJHPmWByjUNTxi73iUGb3qcmThnPXwpNtXDSzTJ3clCl1knnzc1GXiJpopBqZTGecCD+vXk0P8oEe5z3WgY31ICeLdHZcEz7lNpsbdvfHRwZygsaGA8HawSwr7NxBO8yNvz5z8oARCMhoRj8WuAasoHeLf3Bo78www03a2B/89x2mSk5GxXY46zCocQhPgd9uy0eP2/jFO6wWZASN7DQo7yKuhCHdp4Kr6t5WYtbZhYUjG1LTMNpjZtnpiA3HEQoxQyl+h0Rj4rWZZ5oN/11+nfaQMvP61BDfPTdK+3Xtc8dG8GAYpj2ycV8fWp0NuAcjMj4mUtMIjK12SOow4IYr2Y9sLhy2dnG/rzhrODy20X3kThe0Gbk3Uje0d7QbGp16g0LvrSx6COmWzFQypfj1Og3N1cNNcRAwTm3sph8LJL7i9pKzOju8r2P7xndcwxkNSHBkS4YvpkHT7fE4PHdww7DcFaGfGbBznUvUT/xcmKfMNmemuVBKppZKXocumEJ3LJ1mp7R55FyJLYB0oZEs+UURkIqakFNyPcGaXYetrlFotmfGQOJY9GZsqmi6QF0pW2euxgP4ZOWnSv3iF/j0pz7Lq09/jv/bv//3TL/twvVTC//jd/xW/tf/6b/xhS8/8WRKrRsDG78+PCCr0t8a29PmmWU03KpAmoSHtPD49olulWpGKYXRkb0HwwJpUm8S9UPB9uQacmZgRf1zFW/yVlfgaHRs83/XBI+PDSsGs6HMtA61N771OvNmmZlk5gu3L5O6DzacYY/IA/E9dkgsfufpcSNGchC0bzudQ/F1UfB+HuPcJrivsRFkMxiuoz4TAZQMxzVDmlpMuPVp07Z3so+DJiCdqoUuLlfkRfIBdY+2evCZUvFz4iMGG+z5paP7brkB986zrOuRWZ5v4sEC4/iV04edoB8Zx2AYtZOUkWSCUeeHPGnM0+oBE8d12hkaZWnPPDSynQFHt8Q+xsdEYbKdmi6TwKRIFu+9ChIVBEFB8EyFtkN6yZw8jo1WhBg/JJ1Cp4jLX+mpDNGkezkg+XmUTUkNtEGVFCUCoYgy2PzPlPM3XE5DxKHkSNNSwqn8McKlqIQ+YUPUo2pjQyzHSBkXCC69M1mOVp/mTcuamHJhKsJclGXKXOfMZc5M14llWVjmyaddRPaeYxGH8Fyc8lOP65k/MNbDJ23j2rh/7Te945K7f4czG1nW2RnB8xT15JT215yd2Hhuby72yNB7upz5lJNHMSn6TUQ0xs37iBO/sGMBGCFK258J7nZt9B7MqsGOCggl4UMqG9Gki2Ep5nKp19NcQSmUQTTTJbtoaN3wUfGCWeILv/gl3p/f5/qbEt/y2d/Edrvx0Xbjt/6238IXf/EjnuqX+eCjxtY7WEURJnVCyjQXbm87rXbQhuZGa9EomhN5yvTutGPBx7RIMKFckNPoE0jxuob25BF0SDuR3GA7hKSuigGhN2dYNFjW7jpsWmHKOKNOEzdTam8U7Uxzpj8p1j0fKUkhphC7SJSfjGfKQyPAaZ4U7YzCQdqRF24D7jkFQ9LZITYDz8T2hiN53vOU2Wtomjqj/2e/1sWjfxveCPYsYmzCLioVNbLTeotIWUPm6Pmj5wL8sXsSWQsJxtysM8Rquw88ssHzZqPWuXf9HiG37hmAHnO1VOJYdUchLcb6iCuyiA1mXNSOzPw98fGqeG1xAmZBZkEmwSbBNJofzEfeV0tUU7rKfursAEYQcUJFUgs237mZve7w9W5zZY/v9gxaG0goxIgKWZ83SDuNnhM1/AhS7pMTRchyiOsOF+IQ4cbo76R5O46a19JTiOkiRlYoKpScmIrETZmK923llFCJwPnudN43tO9/noK8r7idndavAh48b9/YjutZN//p1u5ec4YBYawI384n4AX677OUuAPmNZycElkzWTNFs4vvpkTSdKhbDOgovtPCuJmMYm7Mk7JR64roEV/CEhGpy0DFlGUcl+9qe9+VU1wda1dcTUMlGGxt5RLwmJnyK7/4IfP7b3n1rY3Pfu4383P/5X/how/f8u3/l9/Om2/5NB/cQN9+yUeSNC9Yz0zkLNhcWFlp3aA3euq03uIqc9iUVtmqky+SuNK7JAGLut8EOgVpoye0KX3MOoqihUV0f64VjppFM2HroM3Q6uzMri5lszZlbZVinVIy6y1h5gXlKfl56TH2Y9j2MTJeOJ3j821fF3HFBZNMUtQq4j02/MjZAwzhOk7PndG8s6ZfGoDM6druBCwVUJgNJQWfbaCxg2pn9ftYtCe2hIkP6NhpzM9SxGOnfbc9m6Zzoq/Hvp6h9lHEOW/ja4WjVnMyVDIqWSI+wNTCVMfrRg13DF41ae644jeMNu4Owc6LFpJkMS1YYBGYFSsCxQlYm7iYlTutTJXsk8l3eaYwhOLnIEkni8U05MHC9DqpBc/dAhL12qfvg2XfB22gLZqpJTJNFX9+KG9E0/LOTI0AZUQrTovwe0nEWzYlauSRLUrfXNw7VGykp7iEhESMPJJEVshJyUkpWSlFvdG4JB8aGRmp7Av+OM3PF+/pwa8W8rv3hL+RcfHcSe0RMEcaazyn9N54fiB32inPou2POcTzyTFBLTGXhXlaqaWx6MosE00rNVVufUV71G5M98Kv4wBeUpEOPVe6BAupQ09C1+DuZM+6nCLsp6lJp6dGU8Nyh2lDZkizeCYDNLonnyVjyajthj52b/JX+KUvCv3/8wW2nPkd/4f/Kx998JZfqL/A/+O//Gfe/B9/M/LpT/FLX/xp1q1Te2erjaf6yMTM5TKxLRvb2426NtQ2ZPGpx09bZV4yahk2oaWNXrpfyKnRtWPJ0EvCkkMsivfF9BXayu609lpSwIYyYCp1ssDNHBattaN1Q2djWoSmM19ujadVuDZF0+yU6J5Z7YbKRpYbJcf7t9Dcg49dgAaHHl/0pe379wxGk4M1N9bhaX2KBPQXxjfKDjtELUFcGF+6j5EfaOEIngREakTewqRP+9fo2SFWGGSD3fkkIeftRIwYGZY79bHj+66P/RvX0XBeI6s879fdNSKVkE3yXI7ujkrHeCAZornJf398qdex/LcbPma+mflgVpEwxv6ZzuILjogokkEWoHi2VReliRP8nyisISMcDRE0C82QaEnwetch0DzmnKVYEE7q8GY/q81JFG3sezjPEvW46PPSwcYSzwZHg75MsvdYnkeYMOPN0wUkgQTZK6u6upQYObneqfaQBKtG3zK9Kr0nrHtPozvM4t+XhJQLZcrMs98u88xlXrguhaVkSh4U+I9vR9dhBMVHmviVtzOT8Nd4+8Z3XCOqu69xjQvvniUIx8Ecz5+HoZ3fM7ZTRjYERJOo95rkwlQKUy5sOZNDX63TA+LgWfTrF7N3tPeuNDVUGrUnJLcQ3Uy7KG1Wz5QMj5iaBUSYjT5Dnzt99szLumEmtNpd0kWEpDNbfURuRhJhzsLTrzzy3+WX+cxv+TJv3jxQ+6f4f/0//yfm+T3KPPOtv+PbePszP0e/bdStsW3eGCqmzMscWoKVWitanVWYsjhEmIQ8JSeHTIrO6hRl8cZoy4ZMTudNKpTUYIX+2HddNcHIU6Y1z0pFXOpqZ6dFg6V04VZxKrc1yuzqJk0Lq12YJkhWKJax1ehNWIHMSkqdRTutCi31YIYdNAY7jZb3ukRkWsMRRQDkja8BqyU5XaxHxjFIFYKM4dGhc2d7xO1sLTut68hERifraQkdkXn8c0IKpAXsZcJo5man7cct9lekIdqcIBA/SDj9BuMIIvYs0de/CyRzZGLj2pCxa/55OvIs8SwgxWNZ08HqTcMd2f7O6Ll3WHA4rBNjp3Fo/0k2bBZaUmoqrFJ2xcUbs2vcW2KzTJPMIao1ZvKde2b8BAz4FfNZaUK0UgyFlOhVk5hOLlndmURNTwaBRgxKPJ7AStSnkx3zt5L4v1M4rCzkIXQwxiYZXn6QhvUaLTFhS3ry/QrX7i2FcWx2iNClnZZpYpkLy5JZpkJOOep/Y5PTVfDCo/fO6IxYnZMCvfv713j79eO47iEeOMgZ59v5AJ9hQE5/32dZz55zA6MWfVbqtNIpZ9aUQjHehXdljCIZuNT4Q+PjuzOSXHA7IB/r9GxYi9pVQCsq8bk0LEHL0Av0yei5n1QrCKHN5BG8Fmp7QjdXz8gibB9ufMhHfPDBF5mXiTevX3F7XHn74RN5zrz+TZ9m+s+/zPq2Ya3Stk6loii5TJTs2dy2rtRWnUlVEs2672cRVBMSbQItjKUk2R0XWUMlJNFTJktjqy1ET4U8C7aK97ZEjcDUMDmGfTaErcGK8WSdV9mw7MoCzQpdvY5oHSw52UTUZb1UNrKFqrt6ANH3Is7dGuh2xB5wygx9jQ3VhjPsMz5DxviWWI8jGRHlmfLC/p7TzU7rWU4owsfqci+t8VGbGxneIJOMTC+78ZTIFl3ZfhjbWK0xamPU7GR3XLyIboySFjuzVkKJQaNWG3MPJKDicKqWHPqWkWbKyHRkHH7/fB3TB0b/FgHBKb0omxRuMnOzmSruuNZ9nnNiI7vGnnhO5bC8izKbDMft+3EWJ1ZCZLf7yTsjrRLOgexOX/YJx3Htqxyw4Mlx7UHEmCCS3WlJAonpwy7kPZx/OA9rYN5L5bdhTCSg5IA449hI8knt5cQknONWcjQcn3q39gV+t8m++D721Mc3eeE21uqv0fbrw3HB4aTOtalzs+TQn7PTewcdfhTe4bnx6Hd/j80EtcwshZ4atzxzmRN1TaxzptyEWpVkiUo9qN3+VswgNejanciBOx+fGNzo2o5OeXFyg2oMkJNKzx2bYLuAFP+wFIwpgN47b9eNmcx0mVi3hd5W2DYeUkJap7bK//o//2e+/f/87Xzq9Wu+9XO/mf/6334JnT7ks//jt3F984rt0agffUTdvNGxA1dxNlJKifqFStsqZoaWAjkkRTuUh5mujaqVruZjJiY8+px8n42O5ES5KOl1Qd4++Xyt1kgzNFX6Fth7CPc2C53FkLyptnGrgnajdnB1g0KjUc1no20VlqIsuXMtwPYWWz+i3z5C9OaF6yQ8JYkay2kddZ47rd2qH2tGRpNt4vmFHc5H4FAJGBnGs+L8800GQeSU/TsLeo94Dop49Jn5/treuHrUpMLAR2P0oPAff8dnBkS1T/+GCDbiImgE/Og9VGR5hmLsxygEqaWJT04gocnrNBqTFBSHDBlN+upwt2cl3fcr6o5+KftJsCGbZKFsodBFuTHxxMRqE08sbCy746p4XavLGObi15TqgEZb1KEzUBHxPsAkfhMZSepwXGkPHvbevizQ1NeA+XkY2YkNtRU1yB3mUxYsAQsOlmWozafiCEZKjrg4XCjB8dqcYdygNdmzUuvJxYKlOxU/GWQllcI8T8xzYZ6LZ1vTxFImlqmQVCP+Osg+95uzC4/JhnsG/knb/w+zLfhGd1yDAQgHVBid6LtxOStYbzw3OqMGkHk5KhjO70z66OxiozkVptK5zDPTPDGtE9M8kacbpTZ672xbOjTIrO2U1xaQyc50a05H7ii07ky7JmjWGJ8CXZzN2FOQEqhs3fH5ZBupD6kahw3X1nncYNaJ2o23t43psZFmvyh++b9+wJs3v8T7n3mPb/sffiu//MWf5UtfvHH76f+GtU7JmawTXTasGq1VqqwugjonLpeZp6cnWq2sj2+Z9AKavEhODdgj0+zmUX5Sz7ZSj/qVeUSO73PRwrYK6wqPa6XFuc2TS2oZBi10HQ2wFrCSURs8rT4huaorZVhOrmlYEjdz1dzUN15dHiAZncZTWr0PR4ykMF0mSN5X9bQ+ea/NWAt7M2zo9J0z9WiK3aHA0zqzsd5GhL5LH4kbmME63YMlf5MEu5E+1q7DcxaBmYysbONgN9Z+ghnlyA4b7qxa7IwEnDUyl6GFGUKzJnIyVRZG2TM0NUjWvdazRVamgjQXcU1N0a6klg7EQP0577/zte+9i86M7YSHz4KUkGczdQZgDzspzR0IkRuJ98B5DWvyLBufUYU4Uy4RMxjMEZARP7jmrBOeEkY2wjm4mk0WGbMoSSFLRcNryyMDLcdpG21+nnkOFiQuQTYg4YxT9sNxjf6sHW5M/t1aBD05L9mlq8L4dJcjcxKIa1mqKUohiZOVVL2XMhVlnhwWvM4T12VimRPzpJSEU//9AmSQM45Y/c7zCCFX9Qle6StlW+ck4Cs5v0/YvrEdFxxQ4RnmO8N/Z6dzoiHvdbCzI7vPmHnhc/fP9wgyJW9ALpOPCcilUHKi5kTdmnO/bDSNHvvr2mYBhWBOIxclaY/6lwUpgF0HUING7HpiPghvr3kFTV7NC+EdF9S9bY0yF8wSrSvbFnWoDP2jypd+6UPIyuXT7/sU5nrjw1/8CK0JekTN4gTy3o1G2yPnMhe2umG1UrcNrdkH7VkOmCWUEGCXKxrEBK/hnWndRike+xnKuuFphhJakGGle0NT0MubOxuJJtXb1pHmGWsTJ8b0BFMYHhVYrfsAW8lI8sbxnj3al+xFdekO76QEfUCAwSq08/q6z8hPF+W+lM4XqlgwJtnrdeG14xDo888ZznGvedmehcl5LW62Z1zP1F667XDmXvwYTiwo/EezbwRXp901vA0DhJHsCB5wFOrepKviyijaldwypSdSF6Qmn7YtwSTMydeDjMnjbir3Gp65Q3I2qach1pOri7jnYq9DygDz3DFJ1NE8AQp2ogwVkh5kieFlvBrkEHwjmUWWdTiqY95epwRT2JqTKnoED1IimJIgEY1jeTIdtgcpHD1tAyqEgMHdcWkENRKDah1OjeChu0ux1A7ouIcTM0HNG6xNLDQUQ2k/K1OOcSVZWUpiycqU/Dgd6ipHs8Q49+90YPfB/b3NlNO/L9nUX4PtG9txnTH2cXGOi3IcvHp3O3v5gBv2zOu8jYN+zzAc1OjuCzVpcsbOsrCulWXZmKcpSA2NtAXjx8AkYUFjc2Fq2xeGa5x1tg5pXBmIO4Cke+9LGU25YrSbOtOQ5uxjVZKoSx6h9AZvbxuXqZAkYTrztL712pkKF4Ff/K9f4lc+uPF/+j0T15K56MSHX/jAdRU3SJLJKaSgemejYhtkzcyXmdpn+hM8vX3Cbo/0VJiWBWuJZF6jy3NmkxZSOt0bLBWHtgYM1Iwye7Kmmthapq4b1jspu+qFWmPWG5JSXMjdpWpaQ6rweNtoNFY6RaDNjTmDlY7mTjV4tEJ9uzIDi0xcrpnamycqG1jzBaQiTJNQm9JCPX4Y92dSSFWilmRHPWnAQLHGBqw3nIjXOAatnuPJfvf6eGqvqQyHFWQje9a6YTsScB7NM0Rg9yZ7haEUQjpUKUZa6Ov0MGOVY/zkaGIWjCmtlFTJpZHmTqqJ1DMLC3MLx7UBm19IyjDQ0dMUEZyFksToU5Mm+3ifLuHoerzH8iGvNA62KDkgFidUbH6Jq6vSGImNTjMN5XT/BaOX2oWKWzQZd4oYWZSUIKsyqVFwGM5JQdWDmbDIloPhu57sBh5IeMBmTrjaYUOipyt2QDTYf+z9m6l4W824jbYLb5Zu3joSRCyLCeKJmBygPbQUhRT9Wpcp8TAJD5PxUOBhEuYi5I+x0Hw7FC2f3/yX6fNg/is5pXsnd29/v87tG9txwfPM6twIqnePny/y4ZDguKiHYeH07/k79ij49J0BfyyXwmW+0JbOtjaW5Ymtdmoz1ttK1yHJxN6bNGjfHhQbdfQwGa7Qbcro4teQxynJiQcWi7hZoveO9UZtrqjR1GjZax+S3DV++NETl5K55Asf3W6++Htl0oy8Nda28V/+77/At+aZh+uF7dr48i890VbDKpFZ+nHabtUHYxooyjxNqKoPpGyVujbksZJTw0LXMS+ZlAVSp24rpOTF48g0CYfWN4dv5gQ2w5aU1gztG/QNpVFKJ9kx9mVMDh5QlcNHQpLGrXZ6a9ha6bkyBVSTksYsq86UL6TZe79SUjZpVKk8Pq5IUbQKWkKCCqWLsNH2RtRn624QLYw9u9nb0KKOMdZb3xl+8STstHg5F9VMjh4xTo5rZ7iy18POb3tG4BhB2Pj+sahHGrV72WFs4zFPk2Pel7BJiZosKMmVHKQy6UbpmWyJqxXmntFQl5ctnaj9Dg92s2CMxtengEWz/w4VRYpRSnVnGQfunMkQiJuIYdIpIxez6kScONCdFMipsHV3vrZjtgF/Ysy2kqN/a04Oo2Uxirpzk33aQXJ1/sn7+HZBAWLy8Ugx7KRhGEHNOPe7PmNk36Iu7+X9mM4q1BIz+rIjLT1+eGuN2oStOTxuIysX7y+VFJPHZ6XMiWlOPCyFyzKxXGauU+GShaI+V9s/1ksU9w5q3MbKeIlt+FXVu96BSnzzQoX3B+Klx146aO+6wcup7UuODM+HECXlwrRkpq0wrxNlnpnWyrY2cs4+8C4wdl/8HOoCoQYg4qoJIqPJMuZ1WXdZHAgoRP1ytFFHUHpTWvVxHn0UPrLDJr0a6+YKGEW9YaTWldUqeTIKIHTe/sqN+VWCKlw185GNsd9CLjNb36D65/coOmx9Y8relzMvC0/rW3rtrI8rPStFzUV1NwvIzyEgq17Ldtuh4Xxk15dTEXI0Lbttb/TmvTRqDenm2ZxPxfTLTixUS/wEmThRxEdMNLZe0e5ZVytOdDERyDlqDx0qaO5o9gtfbr6vlrobEw3hYWlsWqnSAtLFHcwJ8toDpMioZKyjMGCiXqPp4TQEUO17ADV6hCzOu53W3UuXga8p/2P/rvH9A6IaLMZ0PC/nDzEQ7ZG/uLOS0ZwdijCEnmaKrF0FcjZKTxTLFEte29LRexVNsbGeWhesu0rM2G9arI0eUGH2vRIxkh7uoAf7zUKmazDtdEichAEf2o3jQO6OS11BwyQGIY5jBD49IBzXlDpZneSgAtJ7tJoc7NIRGOwZdhow4YiATydrOK1gx+69iSIhgIs7qZgenorfNPljjnK6XagWk2VsIMmhdzFGw0iC5IIIJY/pxj4kci6FeUo+U1BGTWtfnbvzOoDDARfKfg72O+N3n0s177CTzwL+e9v8dW6/PhzXfcp6TknfVYcYWdnZyIzthcBiP1mnxb4z/nJhuhbmPrHUmeWjme1W2aZGnhyKajSfPTWyLT1EOMei9JlNfvOBi50aWmQpujVTFK1zV3JTbz5syR1X4Pp0x/SdfQe3CPmTdK6yeD9TNebSmcQoGF94rHzQViBxEaVE9UlEWJYLaglbgxSydRfONfPIO2WulytrXVnrRt2eKKKgk9cBsvegaQJyoTafySVJ3TAEbVfPxlAVTV4ITtL8Pc1HlWhbHTrNQmvOpFIx/wzw+ySktzi+Ln1VW6O2Su2JXMCyueMqgrVGkwYqpKIs14Jt/vnbWyPlzDQvzMuCSeOj9sRjv7HautegdnN1H1XqKfUagwjVxVVbeBuNWhFjCOdYcyeikSC7dNS+dgb8eFq0Eu8xOBzXhFPiT8SQHV4/XRcaYZOZ4kKtPoZn6P15rVAoKaQBFaZiTJaZLDG17PJBTUiWKKjXuZqwtY716pN517B6EhlWjn0yRdKRQZY5ghI6PX7YSAg9mHMWoARRB5Ooq7EfV7/EhTaYheJ9XCZDSUTcaakzCYt2L0GGW+it0atnic9IOXGORsAwHj9KAHe2Y0DIgaCIDHk3DoeVlDw5qSINiJGwBRhrdcJKNaV2bwlxyTMXg5SUveE4F6YyMZWJMk1M08w8T0xzIcc1loISOsR0Dwd2X9+S01/Dfslzu/kSWvVJjus+4fgat29sx3Xe7g/OOeh5ycGdndt9lvUSzHL/94hmPRxlulx98miD64c32uZD3W7rU2RcnUZzopfY810LmZvuhRS2rohtmHkTc+oSRISMFq9jFXE5zBHjNZoPnIz/moCZOgraYF0r/WbMr6/0XmhdyB9+yFI7eRJeZeXtL9/oJhTJLOYR89YNW1esd0hez9tso63ed9UNSs4sl4U3rx94e3viy48f+XMf3ai9cU1CT46RiCpZHfZprdOLG0Uv/FfvRRFjKpGJqFGa0/GtbViriNSBaWG0gArN62DJe8imJNhtdeVsdc5IMsNqZ60bkjqaG5drI5s6lDkXbEuIGnMxliXDK2izkWxxZ9AhlcSUCg9y5VeePmCTlS4R5Ueh/iBEBCaU7YAGhT0LeLb4DHYZKHhWW/WkwvY1HD/ft3EVi9/fnd74NxnMPCMGHIMd5dl+QdCuYx9z8t43TYWiU7RmKJNUZoFZjDkrU1dyQJ7ezyVB8XZUIAVppDV1UkF1nFBRZAKtoVsoSl+DCGRGMvFzlTzLGolSEq85SQftAt3FeqW5g/fq6ZEGiBgpNbJ2z3xCmcLR0FBgJ/gyQeIyoHXX5uy10279GKfSOfQJlegZHKam771nGAcRA/Z65ajbSR9ICuTsDkuzO7DR3tKks5lxa/BYlceaeGqJ1YRKChalonmCMqHzxHRZmC8L18vC5bJwuUzMy0RO0/M+eQiizCd5kXM6ZR4tPIOdv8Jb7xOGc1LxdW7f2I7r6/Hi987snHHdZ1T37zlHTiPKin4UzYlSjl6JdS6s68RUCmvefPChnYYEij37+H5KASttj1JTbbQajCk1x8Rx3Dur0lIiY9SeAs7o9Gb7FeLkDvGeqm68fdxYUmLSifWWfQp07UyzsraAIaSzxG/tQK3NG6LNiRMpem22bcN6c4hnu1FmH4FyTZ3H+kjvsG2N9bY5Sy8LWg3JFsoZmWYVa90JccGIShjavQtn0s6rWWmPjb5tNDbM6m5YDIdZfdhFG+AUxTpGRaR5rUI04FUJ6KfSqtfkaII177tDvQVh0sycCgjU2ikt05pRa0OKkjJMSXiYFlZJVGmsUulaIcZcGDDGVMhuKSwEXT2LcOcTozJ2B8VzxZfTv89YjbsyrBu/c1T/bK0OZYbEofIR0NWhpjGcmYY9cjSBpPvkb1I+HBeN7OTxcChB7IiLaUiYYb6ORQRZPVuSIBSMEUAlBqqOvsUacDAbmPQ9OxyMTI0+rOGhh7ySdPHa2p4UnQa7SDilFLT4vRP8uYM7rkkLaLN5gFWNVu1InCEUUeyYhmwjjLRgMB/GxO95G4dGdi49altxKuLKdsbrAEINGkY1YevC2pXV/NZwJZCuGUsFSQ5l51woZaKUiTzNDheWmZJnkBSh7eGqzrWtMxVDTn+P51wL9eyJ72zk2f7eJwxjXZ/RiK9z+8Z2XGdHde+4XjqQ9++7P3Dni/6laOL8+BnfVVBzhfhpyszLxHzbWG8b01SYboWWO7fWUKvhpI5I+wiwAyG3Tusd7Q5Vteo1oJTiwhFQjSKs+M2V1iPS692bFC2cjVe86QKPTyt5vjCXTK2ZrW/IZizWmaL4ccOYAFNhU6FtXsdR80Wekof1m1aaBf6/GekykUvmOl/YPtyo1mjVWJ9W12jLimWnmbtOYfKGa58EGI2g5ili21BtTLnx5gpbq1TbqH2jSz1NmB0XWqNb9VEPphRrmITjopOzzzaTJt4LZI3eNuqtQlesCdYzyTIihWmaKdkbdWRrlJpga/RNkGjeTSnxkGaKZFYa1lYfJ+8H3c9rMAgDkdqbm8X8nLqVjduZvRpMQVemtzsWoTxzWnvmvzulU0Q8sqocz5+fG3WXZNEkK7BDgg5BSUqY+r+U5IooKhSLUSOWMHEkQcNxGS7RZYTgdAxX5TYOAl7bFGfRzZpDi5Kjz7F5RtXFkOYwcofIqN15HRliZGvhvOhOtdfx/pD0cLkp7y1LzR3XEK1tYRM6FvrAo87sEOGYumxxePs4bviadXZmMGSHHzQYShtj/0YHhLTh/NjFhscwTR1FyH0/jNolHFZi7cpmA/YsdCmgBcmZlEd7zkSZYsrx5E4s5QlXDGnPnNX5vh/RM5fwPoo/2cLx772zGv/eZ1n3TMRvWscFL2db5/rV+cC95Oj63d/pdP98cvT02L1zi8dTSUzXmcurmVorvTUebxdq9ehm6xVrJaD9LXbJDsgnVFV7h9oaCGgGVp+ADEpRZxylrORU6C2aRVsPG1ip5kQDE0dlyMFMFGGtlbfrihV4nd/Qnj5k7TfWx065OqtpNY/gl5SYpkLRwhc/fOILHz5yqzHlOBWWRbg9PTlEKcbb2wdMS2F5mHkzvebx6Ymn2yPrrdI/6tS+cSlXB/UxNBslZ7q5AkaN+o0aPkbCVpJtXGWlyo2eNmxu9NyotbHdKr2HjECvfvzGfCeBORmqHauNgt931Qb15s3aqWulrfjk46eVmYJmmK6vkeq0+3RVbAWyobOhFw0GZycXIU8TS4JLWvjgUVjrxtrWaNa0j68ZO+Ao0slhDaWXBnsVvuIU9z0Lk6OJeGBb94KtZ8bi+HdIC4XjGv1ULg2heHE/kQfpIdKAnjJoQjOuuB4ZYmqgwQbdwtuYGJZAS4uZavF1VUhPAreEPDr9PEtCxGHjSy6kmNPVxCWWqnW0NSpKl+bUdot9F/b5VgO2SnjtTYIko30wVmEQSrIUiiRXWxcXv67d2Fqj1TXEsC2II6frcjewB8nGhJihFX1THPHHHlz0cFBD+aSG4+ojEbZAABTthWQOtyoepPhHGM0aW4dbSzz1zBMzTzKxstD0AUszkhd0upDmB8rymvnywOV65fpwZVleMZWFlEpYHGcRjl665wzCdziql7Z3vXQcg7ONraf73/SO65yC3hVIP3E7H1C5e/89VHjOvF4wQNgJphGHv5aysM2Vumwsc2KdldaUaS1Ua8FOcuWLseJN2SEkrNO6QBXSKkivSIcq3lWPmisUqA+Qs5Royb/DGVNB18ZrBWLRSBpF7nVzpfDLNaN1wprw9vaWS2/oBJcp8SgOJygb69poWz3o13GMNSt5ztQKtVW0wrYJrJDKxDwVRODt7ZG+dTbd4MNHlocZIVNFfXJwIrI4X+3ehdZQKto3tg8/JNdH1/gu0JOrY2y20asTL7p5oCDqlk1VQrS9e0bQ3TsIzhZL6tClrH7+ezOPx5PPHsuTZ5WSQScn1aTJ2Z1WCNhWaFN2SSuFnIVLvlB6YeoTtW9OX+7xu4YGH8YunhvrcW8sduHKI7saFLJNokfL3KIp7JZ14GBOGg0pJ29qPQaOJof9BjFAB19fSHkMWEyOyllDcOvag/bmlOzou4uLx8LjymjAFYIZl9CUkElI5mtYTaPG5J9pJLIKRZU5++tN/Lhak5jkq2hvNBE6LXgrQ9yWcGIC2UV7NfID68HURYjOZVSVpQfrsTvE2cEb1ivIKvssOYvz4upSI1uOczWSIfUeriZKk+QaiHFxSGoktRhrFChJx/evjexrKIoEMQNXzxenmjp7F6OLM2G35rPotqZsllzOSouTMlJGykQpM2maHR6cF8ogY0wOIzoI33DtmRAqPoGBz1uQ32U65f6Bl9ErOT03+mfvocLK1719Yzuu+2zrPqM6//vSe8bf54N8z5Q5v//ecX2sNuYKDVMY7XXKzJPDh1vNPmyyuRitdB8Gt9M0bER4EsoZ/qGtSRCTGyklem1IhtTdQCT1hVc1kcQnlibTIISE8zJBo+9JjGjShVUaxaW5uW1C0U7uMKlwSw41Yi1qXD3mgkW8IDhUaY6Z115pvUOt2GpcSiGlxCRwqze6NdrWsaeVVAZD0qM+Z1lpwER918pTM6R3+m1F2SipcZkKrXYqndwaXRoNNzi1H/L/igZCF8a2NYYFSdp9omy80swjc0HIOVFKJmd1iFRx9fGwliJClXoIo05uDLzOKUxzjsg5sXWltkZqDXp3lZPeg0Tji88GnARHM/AzZXiOCz5IAa5wcQRLO/yXcRizuDH3TMr321J22aKAmEUTg56nOdRYYgDqgLOMg2gyCA/7Tg54l6gfiZMdNCuas/87xTw5xLOunTWqUXcUJtWYEJwwEUQGkO7XBw480ASve0nUh051OlWX9hrxows1u+MaFHuveyYmSzF1WXcFjFQ7solnOUF7B/ZG8QH1jut+z6LVM5ZK8mkFGEgocFj1YzPqWfh+DDhznyXWZJ90PAZrWrdYAp0WjquaULuzCUczeJeMhePSPJHK5CLY00SZCtPkTivlHOdbA8j133dmE+60+he2FyHFsx09Ey7OtvL83FnI4Zs+44J3Oy25+/vegY0s6yWndabJ32dh905r3I8nBWEuE22Z6W3l8fHiht+E29ZCecLoW+iz9erDGGM/DQ+qXTizU6vGLCBzlYhqsHVUzcfbe57gBdqYX2VkrFfH+rv5oEb1aBY8u+i988tPH/GpywOXXKjtyuNHHzGtGwudV9fCTYS3m+u4Td2zNo8AbV+DOWXvSVLj8fZEs0aRzlpujrUX5dWbV7xd37K2lXprvOUtZS08yMWdAY7w50uJBtvmUWxcWKpemZgm5c2nLjx+qbJh5A5SFJsS1ozHp07fQqTXiywRBDQsBEhz6mjfKFIp0jFLngGIAyWXeeZ6WcgpAdUbh4uQpmhuls623bACNgkyeezeFZhgShrIiDBpib408AGbPt/so6e3zrrsPdbAsbQAl8YKosTuK9JpzZrsjnOHCCdBF4ErWEpYSlQpjjXvKq7e65NyIuUwWuL9fS4jJtBuWK3uJMXDZUdwE9q3ECHuqG246oT32mVVF4RNDmGnlHw0B84q1BQq5zJuyXWXRZldURKAhpJIVBoVr0sO+veu3i/jona4UUnMybPhbgbqdanWfeabmNeLU8cZjuZMD+me2VoVHldxeL3G8dY+MGtvjNbTOegS4MBJvZ6DJepTqKMuXIOMMeqr7fhoz87keLx5NtnNdtmyKsZmibUJT024kX1si0x0nZE8o/lCKRfKdGFaLizXhYdLYbnMLMtCyTlM3XNPMa6vMYb07KCebwec+DF88N729v0tz53WyLTOGdfHRTu+6u0b23GNA3OG++69v73j/j376uyc7iHIM/VzvO6FWtgelUqi5JnL0rleb2zVi79Pt0ZthkgQUDelopETOKXMxKP/3t2AeVNyAu1o20gte7FbO5JaQDxQutJ7hibU2km1B+Rke++YSXcZHbMggMCH9kidCq8vC1utWN3gw8psPsfnqsoHzWnJFzV6TqzdpamseQSsCFMSNm20Xnl6qmjaXCh4Ss401Au5Z95Gk/LGxkcfGIvN6Ow6gjxWV8jOE73P3HpDemOWiS6dtlX40oa0SC9Sc5HQgMKSZapCq3jjtlO1qM2DALVO6p3CDQ2mGE8g1RUyZIVJCrNm0u6cLaR+fPhlw8fLNzMf5Ed1kd4ManrUYDBykZDqSiSZeHC5EKbHC0+31RmX1UfHUBuk5tlSw63h6s3bthk9NSe4DNudJTIsgYv6IMIF5OLzyJpkREZhyzPuNNh7EvJNsZYtWGIy+gAH37ubrzMZxbeBERspmApCfC4jo/BeM+0uAts6sBlpFcaYeemKT/BlF79WCxYjULprbgqCiY9uEBHqFllzwMDEa5IIJa7nUOSCkUWEnh8IvWrAY44e9JAa6xWo6uugifeZiYSgyZ5+xmo4ZLK8v60xSQttRc9JUvW6nuzqIYJUkA3/Nw5xQskhBqy37LBnBytGS0ZVqMl46srNMqsVGk7G6GmCPKEBD5ZlYbpc/bZcKfOFeSosBUpkgvdahPsx2uHCEbG/e3tRPYOTvbz/e5zjUeM6v+43oMIX/r53WC89Pja5e22/e2ws3LNze0cdU+JJTZlSJpZp5mla2bbONG1MtdKts7aEVsfaTXpEawNAgiEI2mn07pBha41WQwJGlb51F+YUp3nnrlg3ck/OymrmbCja7ry6huBodxhlFV89l7mQKLRurLdKloYUvCmSHXFiGSMcZBSx3S4kdeV6w6PdusUVqq4knrIyjYvPXHFiWzfS6l38OcgCoh6ddsk0ClUqNyskqiti3yoTHNE7tqs7aIraAe74I2HZI3EVo9BJrUPt9BVkFaS6FUoohUwi0asb7pG1muEZUgqHNujrsPehORlAh7j7ri/pUj7ZRWZFmVCaZsgVWxv01SFWqajPZ3fhYIWWegy61JjG7KtMQ0VdJsEW8VExBbQkV/gYo3Sjt0qkk2SggwMOO/PHTmvvfC3AHuioNofqom9uzxTP10X0ViGEU+hIVaQZgx6+y1EZDosFIjAg0xT75ETDUPIwQ83ZcAT8J6Hurud9EEIDk8OLxalsOPTsE5klyBmd1nrUF+PW2aW7dq3HO3tiDK3JyI7F1yEGuqkHlzUc1bg/Pj+uPyGyrSoOVab9EDLYhE1thwp9tKUrf7j0VEZTJpXs4t7T7LT30XicfT6gvmjUBvR33D8s2LEWPtmN3W33NvddMOFwXN+0GddLzuhMIJC7v8/v+6TPG9u9Qzs3et5naec3CWjKZOB6eWDdGq3DZa2svdJo5C35FNhQOR+F0tNgI8C1yUCduKGQn1pQ06NRNBW/wHsiN5Bu9NAwJCDH0ddlas4+7O7owDOn3owP0hPvXWZAeXrc4GmlTI18Ma6XiTUZG8KrSUjd0IBiBmTSgXme0U3pZqzrRscNklTIuZCnxMP8wOPjW7bqvW1Pb58oveyq2Fb9s0rKmE50jKd68zEaJtja6dKZpDGJQ6YjbkQ7ksMJmtdTrEOzTu3uuCZxQ9o3oz927NF7y7IZyzJRyGhT1scKTejN2NZObT6eguICx+O3LVNB5kKXzkfrR24EDR+OGDI8qLIZ1B4kiZxRMik3ptRIvSCtQt4cMooaTHtsbGv1TKPgSU8HUMrkCh+6JGqp7lCT+QBOzXRJ3FB616j59FhVrhfoBKGEkajSo4HbDa+ERuHAKQUjWSeLusOKnoy+B3SjkTdQhx7rrhttbUdx3nbGvduz+CivA2aHsmOwoeL7k8hOvDGLgCSMagt8QwzrQjWNa7G7neyd3vxmFaQJK5UWkKXXNh0yr736+JoQr9Ww8bsslaOS/rt6x6JnjR59lQn/IVGjOhwW6Br12obD/KOHzVyeyYNXgexZm3W8Zotn9018ykMzh/RMRkO4r6M8FaZpYpoXlnnmMi9c54Xr4soZJZU9NBnbyLAO0zZqHvfG8UyZ/5hpOu6fndL5NhzWmZxxft03bcb1lbZzavrSgbt3Oi9lZo2jlnDe3um4iGK2S+ZM1yuX7orSt7ayVQfR+9YOIxfaezssHJGimTs0rPp4bnNsvDe/cF2VfGiUeS8XJpTq2ZDG4MEhH9WjWcX1D82L8XRahQ8/XElNXWDUXvP4+EW2W2NZN65JybOyZeUJXFk6u9jv0+piwpvhV/AEJOFx8+LybXOyRtWOWmZaMteHhdoyb5/eOmFhW2lvOzOdsmRSSmw1KPyaWcpMDXJIsy2MbkckSuNWUfPx6mPGk2CUmPBbgSYW7DzDnjo8gjwJ9rZ71CuwzAV7dKe73jaylHBcG1XcaTmP2Qc5qimvLok0K6vBB0/mmQV+DLbmdRpvfE20GpCwZsr0QDZ4a4+E0hRqLeoRCTHhbb+5WkpOSHH4yQMOpYyWiFmpqbHR2KRBjaxVO0Wq1zgNh8z23idjY3ZmvQQxQ6OhyCqDuRc4YmSQDSz6jCTt1HRDsBTMNpEYOeOOq1WD3kPBXL3cVpRUjJ5bGGljw5X/h7iIc92dOdGs0sT/3ZrXBZ19G84Nz2qHAoiJ0bbugcnmws1s5hmVKVVkhzTNfIRQs06trtRhI9EesOmQ2GoeGNhoQdg80NpJIgwIMJzTZrtav5p6C535Xkvcz5bQFtDN01Dp8NFBVcJ5idE67rDEVTU0JSRndJmYF5chu14uXK5XLg8XlofFWYWagrNTT+bNc9rhV8bgl8OshczVKc0cc6BHTexFZ9X3D3zuuF5yXmP7piZnjO3sbO7vv/SacdD07rUvRQ7n2tknOSyOx0cfjGvczdTemOeZefZMYy0bJWWn4PaOtlFRkRC9GIwzhyVcMkr8wjMXEs2S0NT2hkzBC8FJHDv3GlnU0SJCHFR8iwZWn+XjF8eTbljKaC6ILPS+sa0rba1eQ0p26MkJXHLMSRJ3pm7n1OeRpeLNxbjB0S1sS5VQnkhMy8StbRiuSKHb5pE/PjOsqqFmVBVmTYjPeI/Iz7MI6U7dFvP+n10xRMzrX3GylXE8E73nqPEZVqvDNyKoJfpm1NppWwdx49pDaHdfG7FWzIzbraKhIzfsnGctnnEQbE4VVz8YegW610xlv1lArmk0yebkwI32IHnoXujX5AbbR7wTUCbUrQcLLqoXZtFwHed7qGQkL/yL9JhK7HW5IUl2QvOA0e9zXudxEYhg4jp5nvq3gPIs1nM4RDU0GtCtJFJ2NRbDncRY30OI1rPCkEozH6uz4X8PWXmN8ybVvF0g6sK9Nq8/NqKtwHYocN/94bjie3yasN+3zr7Po+PAhzUIlgb1f9Ts2NG1PWNt5vWsLk7OuDMb7v4jOxsHWfG5emo7eWoEHaMetbcspIQlhwen4hnXHCzCqbiwrqrD0sFXfZZfnaP2Z+f0bju3Ie97/5J9PN/undlLt7H9huPiuVO6f+z+oMLLB+38mvMJGGyiMb7iJQd53ka0KpC1MPWZZp1lvjAvmwu33ipPubjjao3U6u60BDyiNY/eehifbp0m0YGPOMSTNlf0Vry2YULW7Cw3jGad1DNm1S+Gajjl3L9Is0fVAjz2lZaNfEks+QFrN25bpTxtXvNSx9WbgKlwyeI0YB31b/NoPSWWaWGrK1s1tro6Hd+LN8xpJhXlslzob4WtObNyXV1CqlclXTO1d1Q7GyCz+lDLqoGNh4OzhqP/HhOO4YY+PNANSe4W4x9coNiYaObvter6c6hHw3Xz+LK1juFs0B6qB7vz7wR0ZHzpy09YCMTmLFQ7mlHpMRNK4jN9j7HufWoSx8TzXs/MhpSXaiKXLQyZrycVJw9odxJItPygqGfQg3CiUW/pQ4AoDFcKiDlJzGTzrBV8+raeHO+Qph0TkeGAA/0Zb3z3eos3KY/hmEPWzMkesrMkU1ZHLibDJqVVC+p3p0VUaOq1yxbHplmn9UalstHoFgLNhpN0RKA2dEvOEMTH/HhhSHxKcw+ntTlJx+IidXr/cFbhuPB9Mo1/CT85vE/23y06am2RqOL9knujcXWWYOqE6LPs3yqhtD96tkguZNyT1wRr9cyrx1gi/5JwXGki5QIlM5eJZfap6/M8s4Tc3FwySdKhzPLMZL0ccR9m7NyQfJA2LES7X3RE77KzZ3JGu3tuZGRf5/brw3F9ctjw8cJg5/jl47FziPmSAxzvH6kvp8fuN33+XJkKqPlgxLWSG/S1cdsuvrgsdPaaR2lbr8e8pwiOxlTkzYyeFJo5iy0lZ5eVRLbu2VbKLojQBWshe7PFD+khX9Occotp9MJAa8atdb7YOt/y+oE8TcB7fPD0K0ytUrbqQxtD8b1fZh6WxCyGtM5j9LJsOGNK+8xkhbc3oVql1lGhNlJLZMm8en1h643bunJrT6xt80yoC9fJe4G6GE9PK6orS4apZIplpHpGkpIwaYK6Mq5zbThM1PDo9+bkhr4ackvI5rp23ofkzkKqj0DZF4EE9m9e65LxN26YSd7DZEHQU1FS1Jo8enY1Co9+QyPOGlvvPK0JQfa+Lm2eHa3bRk+NnJSShSbJG3DFWw+0RZTvRQ9sc5irWqN2J2BYOy2/qG2Jxhh4daHjpF4jTdZdrsqcKdl6Q61HHxS7er+qw4Otj/lcI2r3Y2Ix56qG8ZeoqZaRWeowh0JSaE2cLdl8TaPNG8NxZ9rEe/UqjaY+5bulaMUQD+RkbzgT2AJvFUH3DCtqsBvOgN2OGhkGLZr0h8j1filHtjxixyE5KMlCvoogZOyKggHNcziuTZ1+bwaW9veUqHt6o3wsr+TswRbCwoNI4oGOrx1NyeWcpgmZJnSZuVyuXK8X5oeF6+uFh9cz0+wNyD7TORz5KXw5sqePb4FVMJxXj36xhk9xfxEOPNvUMwnjDA82ntU59wP9Teu4zgfv/rH7jOr+YI+Ddlx77/7M82ecndz9iXiOB3hEBaEakFkuE7fLTG2Ny3rj6WnBulFbY22bR59474l/fD8uHnAHF1BYle6Cr/G9qh3RFsw87w9RUTKJ0nNEjRbaglHz6A7mOE7UnXbf3Qh+dFtZ5swyF3q70rgh20a6NYo5T6nWDXJCs3BZNFQ63HDWWLzdlJkZquD174Y0h3LYQnhXhXmZAt5xBfhaGysN7UadN3oJ2Ki1fZaZRHTuShRtd0LjXO0s7hvwBLaZT6pd3ZFrUyYtqPrYFWeAHzJNQ8Uk+pOdfCB4bXGc9si8rNvJ2Eu0TalTG0NJIuEDOK12BomhG6GT51Bm66FPYeYN2kPlIgmTZFSFRmdrDcwlg3q83rOcseaCsr8vV9ubXNXE139kgg6XxXEbjAQ7L+swZibx9BiK6rAi4vR34hi1WFIpJKAsnItkdZX8gtP+Yz23yIKU0eTujfROUqh0CWJMjh2LTEhCe1GGxJXEpae6w+27GQgpKDjO11CX2V1WZJO7sxpwfWRbQ73ef7fEY/5G3RmJgm6ecY2/kdNaTaMG6Y/3FIzVZkEmsf28xRsxDYHjlEiloPPkFPjZHZVnWxNTmcl58jaIHaxVhi6Gr4Iz/PfctB1Oi3BaSrfIuD8pw3rpdk4U7h3a+MJvWsf1ru0lR3a+f3ZALwUgL2VcZ2d4dlz3DnI4wdN3iSlZE/NSmC8TtTWW28wyB2xYK7dtpTcLyCvkLUNPDYh/fXGLufrPpnWvR2Rt0QvTUE2gngEUcaFel/6BSgvxXWdcASFZJGjQups13t5uSILlUhC9+iSK1km3ShYB7dS60bwww3xR7zlr3Rs5V/YodNLJHW6DW/XMYETAVoQ8ZeapYGrUzVmAvVW2yPCqNnryCc+1dYeLou4jIa1j1r3kPCLwjvfRVMNuYI9gG+64NoNQEhdVSvG6gSdS/j2jJ09OtUZaxK1J9vNshCFsviCCI+Y1KVVMlS4askqetVTbGAKvVM8CNDxMCxZo68ZSjvEW0oVZMroJj3WN7I2Yu3a4mPPSa30s7iAx9HEbNckefYMHHLR7UxuLWfagKdDWgPB8fam6CkxtrvbSoi6Z1DMiS+Yw11CFyATZaTigmEHXa3ybOy4P1pyosAcqKUzu+LmnwYw+ONXfHZVBf0/AlcPd7nyLkNwaRB//IL/Y3XGdjMCAks3Pq+zAH7uDpBO0d4l+LX/MuqMZ7qw04FSHG0nQc0g7tXBe0X7hTivSNM2gPmsrl4xOE3ke87VmpmlhDiq8aowBYDii587Lghz/3ETKx27eIRlw4cCI7x3P/e1sE991Ozur36hxvWM7O6zzgRth6Pg3ne6P7Xz/PnJ4KeM6Z2zC85Oi7rwmnblevJpba+e2baAeW27b6nnhvcsAAKFrSURBVPUdS07hleGsTthkXHCtN+jG2sAK9CwIDctuGNQayUJ0NMGUsxehBIcZu0SUB71F5pWU1BqmQs7KVjc+eDTWXvnst7yG9IC1zO3pyxg+vE+z8dHtiZ4Scyo8vMrMXXm8dfqHQt2csUiDaZ5IZNiEtd5YQ7ZpnvA+tt6YL5m5LHSbePrgy1A7rVanzNcVyZVlulG1UqVSZaWpSzipNsQ0alB2CNbegEfgA7xnawNaOgyWeYSe1WWyavf6n6qCtqhbRFY3TkfoIY7apw1NQKB2Jx2gRjcfnqlJmErZl4qIQ4TW+wGfiZI17708zn3QOG3e5NvwjLm5wtRok/PBjaIUMaYl0Ro+gmO7eQYZLzRzmaNdIlPcQKeoMXnW1RkpphHQ2pgTR2Ovf0TmoeYEj822PRPJuB5kRSgZX+O90wJGbclopbN1hwJrr1Tnz7pT6CMwiJaPQe5IDr9JXFNpOBGBnJK/rENSh4XNgBLrXC3WzIDOYOhFumO+m0g12gEiq/LetQgERoJmw3EJNM+0pILcwGvTrjYzdBxVnN2a8OGYNhl98t2oBWr24+K1YHduXQqSC6lMMM3My0K6XMnXV1wfHnh4eGC+PLAsD6S0gIx1NvLsI5L+SkqER2PJqBh71vWsTnUuk9xnYGcbe3/7DajwHdu993/Jubwr2xqOZ7xnZ3zdff75ffefPTa9e10fUAugmWmavVZ12bg9zX5B187T7Ra9JzFOAduLxgNKGt85ml0H85qobR3GrDt1VsfcruRGNjdqGbRW9am/PeCr7hbBNAxSV1pr3Fb40tsby5SY00zNC5gzI53660ZprZ3cPAq/ZGErcOvC2owqUEpyaaFsvN28jlf7yrbGiJLJL/qUFVW4PFyxG1A70oy+VVq7Udsjraz0VF1pwjZcp6dCc1xKOg4LbsRNjvvV9tEXeyZVjyJ8CJewjwAx3LJE0IkScj3j1EeWF/TpkZ1gcR03cxLI45MTGEKQdTDagsAPGCWaxIcxHmxSE6dUN2cf+LSBrUN3kg5qlCRMJfNKJm40btaom8PFo6HVkwrPBLv0gx0vDrtJNJUfv45dhaJ3CP4mhrcP7GSNZvs1kKKGaQpSlaZGk06TxhYjfbp0qlQ2rWzqgsm+3kNPczTVq2dPMnyFhYAvBJnmYOgpclzCpodT6f5b/HeOZmx/YdfIdnuAn4Nte7qmHYaW03UfxiWc5B4B7A3MToMfNt5nhHuWeIxMcRi1t0BmO1Tbr3o3FcmRDK9tFaQUF9CdZ8pSKEtmWQqXxWcAlpIjQxtVrcO49d0C3UNL503owcN16lCid91/2zPo71ge5wvh407s7Lheyrh+w3GdNnvh32fOxT7+/H4+zwv0hfffO657pyWnf88Z3f7ZQk6ZKdhAyzzTamdbO/M0UbdGTY0qW/DkbB+6B8PQhkERODIxI2t1I2aCSnOICUB9jIepkbOSs2Kh1Va3MEwD89cesIVfXRoX4EdPKyKTj1FJEy3Wc7YQrOrd61M1kxIUTcwpMpHkrMiUNBCPTE1AFXr1qc0udyRBS/f+slIymAvDJhOkN6xXuq00WelWMTZENugx9qJpOCWQTRwSrLJr0A0JrGHQxngJqrjRCs7FMOZ724o9/3s/+ePcD7gqnA0MREi9htU6zXzqMtIRyYw61uAK6Mm5+EdLBDCeebfeXE2j+ecNx7XXmoqP65hrUPrXBquzFF282B2cgNdZOP2+YKASr7P4zOF8x7JrJ6bZ+RJo8SMGsNiShfpEOCN8OKqFw+7WI/txGHgLD2C4k/O5lO78lIDV4ssGVOfZmOw9URrMTwkm7ghC6LZPNZDopwJC2srhwU5352U8J0WNH9j915me6OsQvWHhVduxpsZxi5mWoQTvB7HvHyoO/njSdwSrI8tT9paHlDNaCgzK+1wos8Pry5SZpkRKur9fnu28cN7lcZ6e516nTMtGtqXPWYT3dvQ+GThnXPfQ4P19Tp/xdW6//hzXebs/4G4FOJzXKfUf5/icdaW7z7l3anJ3O3/v+T3jbwFJmTLB9eFKvW1ILODbumLdHU9bV2ISRjgFp3E3O8EcRPHdYoSD3BwfTwPM6U6ckALikFXJmWUqqDgRo3awtUOLy8ZwYoUlsuASQiI83VaqdR5b5Vvfu0CZaGlj40tMwayyatSPVnrO1CzMOSSU1Gi3RsqGZKdPz5OSLJN7cmHe3mjbhtMtBWk+Yfg6CfM8kW8L+vgRpTa03+hPH1F1Y0srMq3QlV6V/nZFQ7JJcRkdKt6T1dhrN721mCQslJRIJ+cWJDw/bcpen0ANKxbzrUZfxDinQBIsCSYNTUIpynUu3JrwuHl23Kph7kFdJgqhW0KoztTTTEmN3rypewQYGDzVjXIT5AZ9wxUpGtCczm9q9AwpVW61clsr/QYxTos+A9XoUVuigGn3W+o+BiW8s2HDVuOVQ41oXPfVd5Dz5DBG45DsAZ473E3CkteVXr22utnKKo2aOrWMVe21VxOliWHSI4tSXE46NBUjc9n3OKA6V8LAmUFDH2/rnnG3EZTIWB2kyHbHWBInR0hIpXX/LDtd2EGM8nMyCpyHo5MRRwrRFwhYJ+loeo4cXXFNTTF6QILEaBz0UNm3ksilIGWBZUGvM8vrielhYrrMXC6Fh8tMnkr4ziEd55nePTj4LI6Oczeq6pVEjXPcTT/udM7OfHzYuxzU/WNnqPDsuL5pM66TQ3gxdX0phf1Y2DDuvoQP3m3nzxQOx3b/tnO965yl6birlHlieb2EpEvldl0waxiVdZtinlB3yZ6AEDXoyDaiYzxKxzp1A+3V2WxRCO+9gxhFZ99dhSmP1EFpwY6Tzdis0VosZlN/78heujlVvna+dINX08RUCjd9wOwRq420OpDUaqWmzlYWEsqcEm8W4Sadzbwna8BBJWcuywNb8+GWtd68IbZ1Eji9WxvXYlzyRK4XytMN2qPX+qxxazdaU1JNpE2DeGZY08i4vIaVFrcWtjX6zV8zCBR0DxDa2rEWckhBPLDkM9AkxemUaBAthqm4uK66zpwVixH0sDZot+qEFXFlE4yglPt8JR9Wo5RU3LtoptUbXv1rkFzmyFEsn4JrDbbWobUwzopskZVJyFzFGk0tI/iEasSokSVKN9dqTOG0JqI45Mw3vyySN3HLAS1LH6p3gjAw1Q7S3LUYFLEgUTtBvq7OCuq9QahZtM1CVaTRxfUfh4DhDl+OSyjWsi9520ke0gdO6XCbmKefVo2+EaxV83lrUXuiez1wQKOD1K/dXEXEXE6tbRbUdkc5ZMD0w84Mpx3nZXA3B4SKDccaWSeyw8w2HFSCFhMGbDKkgEygEz5xYE4wZWSa4TKTLzPlMrMsF6bl6irwD6H8HrVQB3MN9iDjyJDHUT1nyn72/Pw2i7PW5Bhc+lKZJU75M+hw3D/Dgud/x+1si+Gb2HGN7d4PDcdy78z2f+3uSdgzrwFLnGG/83af6r4ED96//9nN2UVKckWN2tjWjWW5UdtGbRvTlGm1xliT5lHggEIYjaC2f0c3L9pXa4gKmzQ3QMT8o9y8kC0+CiVHU23JGmoBbgd78ICNiKjDAo7mYTN46hulO/9Y8oQ36W5Qu9c9UsAuMZtcFZZJg8UFFa9joIYkZSpuhDbp9L6COT2610ZTv1lqTqDImTzNpG1CesW6sjWwGo231b1LMoOW914nRJBRApBoElVBxvRoC4fVHUq0TrDR2OnQPgaevd5ikVGMbGyfW6W4lh1C7d5ePM6V7ClJBAdI3LJH/jQaNYxhPxKZgCBHr5GNBnKTYzRHB+s+NkdEEBGKeM3P4d+6syJHTc2GYc54phu/dV9Yw4dJOBAZP/z5BTC6uPzmKvyCQbDk6mDK1U6P5toWrR8dew7DRgFqjLo/dz272G88V+PxPrLkOA4NejVs69hmrsy+MdoHAyaVoznaPzhyTPHsfcCF0RpwJhjuTsv2pw8zIKfzNa7PkZwN6HwM/EzQC86unCQas/HxNJOiU8JKQcuMTDNlmpiniXmameLvqUxO/Y+WkNE6fEZlfJfldP/548NpdZIjPk2eNwzfv/Hekd0nBy85tf7Ca+C5Lf0at298x/XSQXzX1u//OHuZ89XD84zqnEHd/2sco9LH1ngJSD6yLvMPn5dlf2pdq8NItrHeJix0DI/Bg7ZDHRL4PzrIAN6wSG+HjmE0UWKKlg3LkLMb7JSFyb0MHj87y461U7sX4t0WRNFn0HmBx75RV5i18C2XKyB0bmy3lckgJ2cbwhNWMk0zyzSTSWxmWK084YQNSwJJSClxSRNCpa1GX11cNqvfHvvKXColC9OrK9NWSWuCm7G2G902Sq+0tVJIZMvsZBYVl9RK5kOAJyEVHw3DBttHbXhtXxUjY6sWYzaMnoRMjF4RaEOjLuSTbNzfZfTFTbgxxMkjY5Ng43lDbzeldadwmxmtVeh9V7indXI07qIeQCC2Ky0ghCpDrLlq3NqNopmSMpclYTnR1PuhJIITb7I+1qdGv5G0UNUItQu3OebBBP7b3F/b7t9EfP9yOK1kmwcGvhy9Z80ksnc7pJiAHi+UQUUXGREBghNSpHrdUvuABf3SlTNLLZyXs2RxOHLte9+eq9OrGzsbwUbUgCXUQ8wHNZoJySq9qw9zjWO1o4T+EXsLwrDLKT4bYaf8j0GUlr2frWd/oQW0TAGZDZkMroJcBb0q6SGj8wLzFZsf0MsDU9wu1yvTZSEvs2fqkrFowRgTy4bBOjMEX1LMMNQnKZOolr1VJMbMPCt13G/vggft7vGXnF2/e+zr3PQrv+TYfuRHfoTv/M7v5PXr13zmM5/hj/7RP8rP/MzPPHvN09MTn//85/mWb/kWXr16xfd///fzC7/wC89e87M/+7N83/d9H9frlc985jP8uT/351xV4ddiuz9Az2BC7v84PfaO7XyEPgFFfDGtPn/sfealIJIoZeZ6feD68MCrVw+8fnXl9asHHh4uXK4LZZ4pUyHn7IyqEERVOXZsUNtb7dRaqXVj3VbW9cZ6e+S2PrJtq7PRzLOwnJRSCvM8+W2a/VYmkub9J209tPtad0JE9/6tp/WJX/7wLasJlhZaeY+nmtlihMPcOlOtpHXltq5srWIYb+bEQ0lcso9bWFtji4nAy1J4eFh4/fpCKd75v7XGtm083TYenzYeHze6JdJ8ZX7zafLD+6TLBRbopbNSeWo33tZHblap2rC50y+NNjU2bWy60vIGU4O5Y4vXgKwYxHgQU3bqdlWccDAZ5QLlaqTZkAls8tpXTwNZTZFBCWv32xYj19cWj5HoUjCdaDLz1DNPLfHUla0nGoUmE5Xio9or1FpZe2Oz8ApBuqgSFHlrXk/aGk+3ytunjQ/f3vjw8cZHT2scZ6f794oHRt3rY2k4Brtb4OLgU0WiZCTBLPTeNFfQODL0Xcx5a/Rbo946283YnnrcjLq6rJE1b55OlkiSSJK9WV40gg8n5eSAIF2RQrFV4obXr9YON0NWQTe/yeYageLzQHwuXG+uMFIbrVavg4VgLyZRX+YIeDr7pGI19VYLkyCM+m8+JyYO7oZgr3U2jE2NrRi1GC27A+sz2Aws7qz22ytFrgm9ZvKrTLq8Il9eUx4eWB5eMT+8YXn1hsvDA/PlFWV+hUh5ZpRGveoM9xx52EG6aKRwWJmNTOv5YN2ucbud7t+ru987rTMseLa/58fO9a2P2eSvffuaMq5/9a/+FZ///Of5zu/8Tmqt/MW/+Bf5nu/5Hn76p3+ah4cHAP7sn/2z/KN/9I/4+3//7/Pee+/xgz/4g/yxP/bH+Lf/9t8C0Frj+77v+/jc5z7Hv/t3/46f+7mf40/8iT9BKYW/8Tf+xte29+cff+8w5P65+7z3HUft/vPgucN6CULsp8c+KfM77dNAnFUSObkDaXWmt41lfmJbG73DbfXZVkPtwiLsc5Krf55FgdihH6Fa8wuXGCOeQGJ0hSsx9Oh9UXqMd+39aGTtHar0vX7mTLABzRi0Ds24bSuPm9A0UUoh6YLJSmd1uKgHfLhtNMtY8inOU7DaTIw1kjqUUMFQBB/XILUireLlESP1zo3ObINxlZjKxetiybD26D1hGNQWSJJfrAmPtCWpM9C61zn6ZPt0W0m218UMooVAYPLXySToDN4uI7QCPdtJmdzxwsM47AqKYEE1DtaWicOENbJdz3Cd8WmYTw62FsKt3mS9Q1YiTrjouKZewFJjzIjRndzTzIk94dwG62w0Vu9ZUGdn4PWuOzZmmJNKTBiKkOeC/zCJGOHSPH8fDcTj+53F6RqLMmBAiUbtOOPecB+UdhvPESNeiFKa/0iL2utOjNiN4ynF3V8zbtFeEjD5TqRA9gxqNxF2urxlOPQDgHspecAiOx3XZFzkJsYQ3CZQEsb06ilus6CToIuSloTOBZ0uyHxBpgtlvjLNF6bpwjTNaPbJ1qOf7ui/OtiB97UtG7+VQciItRjX/k5mGbdzbX7/kfH3u2DBlwL383Pc3f/fynH9k3/yT579/ff+3t/jM5/5DD/1Uz/FH/yDf5AvfelL/N2/+3f58R//cf7wH/7DAPzYj/0Yv+t3/S7+/b//93zXd30X//Sf/lN++qd/mn/+z/85n/3sZ/m9v/f38tf+2l/jz//5P89f/st/mWmavvoduj9on7Q9y7juwVV5/rrzAR+Qod49f/9xL/nF4UBf3PdwXaIk9THb3TbMGo+XJ2eVIazDcZnQ+7Y3zboDkwOPj9pMx7xbP54XXKgWEqKNtNNsXbtusoyaBVU5tPcQrHthwFu1etDMnSji3ydsm/HhzZgl82a5UMoD9OwKG7b64EcM1o2tGVtO9KTk4t+tCn1rhMgA4M4rZWXKC7Y2bGvYo7IGKzBZJ/fu8FeCPF+Rkkl9AX6ZnlZ6rvRb82GQ5pFz1okkiZyTF9667ZAqXR1Gq8CKF/ajJkYGm6AuwGLoIkxXwbKg2WgTOxRklpwRR6JKZpPiNaww/maj9uVOzEsKY1yNU8UTiWzOKMy46v0gHgzLKoKPCDGcCakDOo597p0x4drPWVibYaDVz6vGsenNfBxLw5vfo5ePcK7NhIqykXdj2PballfphmK7ux4nCVg4Q08SvdijOFqQAh4UPKvqUSQK1xZQIXt7w70zcgasPHNWrqbe99rd84tvMHD1WfM5uCPsbdT8/Lrx42ywIxvi3r0HDL9DhYez6sOD2fMY9vDCXieUZId6yCzILKRZyZdEuhbSsiDzAzq/Ii2vmJYH5uWBebkyzTOWCqaJenJSR9OwcpKcHuHtYXZ25qCrYzyra40UcmRQI3l7KYC/z8DONvOlmtZXa6e/yu1XVeP60pe+BMCnP/1pAH7qp36Kbdv4I3/kj+yv+Z2/83fybd/2bfzkT/4k3/Vd38VP/uRP8nt+z+/hs5/97P6a7/3e7+UHfuAH+E//6T/x+37f7/vY99xuN2632/73l7/8Zb8zDoby/MDch0afeLDO+B0fdzT37098/PPuI4zzpnf798L7BOEyXTxDUlyDULz5cOt+QSS9RZbS3MiEI/H4Oi7EMBKmjXXzxKj3itGo3aMrIVGyksyhwpQ1MP/s9OMYzEiDis8vqr05k04bqeE9WCKk1FlvG9V8HtSb9y4s08R8+Ra2py+jbUXXihaY+oa0ymqVfpmQKTEpvDd57evWG1vz8zCMY5kyKU+YXmEVrMJjNJ+tCmtytYtLUi4p8+r1tzA/rEhd2T76iPq47Sy2Xm+oCVUSJRVnY2l2yCZo0D5mHa9/rXF6ksFs8ABcHNbRayJPULzEwEc9UU3ZUERmunixe6NE1uUEiUaoKZgEi0vZgr2XgVkKIy5WKtUsxpI4281iDbkQq2eUdp4VZwLFnZwNm5t6rMFGV9nlk+ieDXRxnb1hsKxCj/eY+v5tJ1hp/LZQsguS+ojqhUQNJt5xfUk4qtITaj62pYwLSbxXa2j+GbJr/EnXyJTYUQV3MN2p/ZEZ2JBXMqexW29O1KiRlQ61eiII2zOqCFzMaKPXb/T7na7j51p/g9oi2DjQcUCH+Unx0Yifg1EDFQUrIEWdRTiDLoJehPQ6Mb03kS8X0vV99OE99Poe+urTXF6/Zr6485L0gMlEP8k6DYdVyc/gwD4EHF94nZlfT96Uf/r3LIy7R5N83C6+y2m9K5v6inb4a9u+bsfVe+fP/Jk/wx/4A3+A3/27fzcAP//zP880Tbz//vvPXvvZz36Wn//5n99fc3Za4/nx3Evbj/zIj/BX/spfeffO3Gc7L93/xO3kvM6psX386Wef+5LDOn/n+T0vpdywF8JVEiVN2NS5Li4y2wwut05d/WKpVqnUveeo9wAIDCAFnf7IyHp357XVDhKq4MnL6IVQLY+5PSkpJUeAZY0WiJHhLMAeUjk+WdnZbNI1WG2dtW68vSkNr92UcgVJ9O2G1BXNMGFIa7S2ORNQBcnJJxarR+O7YC1D7UDQXFALluLWqN1cHouhKRjy7BVm8QnI6SqUsrrixuNKf1u9Rw0XI9ai5OLR8W60Vxz2qyPQ9kyKGWwx+gJtgW0ybOgIJlApSI9pw2HOqw1jr1EXchjNmWzqdSMLxxVQocTsDO8xgtHouxP9RPbxGt5UbMFSM4fRlKOZmDCYA546sdx8nUdmcXKIskfaA3JKAUWNul1xgxhDvQYv0EMc26P9JAraQ1k+oaZkS2QZs8a8fsVwcCOzGrseGb3c1U/McUvf5zZYhL7+vE8rCEmnnr29N2CwRPH3izEW+85GtHNmEHeH4oWBK7wwoNKTM4sO9XPX1Mi0RqvooMBLwM9SBJ1AZ4cH8zWTlgVdruh8pVyu6HIlLVfKciFPi8s+BRkDhvO8l2nSaEZ4qaYR7+lEpsXzLOtct7p3NPLC/a/Wvp7t5/+/M67Pf/7z/Mf/+B/5N//m3/za7MknbH/hL/wFfviHf3j/+8tf/jK//bf/9l/FJ96fhZEW3YUVdvcSuXvuXNu6T4PPrx0Z19mR6fEeZ+ArORUEoV4aa3MI7fJk1M2j62qVzarTa82lf/wjO6O+YBFFOmToF7qPf5BwXAddVpNryqkKKWVKjF/o1Jjb5RGrD909yfJ023tpNKCa2oy3T1DNQBPvXRYwxZpgraK9h7ZdY22EakKQTbKTRRTxMeXgvUZx0DRlkkxunCUYY73S2pAr8KOwSueixqLe/FumQmorqq5M3zfPHJt2V5tfov7QzC/gFI6hGmNEBsmwCWw2bIY2Qy9GUyGrkCWjWlC8T6uhNFOqjaZOjcbOYQsEJFMtiA+WCFJ2nEeNKt+hYJHw+VTnOokNyQUfrbvrJUaRyJdZ5tTY6vdFzovwtI5Dv/JYvLJnVxb/dgpHQ7JDghZglbewu1P2wqZ6T6G600o9+0TenkjmdUZ3WPGlo4/SekT9ckT+YzzJcFDd6NVv1ofj8nVohr8/nJZFR7mBCwoHfEnUOC16486KGRJNV44Y9sMH9vNlPv5vz8yAAKHbdTits4lJ0ZpRfGRPWhL5kikPEzpfkdkdVl4unn0tF8pyJZcFyZFpycii3CidiRdjFMnh1I5zahaWYg8O+GTnNX7UKJlw+vdrcUD/e3FcP/iDP8hP/MRP8K//9b/mt/2237Y//rnPfY51XfniF7/4LOv6hV/4BT73uc/tr/kP/+E/PPu8wTocr7nf5pDu/7XfTqvqLjJ6dv9EfQaeO637yGQ4qJe+5v654Qzjs6RnMsrl1ZWunVSCspuN9KiQDUudp6fETW+eUYl3/3RzNQbX2mt+4eCq22yjhqUe3ZfRlOojT3J2rbucckSEijQjdUWbEwaEwWBroeZBCLSGJncSqlZaN261cds2Xi0zDw9vSHWitY8wu5HoLHSaCbfaebIOLaFz5pKcQGIZtm3UoIKCrYpqJuUrlOyjT7bKR9sjTzd3EddJuJSJRTofvX3koRSWnLl++sLDmyfatnF7WmlbR4rCFFlJGEeeute0KliWIHPgLMMLrj6RYWueYUlT5qLMObEUhSR8WF1o13UkC6Nna8Bgg4XnmUx0QAWM5TrpToLYLDNJokmiiqut+7AtXwM7VaARUGE4MuQgKwwSQLJjre03ORydstdfEG8b6IPaz9hP3Z2qE/A88joSuYMKoKJO4y9CIZNacqWUqHHtMkkjLSH2EdxhDTp2M28i7k7Z7xVoFVqsv3BWNHYJLA+2hhPzL9l7EjvBpvTv7ada12AVjl62A7mI32ejy+VwhMfFPZxYOArjcLx4v6IkiR4t0FnQK+TXhfJ+Ib0u5FefIr16n7S8olw/xfzwKfL1DfnhDdPyGtEJc8xiPx9uhp6TMkbj8dl5Ac+ysUNVBGcNNj7uuO6D9tOp2s/dfenjvI33/Ro5qvvta3JcZsYP/dAP8Q/+wT/gX/7Lf8m3f/u3P3v+9//+308phX/xL/4F3//93w/Az/zMz/CzP/uzfPd3fzcA3/3d381f/+t/nf/+3/87n/nMZwD4Z//sn/HmzRu+4zu+42vbe+P5Qbzvt4K7tPel6uAJIrxPvu4d10vRRj+95z4Lu8/UzidTOBbJUA3AMJSsE8tyARVqcwq0JJd02agB5ZhLGYEbs95PkxlGsTsep1OrR9S6i+EFlGMW7GpBSvdGX1GsFS/sm9KaoT2jHVZjl8exwFwUcQWH5LN80crT6hFupfLeUpDygDDR7SM0oKVZJfQRO9SKZCOLkdWYS6gq9NBOtBD/NBB1yES0IVpobaP1irVHtl55ksaCK48/9catNmayO9mlkC4O2W0CZh1N3WWw5na6UOMkD+Ofoatf+NtoghU86qeRkpE1cUkOVWoX2hgzL6PGKHFuJIL+WBiRQe+GyCTstmdrgoG2mD/VvW5FZG8F6LKbqDE+xo50bc/U9rmYIesgKsfvK55ReiuAYpIwTUcGaOw5lVMwggIgnUkaE52MsYi52PJ4p4wGWdyZtEjhAxp0wp4L0/r1JHuPljSQlUPtv/YdRnQJfAIqtJh0HASlSI08iLNdAcNCw3Bkq/tlPBwbHPJL+wrwoA8b16txenJX6O+cHFdkLEMwQFQcHszOStWLkK5KeZPQhwW9XJDlfXT+FGl5oFxfUy6vycsr8vwKkQUjY3JIb43s6gwRDkLGvRPzXfIz5k5LDvr7fdb1kok8B9x29+/9dh+0nx+7d2Yvvfar3L4mx/X5z3+eH//xH+cf/sN/yOvXr/ea1HvvvcflcuG9997jT//pP80P//AP8+lPf5o3b97wQz/0Q3z3d3833/Vd3wXA93zP9/Ad3/Ed/PE//sf5m3/zb/LzP//z/KW/9Jf4/Oc///VnVeeDaXz84N5nRS9ucjig4WzOmdY9w2acAD39fSaKnKPb01fsz59P3kjN46JRMqX4DKvlurH2iqnLMt3aisv/dOqtxsWakOaqGYo3EIc9OCLQOBC1Gvu4drVAxPzizmJIMlJWes+MGkirDaluXHozqtUwtC0mKbth0YDyrBlbZGRdOsscc4Q0Ic1/i2gji0sEdVxhPpnrx2VxJmRP3vi6mQffFtN3RT3zcGrdhLXqAyg36G31Ie/iqhVrEzYxLilTkjEnZy1KKHRAc1Fiwdl8IY8uETqb4gzDJDR1aM8Fjvy/3kGahdHuFAUxV8vYQj0fGUtDIwi3yLTu1kY/L2E3PhXPUpKKs0MH9De2kVnF4hSI+pc/tiva7y/3Wo8kOQKzDAwtyRzZYAy6EuIrQ8ppNEenCD5UjFkqRRxILJGbDfFb2ZUvgmU4YLmm8bPjF0fsSI9WhSYxT4193e30U+NU37JQTYFdLBrbjbAZR0N0/D1u+6GX08W4Q3zhtk6BsQUEO8gn77S7I3MLtMCDBJAEMgu6JNKSSNeMXmY0GIQ6vyLNr9xhLVfyfCWVCyZlp73fO6oh63RQ4M+PD0gXV8c4axC+lGXd17buf6C98NhL27uc169h9vU1Oa6/83f+DgB/6A/9oWeP/9iP/Rh/6k/9KQD+1t/6W6gq3//938/tduN7v/d7+dt/+2/vr00p8RM/8RP8wA/8AN/93d/Nw8MDf/JP/kn+6l/9q7+6X/JJ2x5F33uN8EbDSend7d5pnU/IcFpn5g0cePA50zobmvHe4eRGpJk5FhGQy4Tm5NBVgjQlLLmRzyWhCWxtbj7FafINQh7K0O4jUbzmpa5WYLDhmVfvHRNnHDbr9OS9YgnQpJRJvJAe0E2uiVorsoo7A6tUXMMQMdLWseyQXiehvWGtU9fK+sHKq1dXrsvEm9fv0/uH9H7DeKIIqOIztfpKN88wk8KkLta7pcStCpXO1jptDDgSoYmgxUja4LbQtidafWLbErfmn39Jxs1g6jB3yJtf2kmElDNpXOBJ0WlzurJyzLFK0LOwSWIl02zaswjt3uukDW6ts2RFMszZ+86euvA2yjbW8HPByJBiEViYHqvB1vOspqGoOZFDUYq0kJaSY/0JnnWd1qYkr2ccUf9pneLBkShIZAEEO1JiMCM6oEEPJER8uJXSsJO8UNZOls6VShF3ZDTZHZZ0iV6uTluVvhoaDepYDN0MZGBkjKkncmRLVIMbtGoQA1QPAysHe3DzG6fAg0G26B64WWRjZ+O52+cz0jJuO+xnjLE2wKF4dee40um53bGNrExHtiWka6K8KpT3JqY3D+j1DbK8R3l4j/LqDeXyQHl4j+nhPSQ/gF5o0YZwhgfb6f6hSTic2PObRRa/Z1ZnqHBkXWen9VLGFUvnEx3XOZsatvGcbQ3ndX7s69y+ZqjwK23LsvCjP/qj/OiP/ug7X/M7fsfv4B//43/8tXz1V97khRu8cLB3L8Z+5afT615yVONkvgQVnj/u/v5wiOd9uT+x42IcL9kLr6CSmPPC9dqRGFtQqzsrGmwX82ZNc9UM6UKPK3bv4einQq3JLqw7hqxi1e9noDpMl7MP5ksKkhSkxGwv3aez6qjbaEB6kTVJj56g7I5FRGkdPnp6Yu2VTXyGUJkyiULnEWTDS0mhw0hnq51VHcLMSbnkREuJtRlPdZDLJMgQHek+5j6HM9IsSFV6W3kK59uC9916kIWls6R8ynDci4p4Ngo4rKeJSmFlYrWCScbBMBjj5gXIPhaYVF3oOCVhSgIqbI0Qa+1oT4w5tMbmTpRKkka25plNNPR6zSualyNyH0q0I5rfreiYsEuIxA4MckBlElH/aXab/+QUHznqXL5ePG7z9ZGk7gt4OK2Ei8mWDinGh9hgA0aNylXMDFZDb06ykBpqFDg5xv3EcHa2z7WiCfZEBHQSx7wxJiKMqcG2t4dEXWt3WkPx3V7MtOJr/ZLMx3VqQXDxBXAcb6sBCI5sdr/MZbfRhwmQ+L+4OnxStChlmZiufiuX16Tra9LyivzqNdOr15TLA/PDK1K5hrJKOjkmeDaZ+JRxnY3c0PA/NxzvDv+lbOtMff9at68GzTo7sbMt/t/Kcf3vdrv34F/Ru58eHHLULzm8l7aXTtJYrfdp9tmRjcfONbAzpPixj/SFmiTH9Fxjq5V5XukxqmNZNqx5ZrOtoWxtRlevTTnbC6wPxtZwZiFZUzsqDVTQVl1SJ4E0cYV5XM0gJ8ViNG/Lvi90HI4bWYn0U4Qa4xVMUfORHr1V2taxm0Ge6aoseQLp4TQ6WOVoM4ox5iI0GTJXUNRHQrgCAvtF20e4qz1mehUH2tQp+L1Xl+PxnXGYUzqtuvajYIxJ9yriv8sE00RPhWaFZtkVQMQJBuEiTgixkHpEwaJe61KhqDswwx2hmvdtDWUSsR4iPI0sDbW215AOwvPdGtwliuKYDwrbcEBjFY0y2541uCOVZs5w60OtQhza6iPe6kgIEB8ynOI1UenkboPQSGrq0F44rtEUbCNritlovXZ3WkMBY3jOsV/mzt0nv8Q+njMCTuoVg8beHXocv9NOBvosmtz7YP8ddHbhlBV1jl7j02H+ipucLvM7szJQAVEl5YSWFEMgC9NlpiwXdL4E5f2BabmSZ6e+i3qANBxWhDzPHNZO9PkED2A2MsfzennH7YXf9nVt93b43h7/GkCG39iO6yWH89JrRpS6P3D35v01X+H7XsKAzyfipefOXwnPCST3+3/3/RImZE4TimJX2Nbuo9oR2lpjt5VWG7eIKMfUoi4+JkXCuBkxLK9F3csqJl5usBV6gaLOLJSCT1UOynrOGkMOHfbw5lDfx6qNLQ3GocNnTt5wsgnS0ebkhK1X1lZZLoX331u4Xt8AG9uaSdtGlkTBuGZhrZWtG4+9+yRYVYoq8+T1tF7NBYcBTPeL2DMLbzTOBrl10roitVJvo2GrItpZ24olxZKQJz8JHtm68yFNUK5uaJvSm+7KJCK2D8d1OEbZTJxU0RNaYSowJeXVLMjmkG2zkW05A7HXSrKNSVYmbkg4L5c/ba4WQkND3eLZrQ5n4byNsW52YduzjhxAd8USNh9hoqIuD2Yc0kqpBzu97fCX7gZO9uzMBzj6udAa0KBBC2fRWg9NQXbdOwmYqnXn6JkISVySaydIjPlZFdfM62P9RrYlIVwVZAnbBhQYjxk7PZ6OZ2f7IbBnhn5c+nnUw4aM1HCm4RgPTnxkXyd/e0hVxYcmQYohBTQn0pyD9l6YXy9c3sws711Ir14j1zfo8obp+obp8oY0X5B8pUXrwceVMT5OyHCndvymHT40/Xi2df73JSLGr3Y7B+z3UOG5tAIfs3dfy/aN7bi+0naf7Sg7m+ljDuvsOF6qaY3tHibkhdd9vWn3SycXEMmUrLxKSu+VKXsU79BeJufsDis9crvdWN/Chu2wIDTPSDo+qM+TIp/P1JxgQcgddZy1Zqt50yhGLoVUXFdRi6INctfgCQg1MqUVH5PSe3cyR+/RJK0uK5Q8sl9vldYba1t53a8sS+a6vKFNim2PtO2R0lckJSbcldyacGvwKI6IoTBPmdy6j8joHVoj08nWKVSyVIo0FjEmEdKklKakRjRQV2gtKP3KdgvjBagKkjPUDewRk0JCmdRnpPlaCMbZqSbytjo2bKFAnpo3d89qZIU3SZiysm6d1hwiRFeSrcz2xGxrZFsOTu5l9s3oa5ynG0evU+NoHCYyp0Hv3+QgNDQ5Mn7DlSlGvamlfSzLmDoQ3Ayv5QU0JmaRQQRRMcRn/Xj68XBSRcxza9BWvP60evbkQZMf/xaUfBHvXxtZotYgZrSYVNB8HbUemot7n2LfocF+NsTNnczwQZ9waQFRC7IetTcG79090UH35MgOHS60MUkaO1ibIsgEsqhrD14z5dVEeZOZPjXx8P7C5f0Ly3sPpFdvXCFjeUN+/YDMD6AzTns/HFQ79c61/XE53T8c2lDMcC3C+D3nula7//1f5/bVQITn7Rzgv8tufg3br1/H9a6UVGAPI1+CCe8TsrG96yR9Urb30vu+mlT5pcxLlCSZZZ7B3FCvT3WPJte1hgyQz7IaWmquyxbQjRzXIUjUCnpQh1sYC0OrodWZcRZ1LhXZR6JY8n6xTnFjNYrwJlSJHrLB7hKnQO+4vwaBRMDWztu3N1rvGAWbCiVDkgTbW5c6Ciht9N428z7U8XEiQlIXExbxyDmbkboz/TKdLI2SOsUak3ZK8jqKT5aODEIcmhy1+BYEAFGQvqElRf5rPE/PPfz2pLZHTYKoMbon0C6sahQ9puE6rtXQvlFYKbIxy8bU1/jNjdRbMOLMs5VBQqh+33dUTkhAOJnBqKt23B8Ga2TNAXdqZGbn+VF+MAkHdc5O4nioMEiJAuSoL2Hiorp7nUqCABBOayUi/ViEyt7g7s7L2zxsONqqUccajsuDIl/zbdckPIgX4VDscFw7uDh+hqfne4Dia5TdyFuL7HN/vT1/8znulfG66PcT8XlfUxAx5kS+KOWama6F+dXE8mpiflgo19FgvCDLgpYF00LXzGjyPpMuznT3sbbOYrpHj+Dz28cyrHvU6Gvd7B33P2l7l039Dcd12u4Pzp2NOZwWH6e/y93rxzZO9HnxyzveM+xaP73u683ATj9K4kpZ5mUfElk386GFKqx1o1MRsRgR70bdTKLZuNM1RJJOv6ePC79WHwEhCqkjyQccmuKCvJJIKQUBQneDJh1Sq2gF+kagUNQemm7iXqDj9GiLYsLw328/FG5r5XFb4VMP3kBcHtgkw/aE9NCeSIaa0/ZvzWjd5Zvm7DyQrD7XKzdIzYcaFjqTdSYqRTYm2VjYuGZvbu6Sg2bssGY1iz41XMGjNiQ5WWVJfZ99JXLUGdyZ+hwn1yL0OlbtTp23ES1bp2ijqHFJ6rJXvSJ1Zckbi25c5UaS29GbFE7KOjsDTHZdOTuyrWGbh9MaGcKebUF0RLulbYKS0BYZ18ohEDuMr0hINo21beHMJFig/rzT5I9aWmvEWhB6lRgtAn04rxhYKdjed9jE3Fni+y2VmJfWsSq0ZrTmI0N6ZPHdAmrszpAFdie23w+3ZZF93Ntcs/1eqLXEBON+ggKNI8Dd8VJfA0OJRMCb9gcJYxbSIqRLojxkpleZ+fXE5c3Mw5sL5fWV9PCK6eGBdLki05VeLlQpEWqdK5z3fVrpRcd1OC2iDzDtzNJPhAfPduyrcURnO/hJ2719PNvDXwN48ten47q/f3ZS8Bx75e4174oO4HmkYjz/3DMsOT5/LJR37ecgdLz0/vu0Ou4rhWlSNGeaKKkoJSvWOjkJ01QQSTyqst7WXeKntYq16h83Ct0yLuDIyjZXz+5A15XSm2dkyUiayb0z5YJk1+lT8bpKba5PJz2ReyVbZU1KpdGs0euGz/d142B7g6rQpNK6UOvGL2yNac7Mc+HTD69J6ZXDjY8fIQGhZW08qNc6WjdurXvtX4yrdiaFa4Irzm7U3pl742KVQqXYynsUNE+QMr/yxS+44kgSytyZVKkmPFbltoU+owkaWZ0SGpDRJ9YtOckiFkxlNClnr1OIQzjaG70LG8aNjWwbyTZKe0R5ImtlkUpa1TOgDn01n3FZjbZa1IeMfvN/5X59DYc1buE0BmFBzBuCVX3GlQ5f0WMN9GgmP7FsJe7bvmZtH/ciEpChunMY369Vnb5eBdm6Z36VIFN0R9bEjynq/bC12U53tyF0XMVnyIVTdBg69Ah7ZGcju+LIru75T+e/jkvYjqpBPC92ssvhXJNARIEcaVa8KNplvLVAXcapKHpRptc+V2v+lolX33ph+dTM9VsuvPnWV6SH99DLp0iv34fyPj2/orI8q2sN2K/t/x5Q4NlR3WsU7nWxPWDheaPxeY2Mw/K1OK6xzt6FZr1kV+8d2Pm5r3P7xndc54N177TuI4vz/ZeyrfvPO7/vJcjv/ja2cYJeAtU/Fvbd3e739fR35Dg+w0vhMs9IKGOstxXDm5BrjZqPslOHqQ7bteZstr3ILQdUMrIvWkedv+11qaqUoJApnn2JeoSZVPfI2ZrTwMUGVdjv1+7SOp7ZAXRvhhw/rw2oxzUS69aRBnNOFFWmdEW00G2j9psHvqFkP+2RdSgkiBMrEGFKzkJcOkytk1pDW8N6crUMNdI+h8w8m0he30qSKJp2mzWm9A4C3w7biITzUprzAmNIX6FSQg3eMyg1z78yQ2rIpWutt+hfaw4JBsNv0OxNBJWRF760nuTj98EZeh3GyBtCL1KS7nbY4bGjz8lH20T2EI7KBgEmxqeYClbYs31T27MaujvaHg3CrCOjt92BYg5NeoaE19XGdbL3GnmGVpsdqIAdQdbIlixSp5cuox3vs0G4OQVqPLfdjkWcwZSYExbIxXhiZwsO2xHTjGWKmVqTkK9KeVWYXheW1wuX9xYu73m2NT+8Il1fIcsDlCstzd5g/LHM6QwTvgwPHtDh0XQ87r9oW+5tzNfiON5lm87b2YbeZ2Zne/ySvf4at29sx/WVMqR7p3K+/xI8+NLr3nVw798/XnvOxPrpNfcOCz4Zc37xe8N1ifd4LfPsy1bCcUkPx9Wprbqh7Q6xEONKRkzauyHaj4bKKH676GyLGpBBMnQT0IIl251SEhdQTeKCqSqCtejvsrjgTVzxvHq+1aNGYeAzplAI0gZR1+ibUWN67mUuLFMhX66gPr+j4azFRCOJUSxSW/MMZJR9WnIR3AW4KGRrSGtQG22tpKyk7PT1Rjgkn+2OKmRVyAG3BNXcCD10ceZgsxA1lYwPjpzYKDSKz+NiirpMdSKGhTrHXvQ3irhD79ZZW8M2Jz0oQkF9ZEjUmqp0epAjRofr/vNHJhCv94xBaOG8rPbDYQCoK+p7T2DfC/cuZRU3ZX+9YeG4ZBd59inRnnFFiWnvm+rDWdVBR2f3HBL119FL2EZCYx787FBoDcfFcF4jGzrmYY3jaBDK+7I7pAFmjP1vp4vsHjGzOMPD+af9+juy06FjeDitaOCO5mJdhDQJ00Niel2Y38xc31u4vL9wfW/h+ubKcn2NXF7BxeHBLnOEMs8d0mjz+HhWpfvj5+zrmLPla3L/Ue9yXMOc3Nu6ezv0VdmlT9i+mqTg69i+sR3Xu7Z3UdvvqehfLQX+rr/jE53avaMasMt9cfSMO59T+K92EyGnGb0kSpno3RtvS3FdcUnC0zKRikKCbVW2nLDb5rUbT70QvNhtgte4QgnCstEk0RTatlHUKCnRq1G0kckskp20oIpMytzVR7H3RGqJrW1szdX2Nms+t6vV3TD1re9Cr6pAdqV6UWF96mxp48OsfDjfuD7MLHPm4fo+qa30trJtjyTbfOiGKCVVr2fhTdm1GRudWRvXKVTWbwl7ajy1R97aUyjmSxg5w7rQ8KnRDdfsIznHz5MXi1El6RmU08lsWliZqSS2nthiumxrAr2gvVJNqGLUrhQgxyTj2o2+bqzrRiKRUqGJOV1dBC3uvGRXgR8e+pQFBjtyjLqvZvTWaK3tDiyJMqUU2bK3VZwHkop5n9UONAzqeTiuHga7qtFzD7hX6RE8mOHwcGTwu4MIX703CYcjGtDbTnbrElOoO2zGaAuLxMqdNOH84yIbl5tnpLJfesYQij8GsJziNMJte+3Sjk/zCQn3CULMHVMLCTBf85IFLUJ6SJSHRLlmrp+6cvnUleXNzOvPXHj9mas7r09fye9/ip5f09IDN5a9ZhU5P0Px/bnyxZijNejxGo7ref2rkfdjtM/VgucI0JFSHj/uXTawf4XnP5b+n7aXnJTx3Db+KrZfn44Lnh+o+xu8O8v6So7spSxrbC9FJ/efOxbWuWj6Uhr+iZGO7CiIkshp4nq9ONyhPs2143UoC1ULfUpIWum4GG8b9ZLAaY5Ctv9/j5AHAaCBbYZsRtdOi4GWKfkssRQOYIyzIHmRPolTprU3Uq/ODRhF9gZDe29E8T3ZrkUo3YklT3ajWeNpTdzqxHVKFJnIpSC20vvG2le6VYRKkurHxSBjpL4hsiHWyEmQKWEBZ6FCU4dNK7br1BUaXXLM68x0SyF6Kz6uRNRJGLZ3W0Vty1X8NtNwfEBSsAlDab25PRFnDm498Yg7jslcVb6ooNKxlGKZeCAS6QoQsFw6erfcwXmLguv4dWpuVG0+Ty0ZKSUfXzOFdqScWpWDWj5o7QM6HHCyYa7cn6I22oXegxrfDxjTKejuKryta5B0YGc9PAvQbCQ5u+M7LoDYD8LR2PEMtpdqdzg3UMjYj3CiDIcQeIMd36qMzx5StMd1db7s9qMktk8MkELAg4pOQcJ4XZgeCpdPLVy/debyZub66YWH96/Mby7MDw/0/IDpQpPpWU3qYBLyrH51Vr94SZ+w4RqE3aKudSZk3NeyPmZH7rav1aG8lD3d29SRnb6LV/B1br/+HNdLB+clp3R//6txWufXnj/jq4k87p3ScGDn9P3++8+Pv/S94OwvTUzzxBKc57Z1atS4mjWHDSNKb7XGZxlmwUc2l5PahUXhgGOCkj1ETaUSs5+8PtR7sKcVVJUkgphDGGqukm7qkKGKgHS2MNBOoe8MylfHI19JvhcONfprmnXWqmyt0x9mlly45ClGwLsobDenvmca3ZJ/J64CoRblbcHFZAnYTEA1hILFA371mfE06aE0pLTuRIwmGhoXEt1WeY+Ea9xa6BESGY3/hhhxIuqZSO8hlVVYAxrMKkiyXdiXfGLDxfn33qoBETqJQ2UYV/E+vc01LZs2urrTcumhTEmZMmdyisajoJBr84DHT73tTbfPHBceZHgvoGdqQ5PvzODrdkwO6MEtd5beCI2eO4gRX7JnUmNx23F9xH6eM6HhpJ5dUnf1rsb5EnPndUg2HfmZwVH323OsPSF8fvxVXFJsEnT2BuP8MDG9mpzy/t7C9f2Z5b2Zy/sLy5uF8nAhLQ/0tNBlYh/K+Sxr+jidvX+CM+sozVIwh/XjzMGzffnVZDnvsovvclZfKWn4Sp/7VWy//h3XeOycIb0r6/pav2MshvPVpHf/3m/3V9R50xded/7Od0VNIuS8cF2EkgraHb6bpuIDGhNMj5nHyefqpseV7dH7bWrzfzGv3Zh2SC2yIB+YaL157aIKffMo3OtmnSxGso6RyTlF5J+ZUboqPSmpdzarbOZzmlZrVGls4hOd99pXWGmn/rsD2U9VjGt/asbTbQ0VjcynXl1YpolputLTax7rl9naB0jdyDyRWUkkZmAyH7PXpNKyUtWNQkqenZYJSO68bupEik3hSfxTjIT1RLdCl6NQ7jpZkWaKp4+JzPT/be/vYy1J6vt+/FUP3X3OvTOzs8uyT7YhQBwjwkNsB69WVggSaIEgy479h2OT2InyBUEWKbYJQlixsR0pRETKH4ks578QKbbjWDJBRo4VMAaLeE1iAsJAsjKIhDywRsE/YNmZe7q76vP741PVXadun3PvnVlYz+75jHpun+7q7urqqnrX57ltp+92/UQgeuUqQkAj4zbKIUnifEVo2oHWO9qmwTo7GR8QmdPZB4tLUdPNpKBTE/FhGBmJBIToInTgvaOJjnXb0ThPa10K56RRLmJaRBBBNikOoCjXNEWzMBNvlPqfTBO9FBE2AKKJUznxonpM0WbS44mzmlAhLYbyuMggaJiAMUsGM0CaAvnm4LZm5riYy6q40KRPITMSVeMvTxMlo6DDS0XYtklbq87F9qihOWpojhvWdx6xutqyutJw+a4jLt15zPpKx6U7j+muXoL2mNFdZcMRAx09bUo06gjJBD4m0fO2o/HsgJyza2cQG/HqDJ+lIzmP2Sk059S7zh+L86koyrkpz0WlKHFpXq3nr9II52aAlKcicMEyN5X3s5y3LnsT6A9sr2yysUH+eOUqKFNZj7pTLO0vnTOkVa8ub5xtMN7CZYM48K3TjMc24luPbTwSDd6esDEb7UOD6kCycNwk5XtMPirZ5DgEDc8jvY6OIBZMpBVwSSHfRsE7i3NoZHkBYyytS6kwrMUFgzUjYxxxztJjCaJm88GGQnchKX+VRt6Y2s8ERRaUE/vTMdI0nrZ1HF1q6LoVpvNItPSj4XpwPDb0tJwQLazbE5wRXAy0MTCK0fxT1mAag3gVATprsahCaZPkVMYI1qlzs67GRQ0pTI7zbiCqyHEUjW1gjLabdRqzzoho6hhxOGkwpsXGLn1DwTf6Pk1yayBxOzZETIgq0hsD8SQggzASGUNEkqm4JHPxGDWHm28dThwr09JazUkG6mcXRQikBUPmrJxJVoZ6T0wCrSTOzaCFkSkhpKRjmVPPFoAmSnJIJnmOm2mSFWHyEYt5AAlzyKYCsDPFgjtSWDXTbzAzgEGKuZs5pxLkkl5LTDHfzgukxA+m75vCYiUuC5tM3juLX3nay52KBy+3HN9xzNHtLavbWi4/84hLdx7RXV7TXb0N014m2DWDOSJrYbP1qcoHSqBypzixrM8KpZ4r6U+VyzLbwXKXQGFJyiPV+bNoF9e0pDYpz5WAVRut3SA9NYCrboSzGqVeITwR4FWvctjxe+n556FdgFasHq1xGGdogfUqqMGDBPqogXQjwtiHaVIYQgQzpMR9WsloVAFvTNzKPySiei8zBg1yO624TYrzpvH7iE7B1MxiJGcMOF3l5/e2Oe0FMOa8TaBO0iZPZZI4mlkXgVXOI4pJDq9qPj+MFuOEaD1iPWu7ZuWP8XbkhA0ncqJZiw00MuBiwMYU0SOL3pIVnZqCG42QHx1ODN5kgQ0Ya5WjwRGMUYM8o5HLZzN/AwREb5qCUSQhjxFcjlphslywQUyHXzmatqFtW10wpAgbMcXsEQA7Eo1G5R+JarkYNA9aOXkZa3BYPE6dxklm4RLVcEOi+uml7wukaClZl5U6rs3gJROjYjI/k8ErAQ/ZeTqi4sbctwIqZk6LuMmIIDM+SSw4+R9N8QFnAWM5lLIVY8a3koFS0/wMZ9uWhSZx9KekWGYL3rbAS3NpGay32MbhWofvUjSM45bucsfRbarTWl1pWN+2YnX5iOZ4je2OCfaIYLrkIuEro54yIsbpXFqzeDBbDCZ9Vl7MFbroRUCCsmFOb/XxknZJr/I10+J5R/klbqws97QFrtoP6yKNU8oFyjK7RHznqUu5qsm01FHKVUrNytd/c/mShB3vZzA4vHOsV4a2aWicQ4zgvcNZA8HqhOwtwYA7MQyDxofrk5XhvHrN4iLSZCOExAGozkdFSs5H2hiR4GicJ3ohuIA3mk3ZWgfWYJzDAj4YRok4PDZYtTZMKRMDgdFkYZcoaAUh2DSJBJLILE38RMYxEnrDGAb84GlXlvFIcO0xtvWsViuux45xeIzHT/5/tPJVOtvTMeANOIlJ8iFkhzbjBOsbvLS0xmLHZNYugtiekHQUA46NOEaxjMahWcwc1sAQjeoRsTQaVwNMMl42Ua3/SL5QpiF6R3d8zLprWbctw7Dh+mbDpu85GSLDIMQxwDBgx+sakWQEM8iUcJEebNAwUwaHM5pvDFIgDRHlsMM4B6WNM3DhdF9s0nGm8TGBWM4GUPb1zLBPzq4yAdhk3RZNCoYLOQy/LlCSIVDmlvJ9EthNQ8dsMws5S/QEaJI0VkUw7WyjZydejSIB5DY3NukIp6FkmNLHuOQ60Vr82uOPPd1l1V+tr6qf1uVnrllfbemuKPe1unoF2x0R3GUGVox4BhqGBF5D6j8jpXOxZcnhOExgp39PBU8u/y6B1i6ggu1Gzdt5FtXl/LNrIV4ez/Nj4Gx1yjno1gaui9AuYDuLipXhFtjUtARW+XjZYXI9avPUUF1zEbKcCp7pjOakcscGMYG2bVRvQkPrPa33WGu53jVs+p7rmxMY1erNxlGHvcl5veK0qpaoySONZPNnwYWoIXkaz2ADrQ80zhOcI1iHdyoqc9ZgnVWRIVETOQoMEnDR4xlQrZdlMAoSWdEvMc4r/MgUTcEi5BAO0cAoARkiX47C4Ecu2cBXveGx7gqX3IpLl67QDl/j8fE6drzOKlzHyIiRgIlR85E5R9utsc0xNoDZbGDYYKM6EUer7RtNgzMdTnQCisbTNZFBIhuBDXbqCpaQ4vHNHji6bvY4VjgreB/ZRMewiXxlc8K1vmezGeiHwDAIEjU6iYueNrY4M+KbQcHBkEzJ0RxYUUWXJoUpCkaQqMlC4xghJRolokYZKctitAbTStGPSwFd7toKCpMor7RkGwUG9d/S2F/M6UWyqDBZCs4halMrKTu51f2XJFuZ9y25sJBzkhSc1hS1Pdc3NRGg35G5bP6rHHgKeZWyIjTe4Vs7RXdvLzd0V1sFq9tXrG9fc+XuI9a3dwpot18iNpcZ7Zqejg0tgYYhAdY4OalviwpLACsjYcxGQF6j7NduNOXidwl8akCruat6wS3Mc91F5slvIj19gAu22dryWPlxZE/ZpQ9en6//1srIfN+aQzNVufPQnpWRKq81GeSqW5PlPSFl/7UmpZawYLymQDE9jCnQruTcXXklnCaWyRcHjYmIMVM0A1XAWz3vdUKMTkAsTizW2WR9aNRxywiCS9aDESspMgc6cYyiYrAQR1W8J25IUnR3CQn/Deoca0iRM/T5jwdLcA6iJyJcc5brznJExBuPty0DLcYM2BQTUdPPGwItYQj0Q6DfbAjjgBFNVU8yAsCqn5VLHzJzKCoS1QDBIbWdTRyX5v4KOVoQBos1DRi1nHy8V7AeorAZAuMojKMhBgeiItZGkjWcAecC1ml4JVArURMT9wVThBTsPFFP7RhFs2Qn4w6MiggnLivO3x09nfqAJDFyWkhkAJui0ifwGgTGFCszModqkjy3pvpsjTV1sp6HSjYJSY7FRX/M52ZdVzanT/ETp7/FejFVd1tQYaY/Jn0/a1NoLOfwjce3jrZr6NYN3XHD6lLL0ZU1q9uU4zrK1oNHHbRrglkxmnaKoJKjqYQJrGY/wOX0JVV8wqhxRyexYCkehNNzEwvn6m2J2yqvNQvn8vF9z6mPLZWrz12Qnl7AVVLN3tay26VGLRWMuewucKs7R/mMUjZccnNLloZnvUOmUxY7aZ1pDF13hHUNzqlVm3cW7x1CxLYGt7GIjVhnGAYLo8GEgbEwFdNJIq3SUcW9BAgyEp1JimIhOktwOiFGmwL7BsE3XtOyG4tr3JbeS+31IkMEjyMYhzEOGwMhRsbRTpaHMYTZempME5cFa7VukRRyyhqurxqGaBlHuDZAZw1HTrijWbEyDSt7xNpewsmAjQOOnjb2OBNpgmW4do1xGBg2+kBvRF2ysESrnISxvYqkTEDEad6ypC9xjDo5icEyYO3sqeMywOHAOEQifRh57GRDP0Y2Y0zZptUqQt0JdBoTmxNZGhqJWDdMgXEns+ig3yyH/orzjD+DT0TFeROzk8DA64JFghaeYh1Oort8kwQtyWHK5HBNGzRA8BCRwUw6UpUAmmlImNSHFUi0fjmaRrYanKVJcyLIuUfO3FfWg+bsLQ4hx+6dLAVNSqyKSZxXgk6T/lrdt0ZT0ThnaRqPX7W0a8/6qGF9uWV1uWV9W8elq8es7lixfkbH8Z1HtMdrbLvixFymN2sGWvoUTSUD1zBxWpo6NINTuV+KDUdRgJu+a5meZNwxJ+xbdJem8qH6nctliZCp9mGWFMH23FY/pzy+CyAPwHUG1SLCXTLZTLtWLiVglZaD+dgSaNViv7oultP1KMV+uz5uzantegYASVy3djjraNsTuu4E6wztSct6c4JvHNeun9D3PXazYbMx2BBSlHOIpDxeRJ1I0WgJcYyaqXY0DG4kOIu1kbiJqkuzjqYNNONI47M5udf09Z2a0DsHzgleLMFERhMwNPiYoj6YkdEEwhgZZSTagCSrOJ2g1dkVZyHalBpeLdqCd/TdmhPpaMzI18cNjw+ezo60duTY9nSmpTWBzgTWLgVtCiPOekwbaPxIlBHioHqulGMMbMoRNSAYsF51WmbEiFNHazSwbWNFDVJM1qWlGIaigYxjiIQxcDImsWsUNVpJn9MZm8y9LU4EbF6LDzSNYCOYUQE1++OZ7N+GTtGZ8wEmMNF+pByXcmfMLEkCtkmfNeq5Oat9FiGbKUST6Q1yPSCjEAYNfhyn8vruW+uryfJPKOzrk6hvDjyz1e8LDM56rnL+tcycWi5uEzflk7HHmO+QHmRJEUqcpXWa/857R5fiDWbH4svPVLP3o2e2XLrrEutnKHCtrh4z2CM2rNPWoQlrlKtXfWjmumbdVikinAGtmc6PNAzRq5g1JePcEhXmxtmlxijnodK6OZcr56haVFgu1GsgOuve+7i7J4CeesBVA0O9f5bMdl/D1quFcmTs47TK6+vn599uoSyc1p2dp66m3E0/jEZzb5sOREUhowwYp8YaUdT83XmXlqmCHQYVQUWIMSQjr2z2jIoukgJbfZFQXZQBXCAGwds0tURJDq7KtVhEASuFeNJwRhabRYkm4AOEYBjRoLeBgAuaMiRGjd6RzfWnUEKomTwkQw5vIBr6xhKcJ3hNP9LKSBsDg3V0JtCYQGcGrhtHa0JaKxvN52UjVkaMHfVvLD5KEnNOn1fGJPrUctY4sClOU06XnCdaIeWZCmrCHgLEoCJJEdTrLs/Skpo6WSUaDQHlyFmqAYuGdEyZiKdOYmYruyx4k5RQdBLzxfmvmNPHRVBwknSPzKWJgnDO/WV6QxhS2hkRBjm9jpuHzMwaTIFsYX7PHKzZzGCJYbJArZjI/GaTcNCkvjEZbBTNYovnmuz+4C3OW9rO0XQaYWR1Wa0Fu+OWo9tXHF9dK3Dd1nF824ruckez7lI0jI4hmbsPkwWhn7in0nqwTlcyg5hP/l2eIE4djFOk/C2T9yW91RKdBSI18NSc1RIHte/e+8Cqvs9NgNhTD7hgGRx2sdAlnQUM9QrkLI6r/GBlnfK5Jeuakj0vOw/F8bp+JXDWNI1ZjXdtfYsxOkBH6XHGquVhWn06rw7L0USst5iNSanWDSHpPCSF+LGiVnPZ90qiAls0KrYTqz5koL5FIahuxFsV5Xgr4KzqE8SmZ1us00k6BkMIkQE15gg49QOLhhAjxlkF1BQN38Qc7QM13Q9gvP4eR0NoNN3IgKUxgZbAYByNGWnMSGssK+toGekMrK2lMVEzKFtVk2NGbDLFy7ohGwdyuKIoaS0fk9O0dRjxqPetTd9JkrV3zjMVEjcUsVHU1wvdYgrw64xayDkEb4IacxiNv2iNxSRrP+O1j0jiosxCp1fQklk3GZnETzJKof9KIaWiLkykcHbORoiTbjOLJ/tZmtWj4FXqojKmThnZTIE+CbCyQcV0WKb10ba0vTg+dXdJfX06KGR7+QxgxqQsBmQ/LTXCsK2aureX1NS9WbWsL605vtLRXWo4un3N8e0KXBo49wh/qcGtWjasGRKXNSS9VikWrE3fVZ9VpzBJoCVqxBHFEqPTxky52U5xN/W8sDTP7AOtpf16TqtVJDUtgdMu7mvfQvwC9NQErnlJN/+uRXYl7ePCysatP6hZKLPrHhmoyg5Wyothyu+zJQaoP3rNtp/n+RXnaY2jtR1XL9/GSdNzctLjfUOz8lzvT2ivN7jOqxn25oRr108Yw8AYHHawBKO6JyMhz2P6Wmk1rubyI2KMRs8QNKuyCwxYWhNw0dGIJVivzrh4Gh9VMe4snWs0JJIR/CiMLum7GktrGkYXGO3IKIFAII6REDWqfc5kTIwpAaMh+AgebGuJnaNvHNcbuGY9rRlpTGDNhj6c0BiLR+hAsyebkZURDYprDCtr0ZRUGt29dR5nNJxUwiWiQB9Dbg36CDFqtAojJCfdBFYSMaK+Xcm0JH3yWdzlSVaYBloG1vQ0EnAyqEl8SI6+6OKBnOVZclSLCRkQkvguiQplVMChFzgRtTpMRhaBFAMvziK/eV6aQSwzAzkjSd7PUm+9ZhbpTSAkqN/cxCfpG6dlFuMklE0gLSr2yyLEZARfDAtD0nTO61Vrk0heJg4LoDVOuXxvaY4b/Nrh157V1RXr45buqOXy5WPWV9Z0xy2Xbzvi0t0r2ist3e0tzdVLxJUjNJ4NHZsUESPvl6LBzGmV4sFxa98zJJAbaBiDn90L+qIxM8dVjv1yEVzOB/sW0udZwJ91Te4Ipb6sBNV8XKp6139vgG5t4KpRHc73QZaO7wKv8+jBllYbZR2X9ksusAyRUos3Sxl06XWef++r16klatIfCAgWZzq6RkM0YYEGmr7BOofxhqb3+NaCg36wDIMGjTXBYmLQQAhh5jykbIgk5omixhkWp07No0N69Z2K1hBHUZ8mItFrdHlLmsRTrEMvKh6yRKxV4w8nAe89QzOkmIKRMATVuyULPZF4ShcQUXAkokF2vUO8IViL+lklkWgS6OSYhgaNiOExRBtoTMQTEDNgTEBMpLERa9N6WoTGqGHGGNGMy6QMyWI1c7QIXuMtoRZwkC0PZz5FN29TKhmjYOrHxJ2NAieoj1ROGJgie0wZWUA/etJXSfmthJT2RBS4NjCOmukkZE4LCg5NLwu5dul+IYGSGqWaIlBGFj3m/sAUtzAbsWiCy9xdtY+qnYSktZxMazowyboz85Jma52a13b5Go/NNheahsQk45mckqexuM7TXWlpLzW0lzzrO9asLnesjjouXV6zvnLM6qjl+OqK9TNW+OMGf6mFlSX4ht609DQMSZ/Vpy2bsM9cVikytFsGGlmsOIojTFyWUdDKxkjl5J+HWimhqRe1S9zPRek8wJWP13quyOnnl/Pj0xa4zrOiqBt8F0gtfdR9nNi+Oi3VYalcKUM2xe8lQFoSBdT12wfAW5RWuMaq0YZxU7QE1zh1QvUR11usN0QTcb3BbnRCMuOgK3yEEY1sbhJQFAIe/SspN5NJeoygK/xgNC27jBoE10lEBocXwYkHCViSNV0ANQgxOGMZLTjnCBIwHgLqrjzKqIYORIwZmXx98oSbnVqT4kUijMmAQUAtHsWnCVM5OQUhyzAJ75IIUPPL49kQTMCaQDRjiq8o6Z2cLhLE4EO2pjMEcSlGIanN4iQetCIp/FOcdHYG8HEGLiMa7DivyKUX9Zcakl5Pcrfa7nhSRMmYDDMkBddNubPoDWOYLNqZor6TxIdksR+ngcukJk6WgzEZe2QTdQSNhylMkVWsqWMIpB4kqStnQ5Ot9zFbwCdlrzOZO8uiVRKSaeNZZyeu3lmP65TL6q6o83B3ueH4zjWryyu6IzV5P7q8pjtqWd3W0V7tsKsGs26Q1jIaP1kO1lsWE5bBc+sYhFu6razTCnaWt+atBIHtobw13LY/+MK2e0pYvj6fY8f5GpCWji3p1Fh4lwvQrQ9cmQPZ1XBlWYrjN+G1/YRRrntpmFFySblMHtm7VlXltfWxM8DMGE1HctSs8Z1lHVu6wdF83XCtb2mOOlzrONlsODnZ4Jrr9JuBoR/Z9A7jBtUzBSYd2ARfWRQlICHqhJp0YBZDNJZRBNsEfGcJ0uB8xDcB13i8tTgsLjgsukLGq35CHEQfaa0lDJEwRIam0fBHEhkZGFEOLBDSczVqOpIs7IwhBIEUDX40U4qrxD04LBG1OkteNpKmHBnw0tNwnYYNLkZkgEFn+9TPhslnyVs06n3K57T1+WJMHKA5Ndgzo2ySyAwhBdpl0kUxkEIlmckCUDEqzoYVOXJFQEGqj7M8rzfEjWiA3VE4EaGXOeP7xHVN3zeDmZnAJJCMczBb3JgeSwuXqSsqK5g5SyRO75hFfLnb5iSTJl2mfn5MzsVUQyKDnyOJE71Aq6lIXNJjWW+x3rFarWhWXrmsOztWVzpWV1Zcfuaxhm06VuA6vryiXbX4oxVm5aA10Bqus2bDahINZlFh6WSshhmeOeHjDFjKoc1RMYaosUS3xINZt7ULdMoXXwKWmkO7Edo135RiwjKnYO7/oSpTgtZN1unWBq4lyo1T66PyOarjN8JVlfeof59nlVODZ81Nlde44lhpFCILZevfZZk8a1T1UimOwRhH6zRNiOssxnnaYUO7OaGxlusnLV3b4rxn027YDANmYxl6QxwDY4jYoNEuTArQOjuwxun5GrBXc1JpJmHBBk22GEbBN2qk0bQjYzKnd+Lw1k5JFQ151Qy28XirkdBd0Nh+UTQI8GgUuEbVgumkawKxjUQviBdMk4wdiDgJk90XRphTRKa4B6KGyh09HddpZcMqbKBPqUROBHqm/GVbIdOTcsZYM3HXyojItmMpylFl0Jo+klGRpUrSlENTcEhsTgSNhpGD3xpNRaMsEDKYiauSQVSnlZ2FTwxyXYgboY8pjyOaUDNIajdB40OmjpN1XPNC2hT7udvNOi2EyVpRgSgvb3KqkdQ5TR68Zmt8ztax2q5OEvepDTaVsWiQaA1qDKZVcaD1Ft843NrjGke7UovB9qihu9Rx/IwV3WW1Erxy5yVWt61YHXccHa9oVw22dZiVQzp1ah9Nk0BrFg1mENoO41Q6GtuCC3OTODFIcjAe0sopg1XpZ1XOJeXidmluq8d/OV/UVKP+LiqfX85D59mWYilmYLtBurWBq56ky8bNnf6slco3sh67QKv+nTtB3XFq7qucFZY64y7Qyn+XgNGYKViucS7lezKsMdhGV6cignUO5xxi0sq1d+q0bEUzKg9BzaFjJATN0yVGDSX0/jJNMKXzqxDUKVXSCj1YfKPB8KIXgtUwTCIKXM66pAvKYXm0kSwGrEZKiKhI02EJRGz2OUONDWIbiF4z+Bo/0kjSN5HCMBkKg+WAS+lQfFKhtwy00tPEHjsE5ESQDch1mVfKhXjHGOU0M+dsjNnCtMwVSWACJDN/HqVsjWCZooRoAQW5bNo+RWbP+8lSQnI0iwxcG5LvlcBGiIMQQp4v1ccsi/uEnPVEtrrhdlcvg+HKqe5Xd9OJ82LmqMotl7Pm9PG8n3VX2f1LI38pcBlPypmlfdg1Ft95/FGDX3lWxw2rKyuNgnG54+iOI7rLne5fXbG6vKZdt7TrDtc5aCzSOgUt6wvOquSuZoAqE0CGLS4rGWuI+nUF0f0tx+KlkE675pN9tO8jlFTPM/vuBdtcXLnVxhl1R6lFhDcxB9/6wFU3Tn0OthutnBW+EXWp98vzsFzHJaMNW/0u5Se5/qXJ1q46nSVH3lIwaMQK54TjxtNJQxcafOvprrVcPzmhWTmunbR0/YbmuuX6iWcYBjZ9j+0tIWjiyjAaYkrFoevrLGBKryLq1xVlVH3ZaAi9aPDfxjGGiPcavWD0EZeyLHsn+BTdwFqLTxHx1afJEK2mKYnGEUJO3SHKc5nIaAOhiUQfEa9hmBoMLoVS8gnAdIt4CRpNnoCnp2FDxwlt3OCHHnncINcEToBrTIYS2bxOLQi321p94czEiZDagww6xXefdIMu6mh1IM5gvYA1Wzmupi4eNeqtBJIPELABNlF1YQHitVzPCCcq5h0m3I1JSqUdLYoQcvR+ivnUnB5i20MgddhivKleKnNPGXUyQJXQVPyx85BQ838VBVorUxo0nEnZiZXTsj4ne/TKxTeO7rilvaJc1tGVlvXVI7rjhvWljuNnHLG+1LG61HL56ppmvcK1LTQeWoN4w+iaLX3WSTJ/z1ExsoFFzpmliW1mq8GRhp6GIMlPKzj1z4qcjoixBF6Z9i1Y99G+crsW+fuO7dJfLYkK67JPe46r1HHt4i5u9EPfSH0uej6/g632IZtHzWbyMId52fXuS1RIXxZpWr7Om0F1TNY1OOvouob10NE+7uk2G042Pe2qodt09MOgZvMnJ4zDyNAPbDYDcdTIFyaSuKqkIZm8/EVNsRMnFo0go0bIcNEyNurX5ZqgDqLW0lqPdx6XuK1oGo2DiIqDTBITOacix8zJBSMagsqNhHZEGkGaiI8DPka8RHx0Ki4USxMdDZZGLI0YVkQaibQS6KTHjhFOLHxd4HGQE+BxUe6rR4GiT9xOVAmYmSbxHNsBtbScDCU0IoeClUzcrxjBeoOoPT60QlwJ4iOTi1j6btHlmI7J+GWIikbXgBO1PJQepBfleEcYgqTULIYek4A+c1omuTsIKb79NP9sS95jep8kNpR5kVL+zb+mXFdVGTt17hnGJCnI8rBWa0HAWdUbeoNtwXiD8WpQ5JIeq+k62s7hW8/q8or17R3tpYb11RXHzzhmdalldaXl0m3HdEct7aqh7VaY1qlisoXRekYzm7yHFCx3QzeZsfdTHMIyYK5GsRwnXl3FizEYjYRR+mZly8F9OqEngvbNFRcFr1oUWAf9XXqf8vlPa+OM/Lfe38XhLN3jPBzYUpmle98MW7+05Wfn5y85Py/VaYkbrcFrx3vPebMszhiaplN/l8alSVQDjxoPrjFsBo/zajgxbAac08k3DBY7GsZRRYgmi5+ICRyTiDDVUUxMYi6drKMI1qveyqWo8mIhBlFTZqsiN4dVjgyXdBtpUpxyLBms1cjn0YNbGTXT84EmOBoZcWJwweKixYrBiaUVSyuGVgydCI0IbYw0ydZbRqvx+HowG5CNwHUUKE4UIDSp4yQlTZ8mTmblxkiK9KETtCEDVg5TlCKaWAUvvECHcmeNEBt0FFsFsGxFiTBFZZ+U/EnpL70CWIyJ0yIt9GUhOMP0zXYvnMtup+9R/i5nQ+2A2YC9FC5YzGRhmLk0k8TY6oI1n8/hm/AmgZXBdmiSx9ZOHJbznq7r6FYNTedZXVmzvtLSXW7VmfiOI7pLDasrHevLRzStx7ce03iMUy4ruuRjZbatBbdFhLNuq47qXnJbg2jG4okLzg2fuayaU1maB+omnTvVN5aWnre0xerv0j7V/g3QrQ1ccLrR6ol6ic1e1PVc8Lkll5TvVa6QljrcPqpXIrusHmtlwC7wyvUp2fElRUF5rvqbAaxxLd54WmmxjaHpWjZ9j+8M7cqy6QearsGeWPpNz+Z6D84y9APjYLG9VfGhBHLohCxGkhQpQrKlX0A5AYM65ibHWmcd1jpGC4GQOC5LsFENSqzDi4oTnbF457FOuTJjwTmj3Ig3yNpjnJqud9HhJQFWcAm4HI5AGxS8VhiOIrQxZXkeDBIccRDiAPSC9II5sYTrgtkIcgJxkEkCBJBzRgWUDRTJhtwBRC3ODKKiT6vSQTU4SM7PVrAOBa4RpAXpgAZN/Oghh2zSEE2kYLcZvEw6pr+jzKeU4yJxW1nMlYCQ2fiiHGJs/TXpHfMQMNP5efmQyhbjzySnao/qKafITwVHljksj8Gj5a2z0FhoDLYx2LXBdhbXOdq1xzcNjW9Yr9esVspJra6sWF9VceClO444vjOlKLnc0q6Pk6OyAa8iWLFmyydrd8DcOTpG6bsVkgHGQMMgDT3d7JdVAlfNkdTiwXoe2ecu80TQeUCwBqSleXjXBtvvdwN06wPXPiobJlb7dWzAm31O/awSPG/mnmWnzg7IJfdkquNL12Uq9WZLVB/fAkgV1R03l+lWA0MYWJ14rp+s2fQD3fXrtCea2+vkaENzrWUz9GyGnv5kwzCMhDEwDAMh5GjvSRdj1NdLrRETBzYkTsUKBM0nZUzEinpXJeEgvQ24FGOu6dSB2YnDmyE5n+YwUipCsp3BrgzeCq0RVmLw0SrHFcGlBJUOw2qERoROApeiJstsRiHGTjkpYoruEaf5xk0m+ELvNGexRlFSu8YgOU6hFLEVZ3EcRn20bNL/pGQeNFYzTTcRuhGa3mAaA2ugRUWGjUAns+gwTYwyTTIzp5eTJStQpTklHYsprKKGZNTM2aW6haJbLXWlmSEw23Ouyd1TuScS5zRzXbMNSt6cUXzyxtBi6UxyLWhVAmA7izkytJcb/JHDH3tWl1raVrf1asVq1dJ1DccpDUl7KUV2f0arVoYrD8l/EWu2gtwOE1jl6BbNZKZTbiWoDZPYUA0wTlgTo9XvsWEGrtpHq05Tsov26YbOWizXx8vgvPUCfxeVXFWuf8mql+BVixFL8Hpa67hOL/22z9fHYLcs92bqsevZN0rlzJC3WnSwdD4/u5Yn1xKb+vql+wFlriKMYKzF02CsxsezztM0Pc4ZrIe29zSN1cgbg6PpPSeNoe9HhmHEbAzjMKoJ/WhAwhSZQqLqucp3ENJsmqwcoqSo6aJWf9FpNmYXVazjRsG5SIiWEBMHlnzArFVjD0+kYaAzA50Z8TaoUUZUq3WXtpWBVoRVFI5ixI0GKx5JIBSxE3BFK9jkXhWMQVzKvaXh1km11U8i22biMzeTuLAsqZX5k4UomicsfUczqCWkSb9zCCmxaCXSYmbKcpwXBFksS+Z6y/mkjIaRrARN3t/uSCaXy11lDg5YCDTmME4mI1cBVCU4ae7ojB1Z1AveGrzRrTE2ZRIwGlew89iVwx87uiue5rihudRydLml7RS4jtYZuFqNOXhlTXuk1oN+1WBbq9FTnCUa3TI3VXJQmaPK1oI5EkYdLLe0Px1xDNKoqftots3cayOMcswu0a7xu6v80px3s1TOL/XcuyRLXlpML83ZN0BPDeCqG2Qf1SKxev9GqAaN8tguLqakXYBXckv1dfvedakt9oHWPrFjSYkLsEbdQL2zWOdpG0+buJ6TfkPbOkzn6IeGdujx1w0nJwObzahisI0lDCMYDbUagxpthIimI0EnVVHk0ok3HSMKY1DgMgKxEWy0jGIYG83G7IMlBEvwESeaY1jFiVY5x9hrUF0ZaF1Pm2zBvIu4KJNpfGeFVoSjKKxjTDGMPAiJcxLEWIINmureStJJQXBpwk51nh23IhPbA7nE1lhH8ueYnblzqKSYUqO4UUDmCPKSAgyLBZOSUAlMxiHE1I6RFHVdJmCKmauSrNc63ZV2SZa3u3h5tDySucei2xkzORO7ZCXo0cw0Dcly0CqnqTEaNYuBawzOG+zK0awb/NrTXG5ZX3W0l1rayx1HV1Z0nYLX8dGKdacc1/pKR3dpjVs1NOsWOos0KhoMVvPAzQ4P2d/Kbon+ZMvUfQavEsCyvisHy5VgTkfCKDmRJX1W2YD75oubobMW8EvnalFfCVpn7dfg/LQFrpulvPS7SPl9wLeLezkvlR+25KJyZylNsHL5pY+/dCxfW/+9aF23ANDTWUfbdKz8mqbr6EPP9b5n1V9nE3o2oefa9ce5fq1nczJw/VpHf33D0A/0CcziEAj9yEDQKBwx6qSQnF/FhClsk5QRI6JF4qgiMwwujNhoGUTN5D0accNj1UIwgh0CVnpwI2JHnA8qNrRR7cVMwBs1XG7NQBtTQNshIKPmH4uDwab8UyGFWMJIkqhqHDz1MQoKMklEhjEp5qJGBpe0ds8+UplRKkVsW14RarkConoym54dbeKcMj4mU3mErYnSKEpBLOcUU316O4EahimFyJStmLl7SnFVGc29LIdlipoBMyeVA+U6o0DVWUtjDC3QWDUK8hZ8A9Y5jZ+5anCNwTeOdtXS3tbRHHvWVz2rZ3a0Vxq6qysu3X5E1zWs2oajS2tWbaMJIbsVpvHJWtDAisn4Qi0EmyT2ayaQmtOQaCvF4tucHhrz+QxiEs0yUC0B1hMFSEu0NLaXgOsiHFFtU7D0PktcWPmsG6SnJnDVnWAJUGo73ItQzaGUk3kZAb4sv3SPsr7l37xfvkfNwdWdLlZlc7ly5rPsBuryWSVQxnRtxf2Z8gXEYqWhc2u88zS+oe0cJ2HDSfB4b2hcz6YdaJznxDn6zUBjeiyjRnk3A0ZU/xVMSKlTQEwkGlsEhpU5pUb+JzqZSzTYINgYkaDR4l1KDWEG0bBMMRBjT7SjbiESXdJTWZ3lxYwIk904EgbiGJEhElN4qTiKJn8M+ldGNWuPSZw51VPlbpjETWpTztH11G9LChVmOiP5/WbK1nXR6HUp6fSsoBLSwaI/jKYwF5TE8M0x2Kf7Z4tGcpYsmfrDBDq5m5jTk3e2FJy6ssm5tKYOM1sOGkMDtBZaY1gZm4ALOgOuserS4C2uM8lC0OHXLb7x+NbRrdspMO7qGS1Hd3a0V1pWt7esb1/TdRrpZb1a473HWYdp1MTdOIM0Rs3c8Yym2QqK29OSfbHmFpn9suaIGNtBc0+JDXMOtno+WuJUasTfNb9clPZJluo55tSqY6H80vkarGogW+LS4PQ8eQG6xYGrntn30C7wuBkx4RL47LrneZ6zJHKsgas2sFjqYBmklsB7F1jnDlYfryPSn1qlJYdSEZoUMso3aiDhosMHFdN542n9kPRNhsZ5fLQgI4Md6dFguoOxmGCJjDNeGpNM5QVMnJNZmhRBwqBm5TEns1TRmY1R9Qsx0oyJm5NAlAxc+luzLEeCDVgzYkwkmpEgA0EGYlSftJg4rjBGwijIGBnTX0lAFlNm5jiBSQKu6W9q7ARqORqFTcVPL1rnSBo2xUzM7T9FRk8ToEnfMHNLJI7LBLNlnFFyStvdttBJTZ+86mDZYbg4NQPUXCbXP1sKav31HSYuy0BjDJ0xrKzBO0NrwXYpantrcWvNkeUbr5Es2lYd4o9a1lda2kue1e0rjm9f0V7xdLe3rK6uJx1X13QY4yBbDCbrUrxaDJaGFqXF4AxGGYxPxxosI2WU5cv9RS5kaeJfaOqdx2raNbec5/g+8FqipfIX2qS49jwvt0y3OHAlqhF+V3ucJdM9z3Pyfer7lv5V3wgq33EfCOa6ZNpXn3pVlE268jPswlavBkuKFmtbrGlw3YqWjpGertmw7nr6Tc+RfZzrrmXTDpy4nlWzod8M9O2GjW3o+4FhGBnGnjFqoKaBMXFEyWnWopmWJegk6UDUw1fHQhBCr2lT1O9nJNiBYEdiHAmhJ9hAMKM6JNvAYCPGRkYTcEbFhkFOCLKBuMFvNkgfCb1yXqGHcCLISUx/NVahpPBJ45g4ryiYmMAngZcrBrErOpXiTOYrZ9iYm1xmvRBzyCMENQJJCn9j566QdVzK/WVeah4E+VPWxmVlFyrrUHdxM3UbM3FXVmWnSGlkYVQI6ZMYsANa62it5cha7NpiGrX6bNYpavvK0xy3NCv1r1oft6zajrZp6I7UvL09bljdtuLyM1uaKw3N1Zbu0grjPNY2TI5g1iDWTIYWY3IgzvqogbYwaZ/TjTBxWabYt5PxRb6mPxU5wyWOiwXnuGorG7pudLtwrqTzLohr2jdP7pozljiqfcBcmqIuRQC5CXpqAFdJ+1YKcHMcVnmvnRzIjmecBTZLH/W8H9osbPn6pY6/tFrKv8uZLMuvXFWu5toMRep1Ne82weBsizUe2zR0ZmB0AyvxrHxHfzJw3fU07oS+Heibnt5cZzMMbPqRk03PGEdGAk5GQkwpS2JMnI1FJOljXDIB96hV3VY7CDYMWHqsDJjYY+IGbEBsIMQRZzWfVshKIyInEonSI6LXjZse6VVUKL0QepIfl/6WXogbNA5g5sKESVxoJVWpCqA7OyYrnDhMNf639V3TesLMJuUzYBtNARPnB0gKd2+Cfhf9WHMdJsl20T+tVnnLy2JWvcrsSZK+uTfMlpAm58rS6Bg+OYM7p3nVvNGAyWtr8F6dhZvOYdd2SjHSXPI0naNZe1aXVrQrT9M1rI7VOrBpPeujjnWKJ7i6bcXqaotbO+yqwXrNJ4c1BNMop2RSgFszpxFR8eBsBRiT6G9M4BMmK8HaclCPz5Hd3Skgm9q6pCdo0p7oInPZPi4rH6utGnfNSbWBxT5jjK3n5QOx+ntxusWBq1gLLjWwqYpdBLxudIVzEfHh0rOWgPCi4FUvl/Pfeulcd8xY3KMst1TH+jlTW5tJZGVwiLWqbHc6QdiVwYmjNwOOBiOO3g1sbMNGDH4Y8H7EGs8gA4OMOBkYgiUksV4MQf2oxKIhpCLRAs4oV2ZkqqMxOVCurqud9FjTY2XESiCHkBATiTZFhte7YuOAZWCQgTiOCkZBiGOyhAwp3uIYpxiAErLhSJzBQWaAMulgbi6buFj9FJIs/opmT+fyNdrsClqm0NNK/i/IxHFhVO9HMhXM1oSzQ7BsCQtk2i/N31XvNosCJd0630OtAmfGRi0Ac8BbbyzOGpy1tIJaBjrLylt8Egn6I487dvjO0RypQ3CzUkfi9SWNzt6sGlbHKQpGBq7jNc2qpb3U0Rw16tPlXeoHhujsBEwBOwW4ndKIJA5pTvaYA+L6rf0xGWqECrhKoJp1X0m8uDS+ynFyHrpRbuqs63YtkOtF7C7gWjq/7/gWaC1ddHG6xYErO6WkJWcepKU4bZ9vxC46T/nMjZS0JEK8CJ0FbksdqQaPLNIrAShfXzr+Lb1jLlNyVEsypFpsmMvUCyhREZZJ1n3OqhnyyqwYm5F107NqrrNJ0Tau+5a+H+n7kceb6wxRQeNENvShJ8TAEAaGQS0Pg4Tk/Jtiv6ccXZJCIOECzonG8JYUsMf0+LDBmx4vAy6MYFVvFlLjRGLyE+sx9NjY4/pBo6v3ClwypnBKg3JeU66rZAQhQkoWuf3RJLeXY4pqDgnYhBRFxGBi8eGmWyTIqb10EzAa1GRf4gwsNgXuzWu7CfxMvuY0g177weYI7QEm1kqTepqpK3iUs/LO4HCTVaBL4NVYS+fAtQ7bOvzaYY9UJNheamiOPU2O2n55TbP2tGvH0aWWZt3SrFpWR2tWa0/TelZdQ7daYxuP7RoNhNukeI4NjGYOatsnMeB2eCY/hWga8agY0E7iwXHipJotc/ia+ypBq+TapIxAnGlJMlKO+X0WzvVCcV+581LJGe3a6vIl7TIsiVX5si8/QbqUWxy4YGqdpQa8EbHgjS4Cljili1xbPn/XvXZ1piXAdMXx0sS+BNxdC58a+HdFqM4Amc85tjvzqUFqMNHr5GZaGtfR+ZZhNbBZbThpO/p+YNMPrNYdQ9gwxIFrcWCIKjrsxw39ODLGoKJE0VxbgUBwgWijig5bcI3gnFVDAFRv1RKmZBTZ+NnFiDWafZgEWhpTYkBkQCQQRk3bIiTwMcrZiRNoZFowiZnbbFpklhwsplBQFe0skKPDn54QDDnx4nS/jDqJFZtA0DLftPwGEfCodWPIVVb/rVwkfz6H6qeigE0GMDoPl3osO0mR7eRrZWicpUnA5Sw0jcN5q9aAa4tfOdzK0VxuaFeOZuVpLne0x00Crpb15ZTg8ajl6LiZOa5La7xvcE7jEJpGuSsNPEzK3G2mdCMa1LadImEMtBPgnBLtUZq+z6lIhmRtWHJk2Zer5LJKy0LJA2zXfJC/Uw1c5Zgr6SIuO0vPWqJdddsFWvuu21X+icOpU/QUAC7Ymr1vnPs838faBRR12YuufMrJreaWbpbKyTH/zoPnLL+KsiPX3Fh5r3K/HozJiiCLm4xxiJXkyGx0InKWxjj6fqQdBnzb0A8NQ+jxsaePDUMc6YNnMw6McWQII4OoHmwkMJohRYCPSCt4q2vpFp2oG4QGSfm1RMFqEvxErJmsGDCoKNEk64bSBB+LApZH4wR2ZpYFem0nKdkWMzeGSe0h2b8p6wanZJBm4r4ySurvij2qOG3J4GWLcZC/WTKBzz5gWAUwI4JN97eyVRzBqAAjMw5Joaa4NaeRUUdhjWzhst7KpRQ03tC0mrjRdZ7mWDmtZuVprjR0a0/TedrLamTRdj7lx1prlPajhvWRBsj1XUOz6rDeY63VyPBJjyUeorNEq1sGmxxLsAapEriWdFg5hWjNmeWyGeqXLArl1ABZGCf7jp01vyz93kX1wogd+0uL4YvOY0sL2639JUS88QnuKQJcC7TEBsPuttrHFl/kI5Yr3JulGrxKQCtBbolqkMpUmrfXnFcsrqnvtaT/Ki0Rqa4tLQnKemTOK6GYN7p6btoGaTuGMTAMI+uTDX2vIsIunLCJgSGODPGEk7HX/TDQJz1Yz8jGeKIZiTYS2kgXe5ootBHaqODVEjVxJIJLTsMOzb1lCJiYDZpHrBlxUb15xNikO0uA1SajidHorN8ArUzpKSYMzA1iyn2ZOaYkm8vRLUyZ7CqDzjQdJnSyqYFN/jh6L7E2M2Dpe5oZEDM7FVFdl0pI52em+pbDBmMI6YbWFB/SWFwSA1pjaZzT3w5ca3Bdg2ucukUcNfhWLQTbSy3tkadde5orLd26oeka2uOO1drTrjzdsWd1+Yima+hWDe2xx3mP9R6cT/orUl6y9F5uO3VIGaapjBtYgtdsAVjrrixlehK1NtzmsGaLT3MKtPZOxbUEonZZqcfQWccuwoktzW/lHLUkMiznn10geG5R49Ik/LQGrguwNmeZktd0I+1aTuwXfU55bdmpS2Ap67Qkbsjl8v12mdPma7KJWCmXXtBVTRTYHni5HqWGv67LJFNaqK8FxGJpwTS4RuhWkfV6xTAOjGHgRE7YjCNDDGzGnk3cJO5r0H1GBhnYuJHAQDAjg+3xQfDB0YzQjWOKRxhwQTUZIgZjAhHDiMEFg7WzvM+IBWsR4zCNWhxKftcGjdLegBlAUvR1MyawCIoCUyT0yDStCTODNrV3Tj8yFm04MqNJ+c1qPWYOyGvNLDLMfSkmfZmQQlalYyMTOJoo0zkzpgclq7icWsSgBhcaGcQUgYsdvtUMw641NCnDsG8Tl3TU4JNpe3epY5WAq728olk1+M5zdNSwWrcKYkctvkuiQOcxqihLIkGmFC6jyYYWZeqQGaxKkWDY4pi2DSlyufmabQvBUkwY02DJPPkc/omkGys/UkFLYJW/u2N7zO2aN3YtUm9kjqoxZMkqsLz3ReaynVTaqO7gSi9AtzhwFT2i7BzVqZ0f/Dxc1hLtAqZ6hXJeKkGq9gdb4mZKgKtXQuV7LUXxWOLgSspAs48zPUv8kO9T17l+l/QeOayQmlfrbO8AYyzOexyeJg6MMrIKDZugYsNNHNhEzyAjAyMbOzAyMJrAYDfYADY6fA/tGHEpbYkbDUY8SJ9M1tURGUZERowkdI6q6xEB64KyUS5ovpFWMKOoHHJAOa9BYFTjCAJTgF0wasiR2shEUWu//K1GMKQUL45ZPmeZsydnsskScTLQUFGZycDlEgdoYDJaSv0pOypLNJig7WzEpIgaJpnNgxGroE2yXkwpZBSwFLS8cxqdvXEJpNRhuD1qaI48rlVji/a4nYBrddzSHXnao4bV8RrXNfjGsTpqaNsW13h847Gt1SDOLjsNM1kJbosDHdm6b/bP8luc0RwYt9RBbccZnB2H3SnObL5XLqedVz/dDFyTiFC2M1tv9fey3y/NVWeB0HnmlF33KO+/NG53jeX6mfvqWc9P5cI2wmyZRHHixugWB6607EwOhlviqX2glWkJgM7qPGcB01nP3HXPJRY7g0ievMr9pYFQ1i+D3673qxc9Gax2cU5U5cv9fYuA+v5lnWuLRZgmUyMWaz0OoaWlNYNqsmRgM7YMEtjEkU3wDKie68Rupv2NazDRYkKL7S3NYLChxYZGgSuotaBERwwjJo5gekQGjAREgjrQisOIw7qAcUmc2IzYGDQNy4iaoAfB9JJ+A8FgYs5GDDHKLLZLOcamPCKpEUzMnA4KJCW4Y8jiRZMD/aV+bloDCbSss+DUJD7He5w4q9TOJoGqSW2dbFGm41accliieitrzMRdWa/hmNqmVd1V4/CrFr+y+Naqrmrd4JIfVneppek8zcqxOm5o1g3N2rNeH+Ea1X+1qwbnWgUrrOoNjZm5WwvijJqwmzks03YerG2wqfVNs1ivBK05GsZs/u5ObbMo0G6BlLavLZ5T9f2l8XLa92CmG1EvlPffNZ/tWmzuoyXG6Kx5rQTgLZWE2RrfMz1tgaug3CnygLYLx8uPWOtmWPgNyyunm7HyWaIaeEod1BKo1SLDJbBcGjxLx8rryjYqn7XrGbto14qu3Pa1fT4v+YTHG49PVgSr1UA0gdGM9HJMMApW1zhhNAOjGTlxPUEuI2GD64+xwxEmnmDH6/o7bLBhQxyvIWGEMMK4wYYBddQaCXFgjAHCiPU5BEXU3ww61UVwMqhfWOyxMSoHMzBxXhJIx0GCYCauTFQcmJMLWpBBZs5oAKItgEvHvfECTeKukvjMePR3a5RTcYCJWFziajMLpw1tRYHJpH2bgMyJGswYDM5qjD/nNIyX+mCpGM+3DU2bwGrV4tcO1znlqFYalqk5algfN/i2wSd/K9+lezUNWKe6zpzSOPcxl7tBBpUyOkUz7W+L97bB5nSXNBMHNosJZ0CbsxbPXFsZl7AEwj0BsZYXcfUCbWmRt+Res0RL4FYvEssyS2N/SRJTU8kAFP6CW/cqj5vquvp9lq6/Cbq1gSvJ9rc4rAxate4Gtj/wEnDlMrtWQeXkXRsdPFFUs+5nKU3LutW/67rt2l/6ncntOF9ztmWdl2gXINZltt7XnHqshhHyGOsw1uN8mwwyAt61jHZgtCOdHQn0SNxghwb6BhNOMOEadtNgwwZCj/QrYhiJMSBDr8dCQMJIDCMS0756HYNEjbwhKlaUqE7MIgGRHheVG7Otcm2Zk5n8vkISJ6aAt2ZgivqBFwWxDFxeMDGDjUxtbTxIo0Blkt+ScWC9AhdOQU1cgQcGkgBWh4xYFQGalKsscVgaUd+kNDDNZPHpvKPxCbicp0tiPt8qx6R6LUeXrABdq9EuuuM2cVaasDFzbMZZMImTMY6YlHOZo5FkvLMdqaI5BSol2JQAtL120nsrd+W2uKwyvmCgNLSo/9aDKQ/EhYFTj89ybqqlDqU0Bc4eQ+eZs2paGmvlXFlyf+XCvCxTglA5D+2a/2pJ0bQILetw4xPnLQ5cC1vZ0GXHgO2VQv0xMtXcTHndrsn+PO1/njK7WPpdosTz0EX6xkXf76xVVH2+BK2lVd8SSOf7CGhOJwGchhayTsM8OU90Ade0jH4kuJHWBgIbRFrMaGFjIXQQG+zGQ9hgxp64aQkplUoYNsRx1Mgco3JhClwBGQcFrhiw8YQoA1YGJA4KajKCDLjYg4xY0ejyJnNWQ5yBKxgkRWw32TquAXpR5+lkQMEQVXwYLVMMphK4PJgGTGMw3mCS7b9JEdDxBmPz+i4Bfo5ykRJrWqshmKyxGJN8sFAw877BO58MMRxtY3HW471n1fpJJ9WtkgFGm7itLkVzbxuaVZvAyoJ3ZG9msclXjMkZYYsDmrvN7F+VDTDma7YjtJc+WaWFX5k/azvq+2n/qzlBZAbS06BV4lJWyy72+XoslHNUObaWJBQ17eLU6nMZhMrz5bOW7CPqLVPJcZV1Lu+x9L677r2r3A3QrQ1cJZViQs/pgLF5yw2eoyvUVFvX5WvqldJ56lPSeT5e2SHqjlp30m+QY99Up4uAMuzmAMtBlK2W9l27C5in42mmiKZYyXms9bReaDtBmkhoB6JtwYwQOsywhthD2ED/OIwbGHvGYUMIIyFEhmFkHAMhRPqgIkITAmEcYRwhDKoLCxuM9BgZMGOPjRusDDjZYMcUEzFF3DAxYCTipcfGACESezRE1Aj0kvYF6ZU7MylYrkTRyO7JmVnzYJqUT4okIjSY1ih4NWBWCmLWp6C1Xg0q1ITdJQAzNH4GJO+cOhFb5bi8VVBrmpbWNljrsN7ReE/jLY2ztI3H+hbXNKzXDu81rJdpWs2dZdJgLKIBl6AStwAnG1Rsg5Z+9lkXVVv4jVvgNYv1ap+q8pllqhJhG/Bq5+PZGOMmaUmXtWuc132+3F8Cqvy7XqAvLfx2Xb8EMCVgZWvOmhEYq/qWc+zSvXe92w3QrQ9ctcgqD5T8N+kZTl3jOd2gS52pnmjrVdMS57Zv4l/6iCWg5mcuiQrL3/sAZWlldt6OUsuzd3Fh9X1rkequOi6VqwfVvucuiBwMkK0RJRkcKNfQgI3g1/hmrXop6WE8SiLBntDPwHUywjBGxijYEAijaMqTYUDCAGFIeqzr2Dhi4oAdr+Gi6rhc3ODiiYaIij1eTlRsKAGXxYgyYsKoOrBRNIzUkMBrUJw1KXSUCJryPaDOwsYm4AI6BS0azVllfAKvlcG2CljBNxjr1ejBGqxV511n7eTIq6DkcdaqSNB5Wm/w1tJ4p5mtncV7T+s83ivQeWeTpaHFug4xljFxbZnD04iHVjkrY7YARbCUJue1j1T5dUtObLbwq3NjuS1QK6/ZtiIsrQC3z2+LEGcz91z2tJdWupPJvdCc5r62jBQW+vJZwLVL8lL/riU19Ryy3aSn56FyXsv1zX5yJSNQ6q+W3Ftqji1W15XlbsJW4NYGrqXVQblfynDrFchSo+9aidTPXGKFS9qllFy65z6Q2NVB61XN0jW7qAaUfaujXe9fXrvk91GerwfVLnFh/a7lIJc9W+biUpxKE1AdTwSsS6xK1AnbjDhajPcQB4g9wauoL8SIBIMZBRvVSnAYFcDsqMBlQq9GHfFEQSsO2HGFjwNWVITo4/UEbj1NPMHJiI1j4sgGnIx42cCYjDj6iAxopI0EXGTgimaKf2hFEigkkWCHAlVrcZ3VY43Bdg7TWGgsg+0wtsEYp1xXAi7vXEr74TBWjS2sU0BzjafzFu80fFPrlRNz3tNaN+u8TI6iYQkocGXQmW3vhFLUJ1tnso+VnQwuMmDUAFEDT+aE4k7gmjmr0rBi0SqwKH9K7yUzqBnYNog7L+0CiLKv76J9QFX/Lo2o6jG+9PxdXJbsKbNrXjhrTqtBcancBenWBq5MJViVyYpK4Cr9k0ruLF+fG9SxHWXUVr/P+kD1uV3c1z4xZW0BWXbOfaBVmr+fl+taMj5ZAt56wNXPWALXWiRS1n0XtyXFtaWIpdY9Lj275hYj6rgqjrFxBKOCpcZ2WJuEVa1mwBIRGhFOAgwRNgHsKMQYVMQ4qojQhs1kSm9iTxMex4UeJwNeNrj4uAJayL8HXNR0Kg7luFo2tGywMSCDEPsMXAKjWhVKsDBaNJ9XRKO7OwWvBFy04DqHWTGJCvEdwbUE29KbFdgWYxzegzEZqFqMc8pxJSDSsBeO1ntaa2iswTmPt5IivvvpE4QJlGDWG9lpgjfVEr/mfPTTzEFpS+Cau8/cGbZzk53mkHKki23gmu+3HJIJMsdVOipP9xE3iy0lgdYO5Fq0MVga60uc0T4qAamWbtT79Xiq573aUGIJkMp6nwdU6nm3rG+m0lCungNOG3+em25t4MqNsm91APPHzCLD3HjlRL/EFcCcAC5T7gjn/bDl/r4VS/l3l/6qNlcvqTQ/3cVVnTXALkIl2NRGFbXytuSecuihclFx1jPyfv5uOXpHuVDJRg1JP0RMf/O5EcQZRu8JzmETiE3RLExynTKaN8pa6BwIQkwskBUVNbp4HZfAy8UTNNfXSDOe4MP1qZxPIkUrI042eBlxMtLEHo/qxXzoZw4rgBlEOUcMMkT1+Qom5fEyYAy2sbACGrCdwa4t0XlG6wnuiNE2jKbBm0uTqNAZwbrEfVnlsEiWmVZDYoA12BSJNyCpb2gKxRFJ3V4/sksfIWIms/TaXDwDzax72u5sZYilGVi2oeq0oYXd2s+WgqcD3S6JGOeBlgFtDvCVxZWa8kRyn6sXaUtSiH20tOCj+r1rDCwBUg1K5SIx0z4R3Vl1rZ9fqlrKeTM/p7birlML7FuoPm2Bax9YZdrFTsfqmnIlUJavdUyW0x2u5iqWqF5t7ev8S5xJee4i994HWuehJS6nbtNyW2rrUiy71KlLWqr70rlywOatBu4SRGFaMavORf9OEdeZJ9xpIWl06hTjEROxpsGaDh8dLvZJ9Neieb5GmrDCx5WKBelxcaU6Lka8JK4MBS4nG5wMNLHHiMZIJIIZ4xTGUMaooBUMKTy7Glc0BulAvIHGQdsQbMNgWka3xqipIWIugXFgrAYUtj6JG53qysxskp5dS2Ka6WKCbGFbW0QBL9kCb+aYSsOHbau9JeAqgaeMSlFybEvive1zs6HHaZ1WWfOcsoTpftum8Am0JNWjjGxSUr3YMpw/A309BvdJT+aXPD22l8Bg17VnbVR/6+M16JVjPtfhLKAsx2VZ16ctcJUT4nmBK3/8LE4sy1GUySuNGrjyc2vgY+H5JdiVq6J6v67r0j327e87ttQuSx32LKqfXYNW5nJydIhcpuS6Sg/60qhliRvdBbT1oJh8oNgeILmsL64p2lesVTP0WmSb6m7iXJ2yzxirZvjeaKChho1GtpOUSEN6HJpx2UtKWElQ4GKYrmniyWTU0Zpep3ABJ6NOt4JG5IiSEhZ7bM5r5AVaQ7CO0XaMHDGaFmNbhBXReMQ0CEcIDkkBcmPRuLbqgBkQSrgJzPHQZ5jQTc9mbmUW9YXkQ7Vt+Tf7W22nyZxFfiXY7QOubVq+fhu05v3SMTnrvqKcFi9OXEM9QS9xNhTna7pRQFu6dmms7gKjegEZOT1eQ3Wuvi7fv1wcZiqvLcd3+bsE3F1j+SbQ59YGrl20tGrIIiTY/hgZxJY+bHlNPeGW1jWO7Y9G8beWL1Oc32VVU3aSetVTGzPcKO0DyKXn1KAqFGBV7cd8g2JpmKMjpFQgk4iv7NSlCLY2nqkHV35E1kmWlqPloKnLl3rEfP0SWO5YDWsVPAovinzCgArXWoJZTVqXYIZpSoz05PgOQo8wqFBKRjCDTrHCMs8gpWkBRRp6jYY+pJxTQ0qamIPEDnTT3cwEWzMvVE7zGRxm3kRhKOKKa2NqmnyN7mXH4FJvNYvfZv3TUkQLbdPTA6HkivITa91ZfY/MsZXX7zLOKI9vgZWwvb9rMVjunzVB3wjtA6UlsCn7dv0O5TUl6OQxG9hepAOnmrrmmrbXH2dbCC6df9paFeZJMJtr1o5yNzK57+sM9YqrFEfVk995RYFl2X0gsbT/jaClOuwaROUgyLH4pBwted9CtPqeYwKw4tROrrVs07hw2/xNAtuuD7b4C6ddFrK4pzTOWQLJ8v3z/QWiS5NpYssESzSazjJ7J41EPH4CgoCfwsBGPCHxIo0ZGBIManSLGWBKXmMW1Sk3k9PQayqPnH9KM/5mv6hZ90QCqnzfWSNUAqLeO6IRA22CrBLg5s5viRPE5bxX2/H9MkyXhhPbES2WP3pu8qyHckjxYU6bpM9n6nsqQNUcmGYnFtR1QnKWzHqi3wdcZbXr8X6j4LUkFbkoaJXHdr1PLdoP1e8l4CoXz/vmogxgS4u+EuTy/tNWVNilrRYX7QKuJXHUWeLFXRMYLCtJ62eUooZQXFPWaakz1MeeSMA6C9jL4/UgXhSlShooSyMj38SlAeXAJsTJ4LHUbiUwlb+XBrNleUDmvlCCGGx/t/KZtdg2/y0Hs0k6Gatiw7x6t4kPA8GamH77acoe8CkP70jAT1P8SD8BiFZFqv25QjNwmUk8lzP7jgWIZeu4EU/mZmaN1DZwzQA2C97ysdOc2jZwleLAXJ/AbGxRJmvMeqjzzuwZsreBC/ZxXds0iwrL/SjpfksTf93Xyz6yRLtE3WdXbf+5Xf18aeEIy+9Sv1dZrgarJeCr54Dz0JKx1RKIlVKPG6RbG7ieARyn/bLzlL5b+bdnu3O1LBsNXITyhy6t/XYBZwl6pRhric1+IkFqF9UcRt25l4CznszzIJjO7RvxRWPlazxzu5TcUS6+1I41R1a2dz1gQ1W2fIcsqozFPZaUyEsDMQfENTA4vwW+xmbuaDv705yHd6RlSPl5A542WTfm2589S2QfKAUHV4CVmziuzJXlK1SwuR13YnbVnTVBpX1ebW5R3kubu855tQ1cJXhKKn9eynzmLNLL/mH77jH7jumvDH6zuHGrmy5N0vW5/ZWc/9qF/YtQ2d9rqutZDq8lDiyDWg1k+fgSuO0Cx7IOZ1Ep9WrYHr91vc57zx10oSZ+5zvfyUtf+lIuX77MXXfdxQ/8wA/wyCOPbJV5+ctfnuKhzdsb3/jGrTJf+MIXeO1rX8vR0RF33XUXb33rWxnHOn7IOegKcBtwGThiSuy3NZllHVQWK7ZM4XJOGWgs0RILX1O9Kt/VCWJVvjy+a6VUDqCl8nWZfe+RJ+dyK4/DaTCo33HpuQKnX3iJ0g12ve+uS2sOuX6P8vi+NgrVNqIglLecyLE8H6rzAxoIdwP0BjYGTuZNTgzxxBI2jmFs2ISOk9hxIiuus+KEFRu6ndtJKqPbmutpu8bRzk3Pr6f967LiuqzoY0MfGvrY0kvLRtqtZ/W09LRJTzZvczbh+e98vt153bz5Qnx4WoS4zevVsQK3LRFn4evpdCOnN19dk8STYohiUpZps8xd7RKTFd12Z9+vz+/iaHaN//o59bGla+o5ZqleS3PQvut3ldn3PmV9c8zNDlijc/JR2l8xS8jaYrtBuhDH9eEPf5iHHnqIl770pYzjyE//9E/z4IMP8pnPfIbj4+Op3Otf/3p+4Rd+Yfp9dHQ07YcQeO1rX8s999zD7//+7/PFL36RH/uxH6NpGv7xP/7HF6v9JRS0xmobijKGGaDyqqbmcuqOuiRS3AcMUpVZWolRndtHu8Ax/13iApauq0VfS+IMKY6d5z1PDZBdo2LXCyQ2U2DKOcU5Lt+1Gi1BtuYgM0dbcl+G0yKWJa43V3Vpcsn3KQF0C1SNBpFNoutghegsjtlAIRpLYCRitkSFbD1qrlQ2Jc9GBuWEPeAJohP3KC5FfLBz/VM9jYkT5xUxBOPSHSzZYCPzVyWk7CJJ9ckAlbmsyWKv2JfpfZb1VKUYNL9ntvirhaa7yFB28lzHpMPSm88VP2udtW+81eN86dpdC+KlMbrvPnXfWxon5wWnfcN0H1jGhTIllRKLFOiZNXMbRE4bgghMAoEboAsB12//9m9v/X73u9/NXXfdxcc+9jFe9rKXTcePjo645557Fu/xH//jf+Qzn/kMH/jAB7j77rv5S3/pL/GP/tE/4m1vexs/93M/R9teAIbvQLmugbQCBh5n/liBbTnqEjdRDu663Fms7C6gWBIH5vOx2M/Xn8X1lfXYNciW3uGilMG9ju1Yg1W5Altctp2DygGRJ/+zgCu33y7uq7xvDVz1pFXqwEor0X31XKpbrTsr3ydz9Q5C4wiNwzhBxWvKk4xJD5b1T3GapIsJfBJzbfsdZU5koJmSQW5xjGVdPQqm1hC9ZXC+EO5lyImTViq79WYN0RLlupXApdVwlKGUTkes2Nbl5feem3jWtAHn7lYCLIaxKK89SxJSj7V9zy3Hdrkozufg9DiMC8d2jdWlvlePkVois8QN1gC2JMU5i86aCy0KWKu0XWbbKbmUaJSSlhukm9JxffWrXwXgjjvu2Dr+y7/8y/ybf/NvuOeee/i+7/s+fuZnfmbiuh5++GFe9KIXcffdd0/lX/WqV/GmN72JT3/603znd37nqedsNhs2m830+2tf+xoA5ihi1lEdMXOHzUn5cnSFkmqrwxpEllYwS7Tr/BKQlaAl1bml4/ueVz9jaQDUA2mp7Dmx5dTztwbAWaOkfHA9c4BaGrr5dKyKnl48z7db4hzLupaPyhxW+Y3z85YAc6mdas6rfr26bnmbgMtMYCkehqYhWstofLK5C9PUXgJXOelP4rQk8pqs4oJJoGW2zZrLySmDd86cHLVewVqiM+qcbCyObCmoIBYTJ7bczDP0jBNoZUfg5FgsbgKimgyiOsGqOZHcvRKnVLf9rr5r6o+xWOn571nc174xvmuc71rI1uV2/V6qb67nkni9NuFfMoHfN0T39et9YsS67vXxUj1TWvhmvXJeGJeSsQvSDQNXjJGf+Imf4Hu/93t54QtfOB3/0R/9UZ797Gdz33338clPfpK3ve1tPPLII/zGb/wGAI8++ugWaAHT70cffXTxWe985zv5+Z//+VPHbROxjRCMUSQvoxjvmvRgeYLa1WnP24GXJtpyFbYEJKYqU15X32fpmefp+OflvOqJYVcbRJhDBezq2fuQsUSoPEuZ3e1ff7PzvNMSQO0SB5fX5OP1wmbX4IXTr1oCVzlB5PtFQzQOHERriSYbnksqYlOzmMlsGwxBksisnMxr/cOSPw5FXWx1Lt0/uPxaCYyMSTydmY7WVJqYlylBNM5f4R+1oytIcomQ7ZvOf8s2Pw8XdJ6xUC9qlp5Vl6+ftYsrXwKppW9w1lhfqnMNREvAs9Rmu8oslT/P+V31XRKpw7ZEw1XH4clxQH7ooYf41Kc+xUc+8pGt4294wxum/Re96EXce++9vOIVr+Bzn/scz3ve827oWW9/+9v5qZ/6qen31772Nb7t275NrbPMSGxaxIuubKf8P8UNcocp9RylCKlW2i91jLyfV+m1xdrSfvms+vxFOIfy2C7g2rWSW+LClgZP2TGXVl71JLl1sLyobLjca031O5c3IPb0QKm5I2GbMyrFhVTHM+WFDGzrtEpArO8P26K/JZAq71XfM//Or5ljJbqiPl7vERtNghmyVWJuuvw3FPuliLasQ32+nqzy++S+X+p68zsHrVN0jugsAcGLZkYe2eb7ato2ptjmDiduafuCs2nfRMrCXzgbtMrn5+tK4KrPLT2z7gdn0b554KyxXz5n6dsucV31+Rr0y3Yt+9ESwNXXsHCuJF/cqxZXl+PKsD2+vtkc15vf/Gbe97738Xu/93t867d+696y999/PwCf/exned7znsc999zDf/7P/3mrzJ/8yZ8A7NSLdV1H13WnjrvkchmxjNYhzuzWF9UNnlefdVinpU66NLGXxh5U5c+iejVWT8y7qD5X/zYLx8tnnZdjyffYWZclZGfhd9lYZuEYu9u8Lrp0vrjN4r2WRHpS/S45o320a0W+S9xS6s3KrZxoRrbNhusJp27mGpSW+uxSPesxkYGv1A2muok3jNaTjTjMJC6sIw1SANV2yKVF2tefao5qH6js+n0e++j6G9fPLe990bG4ROflrHaNx3112QXqSyC/JC2o+28ut0RLHFX5u3T6Ly1y84KsjJBTIs5NWBVeyBxeRHjzm9/Me97zHj74wQ/ynOc858xrPvGJTwBw7733AvDAAw/wR3/0R3zpS1+ayrz//e/nypUrvOAFL7hIdSa7KkvUYKmldddU6R3b0iRRf9xdHeq84rez6KKruIvSPnHpRa5b4tIuRDf5oru+IZweiPu286zmLzKB7ZoEyv61i6uvLWFrq9jSVL88Vm9Lpsr7JrRd9YugpuIGiRYRm6z65vQhs5GFbmfN7XslEXUblvU8i8zCdhbt64LfiLH3zaaz5qxddF7ub9cz9/anql6l7iurdW6QLsRxPfTQQ/zKr/wK733ve7l8+fKkk7rttttYr9d87nOf41d+5Vf4a3/tr/GMZzyDT37yk/zkT/4kL3vZy3jxi18MwIMPPsgLXvAC/tbf+lu8613v4tFHH+Uf/sN/yEMPPbTIVe2vfDYIHhmN25ZM1Qv8pdX3PtY6l8ubXTi2a9AsiQf3DWK751yu565z5xVF7qvzktht7/VJxLfFCpWj/6wRUNx8VxsuMWpnTX71N8/iYFv8lWq/3Gqu7KIT2pJoLNcDZk5nrN6l5HqWuCvhtOL9olS2Qz1RxaocIGgQXycCZm7KJWMNtQosbmAsUn+wJa6oFPmWfbyWSNS/L0r1c/L9ljj5uhzVNXC6T+7r7kvfud6vy5bPKaUkdRssjVFZ+LtLx1u39ZLEJte15oJLKiVX5cKsDHydp4tSlfPN4rh+6Zd+ia9+9au8/OUv59577522X/u1XwOgbVs+8IEP8OCDD/L85z+ft7zlLfzQD/0Qv/mbvzndwznH+973PpxzPPDAA/zNv/k3+bEf+7Etv6/zVz67JSaOa9cEuLQyrmnXam8fONVldoHCLjrvavE8ddhXtxuhGrAvdNETTEvfpeZw9pV9op65r+zSKn4fJ1YaUuzal+LY0gLsPLTvmnNwodt5rLZJu4cWnrNgzcLDC3FEux5wQ/3wBp6z69n1/lnXfSPoyXz2RWipj5cLkhq8buKbXojjkjMSz3zbt30bH/7wh8+8z7Of/Wx+67d+6yKPXqS5X8npg2fReSem8wLLjZ4/7/131XcXSNWr6n3XPWGikptdGt8A1ZzSn8UBDcvizaUy9f55rrtZ2gX8U3vuBi4tIhO4TftLq//6/rtuuPTIpW/7RLRH/cx9+xftZ+fti7sWu7eiCPOsvnrWYuCcdEvGKswAeu1rjxExbOi53g+MmwYeA74OnKBOyRr39PSqOHfGpRXvLnltvq7e9q0c9nFhF/l4S6v6+vql+9ZiyLOemcVStZXQ1r6gJvFZyVKysUtL/NxI+cFZhqBJDrFmdtgtV2blqmxXO5bl699ZKeyrMpbl1V/tyLzUNvVrlmK8+rXr+7piy6ldyhiaSyLrUO3fCOV3zs+q37k85rbPGxOxJmc8Pm1+MQ+tOVPxpA+TygAHttt1QUS5F9SXuNrz0FnP2bd/MwuIur/uEhXuGo9LouNd4uRd+qWyv+a6n2VVKMU19X55n3JOzPqqrHsF1cu26W+ZqTz1uZPH1B/3LIZoiW5J4HrssccA+P++7bue5Joc6EAHOtCBboYee+wxbrvttgtdY+RG4O5JphgjjzzyCC94wQv4X//rf3HlypUnu0p/5ij7uh3aZ5kO7bOfDu1zNh3aaD+d1T4iwmOPPcZ9992HtRdTeN2SHJe1lm/5lm8B4MqVK4dOs4cO7bOfDu2znw7tczYd2mg/7Wufi3Jamb6RtjoHOtCBDnSgAz3hdACuAx3oQAc60C1FtyxwdV3HO97xjgs7LT9d6NA+++nQPvvp0D5n06GN9tM3sn1uSeOMAx3oQAc60NOXblmO60AHOtCBDvT0pANwHehABzrQgW4pOgDXgQ50oAMd6JaiA3Ad6EAHOtCBbim6JYHrF3/xF/lzf+7PsVqtuP/++08lpny60M/93M9hjNnanv/850/nT05OeOihh3jGM57BpUuX+KEf+qEpaedTlX7v936P7/u+7+O+++7DGMO///f/fuu8iPCzP/uz3HvvvazXa175ylfyx3/8x1tl/vRP/5TXve51XLlyhatXr/J3/+7f5etf//o38S2+cXRW+/ztv/23T/WpV7/61Vtlnqrt8853vpOXvvSlXL58mbvuuosf+IEf4JFHHtkqc54x9YUvfIHXvva1HB0dcdddd/HWt76VcRx5KtB52ujlL3/5qT70xje+cavMzbbRLQdcv/Zrv8ZP/dRP8Y53vIP/+l//Ky95yUt41atetZWY8ulEf/Ev/kW++MUvTttHPvKR6dxP/uRP8pu/+Zv8+q//Oh/+8If5v//3//KDP/iDT2Jtv/H0+OOP85KXvIRf/MVfXDz/rne9i3/+z/85//Jf/ks++tGPcnx8zKte9SpOTk6mMq973ev49Kc/zfvf//4p0/cb3vCGb9YrfEPprPYBePWrX73Vp371V3916/xTtX0+/OEP89BDD/EHf/AHvP/972cYBh588EEef/zxqcxZYyqEwGtf+1r6vuf3f//3+df/+l/z7ne/m5/92Z99Ml7pCafztBHA61//+q0+9K53vWs694S0kdxi9D3f8z3y0EMPTb9DCHLffffJO9/5ziexVk8OveMd75CXvOQli+e+8pWvSNM08uu//uvTsf/23/6bAPLwww9/k2r45BIg73nPe6bfMUa555575J/+0386HfvKV74iXdfJr/7qr4qIyGc+8xkB5L/8l/8ylfkP/+E/iDFG/s//+T/ftLp/M6huHxGRH//xH5fv//7v33nN06l9vvSlLwkgH/7wh0XkfGPqt37rt8RaK48++uhU5pd+6ZfkypUrstlsvrkv8E2guo1ERP7qX/2r8vf//t/fec0T0Ua3FMfV9z0f+9jHeOUrXzkds9byyle+kocffvhJrNmTR3/8x3/Mfffdx3Of+1xe97rX8YUvfAGAj33sYwzDsNVWz3/+83nWs571tG2rz3/+8zz66KNbbXLbbbdx//33T23y8MMPc/XqVf7yX/7LU5lXvvKVWGv56Ec/+k2v85NBH/rQh7jrrrv4ju/4Dt70pjfx5S9/eTr3dGqfr371qwDccccdwPnG1MMPP8yLXvQi7r777qnMq171Kr72ta/x6U9/+ptY+28O1W2U6Zd/+Ze58847eeELX8jb3/52rl27Np17Itrolgqy+//+3/8jhLD1wgB33303//2///cnqVZPHt1///28+93v5ju+4zv44he/yM///M/zV/7KX+FTn/oUjz76KG3bcvXq1a1r7r77bh599NEnp8JPMuX3Xuo/+dyjjz7KXXfdtXXee88dd9zxtGi3V7/61fzgD/4gz3nOc/jc5z7HT//0T/Oa17yGhx9+GOfc06Z9Yoz8xE/8BN/7vd/LC1/4QoBzjalHH310sX/lc08lWmojgB/90R/l2c9+Nvfddx+f/OQnedvb3sYjjzzCb/zGbwBPTBvdUsB1oG16zWteM+2/+MUv5v777+fZz342/+7f/TvW6/WTWLMD3ar0N/7G35j2X/SiF/HiF7+Y5z3veXzoQx/iFa94xZNYs28uPfTQQ3zqU5/a0hkfaJt2tVGp73zRi17Evffeyyte8Qo+97nP8bznPe8JefYtJSq88847cc6dsuL5kz/5E+65554nqVZ/dujq1av8hb/wF/jsZz/LPffcQ9/3fOUrX9kq83Ruq/ze+/rPPffcc8rQZxxH/vRP//Rp2W7Pfe5zufPOO/nsZz8LPD3a581vfjPve9/7+N3f/V2+9Vu/dTp+njF1zz33LPavfO6pQrvaaInuv/9+gK0+dLNtdEsBV9u2fPd3fze/8zu/Mx2LMfI7v/M7PPDAA09izf5s0Ne//nU+97nPce+99/Ld3/3dNE2z1VaPPPIIX/jCF562bfWc5zyHe+65Z6tNvva1r/HRj350apMHHniAr3zlK3zsYx+bynzwgx8kxjgNwKcT/e///b/58pe/zL333gs8tdtHRHjzm9/Me97zHj74wQ/ynOc8Z+v8ecbUAw88wB/90R9tgfv73/9+rly5wgte8IJvzot8A+msNlqiT3ziEwBbfeim2+gGjUmeNPq3//bfStd18u53v1s+85nPyBve8Aa5evXqloXK04Xe8pa3yIc+9CH5/Oc/L//pP/0neeUrXyl33nmnfOlLXxIRkTe+8Y3yrGc9Sz74wQ/KH/7hH8oDDzwgDzzwwJNc628sPfbYY/Lxj39cPv7xjwsg/+yf/TP5+Mc/Lv/zf/5PERH5J//kn8jVq1flve99r3zyk5+U7//+75fnPOc5cv369eker371q+U7v/M75aMf/ah85CMfkW//9m+XH/mRH3myXukJpX3t89hjj8k/+Af/QB5++GH5/Oc/Lx/4wAfku77ru+Tbv/3b5eTkZLrHU7V93vSmN8ltt90mH/rQh+SLX/zitF27dm0qc9aYGsdRXvjCF8qDDz4on/jEJ+S3f/u35ZnPfKa8/e1vfzJe6Qmns9ros5/9rPzCL/yC/OEf/qF8/vOfl/e+973y3Oc+V172spdN93gi2uiWAy4RkX/xL/6FPOtZz5K2beV7vud75A/+4A+e7Co9KfTDP/zDcu+990rbtvIt3/It8sM//MPy2c9+djp//fp1+Xt/7+/J7bffLkdHR/LX//pfly9+8YtPYo2/8fS7v/u7ApzafvzHf1xE1CT+Z37mZ+Tuu++WruvkFa94hTzyyCNb9/jyl78sP/IjPyKXLl2SK1euyN/5O39HHnvssSfhbZ542tc+165dkwcffFCe+cxnStM08uxnP1te//rXn1oUPlXbZ6ldAPlX/+pfTWXOM6b+x//4H/Ka17xG1uu13HnnnfKWt7xFhmH4Jr/NN4bOaqMvfOEL8rKXvUzuuOMO6bpO/vyf//Py1re+Vb761a9u3edm2+iQ1uRABzrQgQ50S9EtpeM60IEOdKADHegAXAc60IEOdKBbig7AdaADHehAB7ql6ABcBzrQgQ50oFuKDsB1oAMd6EAHuqXoAFwHOtCBDnSgW4oOwHWgAx3oQAe6pegAXAc60IEOdKBbig7AdaADHehAB7ql6ABcBzrQgQ50oFuKDsB1oAMd6EAHuqXoAFwHOtCBDnSgW4r+/xoKLM+05rzdAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "heat_map = superimpose_anomaly_map(anomaly_map=anomaly_map, image=image, normalize=True)\n", - "plt.imshow(heat_map)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "`predictions` also contains prediction scores and labels.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.6486) tensor(True)\n" - ] - } - ], - "source": [ - "pred_score = predictions[\"pred_scores\"][0]\n", - "pred_labels = predictions[\"pred_labels\"][0]\n", - "print(pred_score, pred_labels)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "The last part of the predictions is the mask that is predicted by the model. This is a boolean mask containing True/False for the abnormal/normal pixels, respectively.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pred_masks = predictions[\"pred_masks\"][0].squeeze().cpu().numpy()\n", - "plt.imshow(pred_masks)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "That wraps it! In this notebook, we show how we could train, test and finally infer a FastFlow model using Anomalib API.\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "anomalib", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "f26beec5b578f06009232863ae217b956681fd13da2e828fa5a0ecf8cf2ccd29" - } - } + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train a Model via API\n", + "\n", + "This notebook demonstrates how to train, test and infer the FastFlow model via Anomalib API. Compared to the CLI entrypoints such as \\`tools/\\.py, the API offers more flexibility such as modifying the existing model or designing custom approaches.\n", + "\n", + "# Installing Anomalib\n", + "\n", + "The easiest way to install anomalib is to use pip. You can install it from the command line using the following command:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install anomalib" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting up the Dataset Directory\n", + "\n", + "This cell is to ensure we change the directory to have access to the datasets.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "# NOTE: Provide the path to the dataset root directory.\n", + "# If the datasets is not downloaded, it will be downloaded\n", + "# to this directory.\n", + "dataset_root = Path.cwd().parent / \"datasets\" / \"MVTec\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Imports\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint\n", + "from matplotlib import pyplot as plt\n", + "from PIL import Image\n", + "from torch.utils.data import DataLoader\n", + "\n", + "from anomalib import TaskType\n", + "from anomalib.data import MVTec, PredictDataset\n", + "from anomalib.engine import Engine\n", + "from anomalib.models import Fastflow\n", + "from anomalib.utils.post_processing import superimpose_anomaly_map" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Data Module\n", + "\n", + "To train the model end-to-end, we do need to have a dataset. In our [previous notebooks](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules), we demonstrate how to initialize benchmark- and custom datasets. In this tutorial, we will use MVTec AD DataModule. We assume that `datasets` directory is created in the `anomalib` root directory and `MVTec` dataset is located in `datasets` directory.\n", + "\n", + "Before creating the dataset, let's define the task type that we will be working on. In this notebook, we will be working on a segmentation task. Therefore the `task` variable would be:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "task = TaskType.SEGMENTATION" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "datamodule = MVTec(\n", + " root=dataset_root,\n", + " category=\"bottle\",\n", + " image_size=256,\n", + " train_batch_size=32,\n", + " eval_batch_size=32,\n", + " num_workers=0,\n", + " task=task,\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## FastFlow Model\n", + "\n", + "Now that we have created the MVTec datamodule, we could create the FastFlow model. We could start with printing its docstring.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mFastflow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbackbone\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'resnet18'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mpre_trained\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mflow_steps\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mSource:\u001b[0m \n", + "\u001b[0;32mclass\u001b[0m \u001b[0mFastflow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mAnomalyModule\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"PL Lightning Module for the FastFlow algorithm.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Args:\u001b[0m\n", + "\u001b[0;34m input_size (tuple[int, int]): Model input size.\u001b[0m\n", + "\u001b[0;34m Defaults to ``(256, 256)``.\u001b[0m\n", + "\u001b[0;34m backbone (str): Backbone CNN network\u001b[0m\n", + "\u001b[0;34m Defaults to ``resnet18``.\u001b[0m\n", + "\u001b[0;34m pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.\u001b[0m\n", + "\u001b[0;34m Defaults to ``True``.\u001b[0m\n", + "\u001b[0;34m flow_steps (int, optional): Flow steps.\u001b[0m\n", + "\u001b[0;34m Defaults to ``8``.\u001b[0m\n", + "\u001b[0;34m conv3x3_only (bool, optinoal): Use only conv3x3 in fast_flow model.\u001b[0m\n", + "\u001b[0;34m Defaults to ``False``.\u001b[0m\n", + "\u001b[0;34m hidden_ratio (float, optional): Ratio to calculate hidden var channels.\u001b[0m\n", + "\u001b[0;34m Defaults to ``1.0`.\u001b[0m\n", + "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbackbone\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"resnet18\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mpre_trained\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mflow_steps\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackbone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbackbone\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_trained\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpre_trained\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflow_steps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflow_steps\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv3x3_only\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhidden_ratio\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFastflowLoss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mFastflowModel\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_setup\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_size\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Fastflow needs input size to build torch model.\"\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFastflowModel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0minput_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbackbone\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackbone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mpre_trained\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_trained\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mflow_steps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflow_steps\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv3x3_only\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhidden_ratio\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtraining_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mSTEP_OUTPUT\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Perform the training step input and return the loss.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Args:\u001b[0m\n", + "\u001b[0;34m batch (batch: dict[str, str | torch.Tensor]): Input batch\u001b[0m\n", + "\u001b[0;34m args: Additional arguments.\u001b[0m\n", + "\u001b[0;34m kwargs: Additional keyword arguments.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Returns:\u001b[0m\n", + "\u001b[0;34m STEP_OUTPUT: Dictionary containing the loss value.\u001b[0m\n", + "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;31m# These variables are not used.\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mhidden_variables\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjacobians\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"image\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhidden_variables\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjacobians\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"train_loss\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mon_epoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprog_bar\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"loss\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mSTEP_OUTPUT\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Perform the validation step and return the anomaly map.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Args:\u001b[0m\n", + "\u001b[0;34m batch (dict[str, str | torch.Tensor]): Input batch\u001b[0m\n", + "\u001b[0;34m args: Additional arguments.\u001b[0m\n", + "\u001b[0;34m kwargs: Additional keyword arguments.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Returns:\u001b[0m\n", + "\u001b[0;34m STEP_OUTPUT | None: batch dictionary containing anomaly-maps.\u001b[0m\n", + "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;31m# These variables are not used.\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0manomaly_maps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"image\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"anomaly_maps\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0manomaly_maps\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtrainer_arguments\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Return FastFlow trainer arguments.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"gradient_clip_val\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"num_sanity_val_steps\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mconfigure_optimizers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOptimizer\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Configure optimizers for each decoder.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Returns:\u001b[0m\n", + "\u001b[0;34m Optimizer: Adam optimizer for each decoder\u001b[0m\n", + "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0moptim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAdam\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mlr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.001\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mweight_decay\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.00001\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlearning_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mLearningType\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Return the learning type of the model.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Returns:\u001b[0m\n", + "\u001b[0;34m LearningType: Learning type of the model.\u001b[0m\n", + "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mLearningType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mONE_CLASS\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFile:\u001b[0m ~/anomalib/src/anomalib/models/image/fastflow/lightning_model.py\n", + "\u001b[0;31mType:\u001b[0m ABCMeta\n", + "\u001b[0;31mSubclasses:\u001b[0m " + ] + } + ], + "source": [ + "Fastflow??" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "model = Fastflow(backbone=\"resnet18\", flow_steps=8)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Callbacks\n", + "\n", + "To train the model properly, we will to add some other \"non-essential\" logic such as saving the weights, early-stopping, normalizing the anomaly scores and visualizing the input/output images. To achieve these we use `Callbacks`. Anomalib has its own callbacks and also supports PyTorch Lightning's native callbacks. So, let's create the list of callbacks we want to execute during the training.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "callbacks = [\n", + " ModelCheckpoint(\n", + " mode=\"max\",\n", + " monitor=\"pixel_AUROC\",\n", + " ),\n", + " EarlyStopping(\n", + " monitor=\"pixel_AUROC\",\n", + " mode=\"max\",\n", + " patience=3,\n", + " ),\n", + "]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Training\n", + "\n", + "Now that we set up the datamodule, model, optimizer and the callbacks, we could now train the model.\n", + "\n", + "The final component to train the model is `Engine` object, which handles train/test/predict pipeline. Let's create the engine object to train the model.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "engine = Engine(\n", + " callbacks=callbacks,\n", + " pixel_metrics=\"AUROC\",\n", + " accelerator=\"auto\", # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n", + " devices=1,\n", + " logger=False,\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "`Trainer` object has number of options that suit all specific needs. For more details, refer to [Lightning Documentation](https://pytorch-lightning.readthedocs.io/en/stable/common/engine.html) to see how it could be tweaked to your needs.\n", + "\n", + "Let's train the model now.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "engine.fit(datamodule=datamodule, model=model)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "The training has finished after 12 epochs. This is because, we set the `EarlyStopping` criteria with a patience of 3, which terminated the training after `pixel_AUROC` stopped improving. If we increased the `patience`, the training would continue further.\n", + "\n", + "## Testing\n", + "\n", + "Now that we trained the model, we could test the model to check the overall performance on the test set. We will also be writing the output of the test images to a file since we set `VisualizerCallback` in `callbacks`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n" + ] }, - "nbformat": 4, - "nbformat_minor": 2 + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4b40cd5a1e094248b521f07ef14291de", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Testing: | | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃ Test metric ┃ DataLoader 0 ┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ image_AUROC │ 1.0 │\n", + "│ image_F1Score │ 1.0 │\n", + "│ pixel_AUROC │ 0.9769068956375122 │\n", + "└───────────────────────────┴───────────────────────────┘\n", + "\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[36m \u001b[0m\u001b[36m image_AUROC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.0 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m image_F1Score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.0 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m pixel_AUROC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9769068956375122 \u001b[0m\u001b[35m \u001b[0m│\n", + "└───────────────────────────┴───────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[{'pixel_AUROC': 0.9769068956375122, 'image_AUROC': 1.0, 'image_F1Score': 1.0}]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "engine.test(datamodule=datamodule, model=model)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Inference\n", + "\n", + "Since we have a trained model, we could infer the model on an individual image or folder of images. Anomalib has an `PredictDataset` to let you create an inference dataset. So let's try it.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "inference_dataset = PredictDataset(path=dataset_root / \"bottle/test/broken_large/000.png\")\n", + "inference_dataloader = DataLoader(dataset=inference_dataset)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "We could utilize `Trainer`'s `predict` method to infer, and get the outputs to visualize\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "predictions = engine.predict(model=model, dataloaders=inference_dataloader)[0]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "`predictions` contain image, anomaly maps, predicted scores, labels and masks. These are all stored in a dictionary. We could check this by printing the `prediction` keys.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image Shape: torch.Size([1, 3, 256, 256]),\n", + "Anomaly Map Shape: {predictions[\"anomaly_maps\"].shape}, \n", + "Predicted Mask Shape: {predictions[\"pred_masks\"].shape}\n" + ] + } + ], + "source": [ + "print(\n", + " f'Image Shape: {predictions[\"image\"].shape},\\n'\n", + " 'Anomaly Map Shape: {predictions[\"anomaly_maps\"].shape}, \\n'\n", + " 'Predicted Mask Shape: {predictions[\"pred_masks\"].shape}',\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Visualization\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "To properly visualize the predictions, we will need to perform some post-processing operations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first show the input image. To do so, we will use `image_path` key from the `predictions` dictionary, and read the image from path. Note that `predictions` dictionary already contains `image`. However, this is the normalized image with pixel values between 0 and 1. We will use the original image to visualize the input image." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "image_path = predictions[\"image_path\"][0]\n", + "image_size = predictions[\"image\"].shape[-2:]\n", + "image = np.array(Image.open(image_path).resize(image_size))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "The first output of the predictions is the anomaly map. As can be seen above, it's also a torch tensor and of size `torch.Size([1, 1, 256, 256])`. We therefore need to convert it to numpy and squeeze the dimensions to make it `256x256` output to visualize.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "anomaly_map = predictions[\"anomaly_maps\"][0]\n", + "anomaly_map = anomaly_map.cpu().numpy().squeeze()\n", + "plt.imshow(anomaly_map)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "We could superimpose (overlay) the anomaly map on top of the original image to get a heat map. Anomalib has a built-in function to achieve this. Let's try it.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "heat_map = superimpose_anomaly_map(anomaly_map=anomaly_map, image=image, normalize=True)\n", + "plt.imshow(heat_map)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "`predictions` also contains prediction scores and labels.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.6486) tensor(True)\n" + ] + } + ], + "source": [ + "pred_score = predictions[\"pred_scores\"][0]\n", + "pred_labels = predictions[\"pred_labels\"][0]\n", + "print(pred_score, pred_labels)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "The last part of the predictions is the mask that is predicted by the model. This is a boolean mask containing True/False for the abnormal/normal pixels, respectively.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pred_masks = predictions[\"pred_masks\"][0].squeeze().cpu().numpy()\n", + "plt.imshow(pred_masks)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "That wraps it! In this notebook, we show how we could train, test and finally infer a FastFlow model using Anomalib API.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "anomalib", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "f26beec5b578f06009232863ae217b956681fd13da2e828fa5a0ecf8cf2ccd29" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 } diff --git a/notebooks/400_openvino/401_nncf.ipynb b/notebooks/400_openvino/401_nncf.ipynb index 6580b86c3a..64af5ae4f5 100644 --- a/notebooks/400_openvino/401_nncf.ipynb +++ b/notebooks/400_openvino/401_nncf.ipynb @@ -1,345 +1,344 @@ { - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setting up the Working Directory\n", - "This cell is to ensure we change the directory to anomalib source code to have access to the datasets and config files. We assume that you already went through `001_getting_started.ipynb` and install the required packages." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "from pathlib import Path\n", - "\n", - "from git.repo import Repo\n", - "\n", - "current_directory = Path.cwd()\n", - "if current_directory.name == \"400_openvino\":\n", - " # On the assumption that, the notebook is located in\n", - " # ~/anomalib/notebooks/400_openvino/\n", - " root_directory = current_directory.parent.parent\n", - "elif current_directory.name == \"anomalib\":\n", - " # This means that the notebook is run from the main anomalib directory.\n", - " root_directory = current_directory\n", - "else:\n", - " # Otherwise, we'll need to clone the anomalib repo to the `current_directory`\n", - " repo = Repo.clone_from(url=\"https://github.com/openvinotoolkit/anomalib.git\", to_path=current_directory)\n", - " root_directory = current_directory / \"anomalib\"\n", - "\n", - "os.chdir(root_directory)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# int-8 Model Quantization via NNCF\n", - "It is possible to use Neural Network Compression Framework ([NNCF](https://github.com/openvinotoolkit/nncf)) with anomalib for inference optimization in [OpenVINO](https://docs.openvino.ai/latest/index.html) with minimal accuracy drop.\n", - "\n", - "This notebook demonstrates how NNCF is enabled in anomalib to optimize the model for inference. Before diving into the details, let's first train a model using the standard Torch training loop.\n", - "\n", - "## 1. Standard Training without NNCF\n", - "To train model without NNCF, we use the standard training loop. We use the same training loop as in the [Getting Started Notebook](https://github.com/openvinotoolkit/anomalib/blob/main/notebooks/000_getting_started/001_getting_started.ipynb)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from anomalib.engine import Engine\n", - "\n", - "from anomalib.config import get_configurable_parameters\n", - "from anomalib.data import get_datamodule\n", - "from anomalib.models import get_model\n", - "from anomalib.utils.callbacks import get_callbacks" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Configuration\n", - "Similar to the [Getting Started Notebook](https://github.com/openvinotoolkit/anomalib/blob/main/notebooks/000_getting_started/001_getting_started.ipynb), we will start with the [PADIM](https://github.com/openvinotoolkit/anomalib/tree/main/anomalib/models/padim) model. We follow the standard training loop, where we first import the config file, with which we import datamodule, model, callbacks and trainer, respectively." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MODEL = \"padim\" # 'padim', 'stfpm'\n", - "CONFIG_PATH = f\"src/anomalib/models/{MODEL}/config.yaml\"\n", - "\n", - "config = get_configurable_parameters(config_path=CONFIG_PATH)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that we will run OpenVINO's `benchmark_app` on the model, which requires the model to be in the ONNX format. Therefore, we set the `export_type` flag to `onnx` in the `optimization` [config file](https://github.com/openvinotoolkit/anomalib/blob/main/anomalib/models/padim/config.yaml#L61). Let's check the current config:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'export_type': None}\n" - ] - } - ], - "source": [ - "print(config[\"optimization\"])" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As mentioned above, we need to explicitly state that we want onnx export mode to be able to run `benchmark_app` to compute the throughput and latency of the model." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "config[\"optimization\"][\"export_type\"] = \"onnx\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "datamodule = get_datamodule(config)\n", - "model = get_model(config)\n", - "callbacks = get_callbacks(config)\n", - "\n", - "# start training\n", - "engine = Engine(**config.trainer, callbacks=callbacks)\n", - "engine.fit(model=model, datamodule=datamodule)\n", - "fp32_results = engine.test(model=model, datamodule=datamodule)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. Training with NNCF\n", - "The above results indicate the performance of the standard fp32 model. We will now use NNCF to optimize the model for inference using int8 quantization. Note, that NNCF and Anomalib integration is still in the experimental stage and currently only Padim and STFPM models are optimized. It is likely that other models would work with NNCF; however, we do not guarantee that the accuracy will not drop significantly.\n", - "\n", - "### 2.1. Padim Model\n", - "To optimize the Padim model for inference, we need to add NNCF configurations to the `optimization` section of the [config file](https://github.com/openvinotoolkit/anomalib/blob/main/anomalib/models/padim/config.yaml#L60). The following configurations are added to the config file:\n", - "\n", - "```yaml\n", - "optimization:\n", - " export_type: null # options: torch, onnx, openvino\n", - " nncf:\n", - " apply: true\n", - " input_info:\n", - " sample_size: [1, 3, 256, 256]\n", - " compression:\n", - " algorithm: quantization\n", - " preset: mixed\n", - " initializer:\n", - " range:\n", - " num_init_samples: 250\n", - " batchnorm_adaptation:\n", - " num_bn_adaptation_samples: 250\n", - "```\n", - "\n", - "After updating the `config.yaml` file, `config` could be reloaded and the model could be trained with NNCF enabled. Alternatively, we could manually add these NNCF settings to the `config` dictionary here. Since we already have the `config` dictionary, we will choose the latter option, and manually add the NNCF configs." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "config[\"optimization\"][\"nncf\"] = {\n", - " \"apply\": True,\n", - " \"input_info\": {\"sample_size\": [1, 3, 256, 256]},\n", - " \"compression\": {\n", - " \"algorithm\": \"quantization\",\n", - " \"preset\": \"mixed\",\n", - " \"initializer\": {\"range\": {\"num_init_samples\": 250}, \"batchnorm_adaptation\": {\"num_bn_adaptation_samples\": 250}},\n", - " },\n", - "}" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that we have updated the config with the NNCF settings, we could train and tests the NNCF model that will be optimized via int8 quantization." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "datamodule = get_datamodule(config)\n", - "model = get_model(config)\n", - "callbacks = get_callbacks(config)\n", - "\n", - "# start training\n", - "engine = Engine(**config.trainer, callbacks=callbacks)\n", - "engine.fit(model=model, datamodule=datamodule)\n", - "int8_results = engine.test(model=model, datamodule=datamodule)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'pixel_F1Score': 0.7241847515106201, 'pixel_AUROC': 0.9831862449645996, 'image_F1Score': 0.9921259880065918, 'image_AUROC': 0.9960317611694336}]\n" - ] - } - ], - "source": [ - "print(fp32_results)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'pixel_F1Score': 0.7164928913116455, 'pixel_AUROC': 0.9731722474098206, 'image_F1Score': 0.9841269850730896, 'image_AUROC': 0.9904761910438538}]\n" - ] - } - ], - "source": [ - "print(int8_results)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As can be seen above, there is a slight performance drop in the accuracy of the model. However, the model is now ready to be optimized for inference. We could now use `benchmark_app` to compute the throughput and latency of the fp32 and int8 models and compare the results." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Check the throughput and latency performance of the fp32 model.\n", - "!benchmark_app -m results/padim/mvtec/bottle/run/onnx/model.onnx -t 10" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Check the throughput and latency performance of the int8 model.\n", - "!benchmark_app -m results/padim/mvtec/bottle/run/compressed/model_nncf.onnx -t 10" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We have observed approximately 30.1% performance improvement in the throughput and latency of the int8 model compared to the fp32 model. This is a significant performance improvement, which could be achieved with 6.94% drop pixel F1-Score.\n", - "\n", - "### 2.2. STFPM Model\n", - "Same steps in 2.1 could be followed to optimize the STFPM model for inference. The only difference is that the `config.yaml` file for STFPM model, located [here](https://github.com/openvinotoolkit/anomalib/blob/main/anomalib/models/stfpm/config.yaml#L67), should be updated with the following:\n", - "\n", - "```yaml\n", - "optimization:\n", - " export_type: null # options: torch, onnx, openvino\n", - " nncf:\n", - " apply: true\n", - " input_info:\n", - " sample_size: [1, 3, 256, 256]\n", - " compression:\n", - " algorithm: quantization\n", - " preset: mixed\n", - " initializer:\n", - " range:\n", - " num_init_samples: 250\n", - " batchnorm_adaptation:\n", - " num_bn_adaptation_samples: 250\n", - " ignored_scopes:\n", - " - \"{re}.*__pow__.*\"\n", - " update_config:\n", - " hyperparameter_search:\n", - " parameters:\n", - " lr:\n", - " min: 1e-4\n", - " max: 1e-2\n", - "```\n", - "This is to ensure that we achieve the best accuracy vs throughput trade-off." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "anomalib", - "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.8.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "ae223df28f60859a2f400fae8b3a1034248e0a469f5599fd9a89c32908ed7a84" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting up the Working Directory\n", + "This cell is to ensure we change the directory to anomalib source code to have access to the datasets and config files. We assume that you already went through `001_getting_started.ipynb` and install the required packages." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from pathlib import Path\n", + "\n", + "from git.repo import Repo\n", + "\n", + "current_directory = Path.cwd()\n", + "if current_directory.name == \"400_openvino\":\n", + " # On the assumption that, the notebook is located in\n", + " # ~/anomalib/notebooks/400_openvino/\n", + " root_directory = current_directory.parent.parent\n", + "elif current_directory.name == \"anomalib\":\n", + " # This means that the notebook is run from the main anomalib directory.\n", + " root_directory = current_directory\n", + "else:\n", + " # Otherwise, we'll need to clone the anomalib repo to the `current_directory`\n", + " repo = Repo.clone_from(url=\"https://github.com/openvinotoolkit/anomalib.git\", to_path=current_directory)\n", + " root_directory = current_directory / \"anomalib\"\n", + "\n", + "os.chdir(root_directory)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# int-8 Model Quantization via NNCF\n", + "It is possible to use Neural Network Compression Framework ([NNCF](https://github.com/openvinotoolkit/nncf)) with anomalib for inference optimization in [OpenVINO](https://docs.openvino.ai/latest/index.html) with minimal accuracy drop.\n", + "\n", + "This notebook demonstrates how NNCF is enabled in anomalib to optimize the model for inference. Before diving into the details, let's first train a model using the standard Torch training loop.\n", + "\n", + "## 1. Standard Training without NNCF\n", + "To train model without NNCF, we use the standard training loop. We use the same training loop as in the [Getting Started Notebook](https://github.com/openvinotoolkit/anomalib/blob/main/notebooks/000_getting_started/001_getting_started.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from anomalib.config import get_configurable_parameters\n", + "from anomalib.data import get_datamodule\n", + "from anomalib.engine import Engine\n", + "from anomalib.models import get_model\n", + "from anomalib.utils.callbacks import get_callbacks" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Configuration\n", + "Similar to the [Getting Started Notebook](https://github.com/openvinotoolkit/anomalib/blob/main/notebooks/000_getting_started/001_getting_started.ipynb), we will start with the [PADIM](https://github.com/openvinotoolkit/anomalib/tree/main/anomalib/models/padim) model. We follow the standard training loop, where we first import the config file, with which we import datamodule, model, callbacks and trainer, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "MODEL = \"padim\" # 'padim', 'stfpm'\n", + "CONFIG_PATH = f\"src/anomalib/models/{MODEL}/config.yaml\"\n", + "\n", + "config = get_configurable_parameters(config_path=CONFIG_PATH)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that we will run OpenVINO's `benchmark_app` on the model, which requires the model to be in the ONNX format. Therefore, we set the `export_type` flag to `onnx` in the `optimization` [config file](https://github.com/openvinotoolkit/anomalib/blob/main/anomalib/models/padim/config.yaml#L61). Let's check the current config:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'export_type': None}\n" + ] + } + ], + "source": [ + "print(config[\"optimization\"])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As mentioned above, we need to explicitly state that we want onnx export mode to be able to run `benchmark_app` to compute the throughput and latency of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "config[\"optimization\"][\"export_type\"] = \"onnx\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "datamodule = get_datamodule(config)\n", + "model = get_model(config)\n", + "callbacks = get_callbacks(config)\n", + "\n", + "# start training\n", + "engine = Engine(**config.trainer, callbacks=callbacks)\n", + "engine.fit(model=model, datamodule=datamodule)\n", + "fp32_results = engine.test(model=model, datamodule=datamodule)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Training with NNCF\n", + "The above results indicate the performance of the standard fp32 model. We will now use NNCF to optimize the model for inference using int8 quantization. Note, that NNCF and Anomalib integration is still in the experimental stage and currently only Padim and STFPM models are optimized. It is likely that other models would work with NNCF; however, we do not guarantee that the accuracy will not drop significantly.\n", + "\n", + "### 2.1. Padim Model\n", + "To optimize the Padim model for inference, we need to add NNCF configurations to the `optimization` section of the [config file](https://github.com/openvinotoolkit/anomalib/blob/main/anomalib/models/padim/config.yaml#L60). The following configurations are added to the config file:\n", + "\n", + "```yaml\n", + "optimization:\n", + " export_type: null # options: torch, onnx, openvino\n", + " nncf:\n", + " apply: true\n", + " input_info:\n", + " sample_size: [1, 3, 256, 256]\n", + " compression:\n", + " algorithm: quantization\n", + " preset: mixed\n", + " initializer:\n", + " range:\n", + " num_init_samples: 250\n", + " batchnorm_adaptation:\n", + " num_bn_adaptation_samples: 250\n", + "```\n", + "\n", + "After updating the `config.yaml` file, `config` could be reloaded and the model could be trained with NNCF enabled. Alternatively, we could manually add these NNCF settings to the `config` dictionary here. Since we already have the `config` dictionary, we will choose the latter option, and manually add the NNCF configs." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "config[\"optimization\"][\"nncf\"] = {\n", + " \"apply\": True,\n", + " \"input_info\": {\"sample_size\": [1, 3, 256, 256]},\n", + " \"compression\": {\n", + " \"algorithm\": \"quantization\",\n", + " \"preset\": \"mixed\",\n", + " \"initializer\": {\"range\": {\"num_init_samples\": 250}, \"batchnorm_adaptation\": {\"num_bn_adaptation_samples\": 250}},\n", + " },\n", + "}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have updated the config with the NNCF settings, we could train and tests the NNCF model that will be optimized via int8 quantization." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "datamodule = get_datamodule(config)\n", + "model = get_model(config)\n", + "callbacks = get_callbacks(config)\n", + "\n", + "# start training\n", + "engine = Engine(**config.trainer, callbacks=callbacks)\n", + "engine.fit(model=model, datamodule=datamodule)\n", + "int8_results = engine.test(model=model, datamodule=datamodule)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{'pixel_F1Score': 0.7241847515106201, 'pixel_AUROC': 0.9831862449645996, 'image_F1Score': 0.9921259880065918, 'image_AUROC': 0.9960317611694336}]\n" + ] + } + ], + "source": [ + "print(fp32_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{'pixel_F1Score': 0.7164928913116455, 'pixel_AUROC': 0.9731722474098206, 'image_F1Score': 0.9841269850730896, 'image_AUROC': 0.9904761910438538}]\n" + ] + } + ], + "source": [ + "print(int8_results)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As can be seen above, there is a slight performance drop in the accuracy of the model. However, the model is now ready to be optimized for inference. We could now use `benchmark_app` to compute the throughput and latency of the fp32 and int8 models and compare the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Check the throughput and latency performance of the fp32 model.\n", + "!benchmark_app -m results/padim/mvtec/bottle/run/onnx/model.onnx -t 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Check the throughput and latency performance of the int8 model.\n", + "!benchmark_app -m results/padim/mvtec/bottle/run/compressed/model_nncf.onnx -t 10" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have observed approximately 30.1% performance improvement in the throughput and latency of the int8 model compared to the fp32 model. This is a significant performance improvement, which could be achieved with 6.94% drop pixel F1-Score.\n", + "\n", + "### 2.2. STFPM Model\n", + "Same steps in 2.1 could be followed to optimize the STFPM model for inference. The only difference is that the `config.yaml` file for STFPM model, located [here](https://github.com/openvinotoolkit/anomalib/blob/main/anomalib/models/stfpm/config.yaml#L67), should be updated with the following:\n", + "\n", + "```yaml\n", + "optimization:\n", + " export_type: null # options: torch, onnx, openvino\n", + " nncf:\n", + " apply: true\n", + " input_info:\n", + " sample_size: [1, 3, 256, 256]\n", + " compression:\n", + " algorithm: quantization\n", + " preset: mixed\n", + " initializer:\n", + " range:\n", + " num_init_samples: 250\n", + " batchnorm_adaptation:\n", + " num_bn_adaptation_samples: 250\n", + " ignored_scopes:\n", + " - \"{re}.*__pow__.*\"\n", + " update_config:\n", + " hyperparameter_search:\n", + " parameters:\n", + " lr:\n", + " min: 1e-4\n", + " max: 1e-2\n", + "```\n", + "This is to ensure that we achieve the best accuracy vs throughput trade-off." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "anomalib", + "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.8.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "ae223df28f60859a2f400fae8b3a1034248e0a469f5599fd9a89c32908ed7a84" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 } diff --git a/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb b/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb index 3022827c8f..ca7b97e67c 100644 --- a/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb +++ b/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb @@ -141,8 +141,8 @@ } ], "source": [ - "from anomalib.data import Folder\n", "from anomalib import TaskType\n", + "from anomalib.data import Folder\n", "\n", "datamodule = Folder(\n", " name=\"cubes\",\n", @@ -646,9 +646,10 @@ } ], "source": [ - "from anomalib.utils.visualization.image import ImageVisualizer, VisualizationMode\n", "from PIL import Image\n", "\n", + "from anomalib.utils.visualization.image import ImageVisualizer, VisualizationMode\n", + "\n", "visualizer = ImageVisualizer(mode=VisualizationMode.FULL, task=TaskType.CLASSIFICATION)\n", "output_image = visualizer.visualize_image(predictions)\n", "Image.fromarray(output_image)" diff --git a/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb b/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb index 546da666e7..236b3ccc56 100644 --- a/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb +++ b/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb @@ -58,18 +58,20 @@ "\n", "# Anomalib imports\n", "from __future__ import annotations\n", - "from typing import TYPE_CHECKING\n", + "\n", "import sys\n", "import time # time library\n", "from datetime import datetime\n", "from pathlib import Path\n", "from threading import Thread\n", + "from typing import TYPE_CHECKING\n", "\n", "if TYPE_CHECKING:\n", " import numpy as np\n", "\n", "# importing required libraries\n", "import cv2 # OpenCV library\n", + "\n", "from anomalib.deploy import OpenVINOInferencer" ] }, diff --git a/notebooks/600_loggers/601_mlflow_logging.ipynb b/notebooks/600_loggers/601_mlflow_logging.ipynb index 24c32b9c34..1d37c03592 100644 --- a/notebooks/600_loggers/601_mlflow_logging.ipynb +++ b/notebooks/600_loggers/601_mlflow_logging.ipynb @@ -129,7 +129,7 @@ "metadata": {}, "outputs": [], "source": [ - "#!mlflow server" + "# !mlflow server" ] }, { @@ -175,15 +175,17 @@ "metadata": {}, "outputs": [], "source": [ - "from anomalib.data import MVTec\n", + "import warnings\n", + "\n", + "from lightning.pytorch.callbacks import EarlyStopping\n", + "\n", "from anomalib import TaskType\n", "from anomalib.callbacks.checkpoint import ModelCheckpoint\n", - "from lightning.pytorch.callbacks import EarlyStopping\n", - "from anomalib.models import Fastflow\n", - "from anomalib.loggers import AnomalibMLFlowLogger\n", + "from anomalib.data import MVTec\n", "from anomalib.engine import Engine\n", + "from anomalib.loggers import AnomalibMLFlowLogger\n", + "from anomalib.models import Fastflow\n", "\n", - "import warnings\n", "warnings.filterwarnings(\"ignore\")" ] }, @@ -1044,7 +1046,7 @@ " pixel_metrics=\"AUROC\",\n", " accelerator=\"auto\",\n", " devices=1,\n", - " logger=mlflow_logger, # Logger is set here\n", + " logger=mlflow_logger, # Logger is set here\n", " **kwargs,\n", ")" ] diff --git a/notebooks/700_metrics/701a_aupimo.ipynb b/notebooks/700_metrics/701a_aupimo.ipynb new file mode 100644 index 0000000000..d780c5a964 --- /dev/null +++ b/notebooks/700_metrics/701a_aupimo.ipynb @@ -0,0 +1,534 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# AUPIMO\n", + "\n", + "Basic usage of the metric AUPIMO (pronounced \"a-u-pee-mo\")." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# What is AUPIMO?\n", + "\n", + "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n", + "\n", + "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n", + "\n", + "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n", + "\n", + "But:\n", + "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n", + "- the FPR (X-axis) considers the (average of) **normal** images only; \n", + "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n", + "\n", + "\\* The score (the area under the curve) is normalized to be in [0, 1].\n", + "\n", + "AUPIMO can be interpreted as\n", + "\n", + "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n", + "\n", + "References in the last cell.\n", + "\n", + "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Install `anomalib` using `pip`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released # noqa: TD003\n", + "%pip install ../.." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Change the directory to have access to the datasets." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "# NOTE: Provide the path to the dataset root directory.\n", + "# If the datasets is not downloaded, it will be downloaded\n", + "# to this directory.\n", + "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.ticker import MaxNLocator, PercentFormatter\n", + "from scipy import stats\n", + "\n", + "from anomalib import TaskType\n", + "from anomalib.data import MVTec\n", + "from anomalib.engine import Engine\n", + "from anomalib.metrics import AUPIMO\n", + "from anomalib.models import Padim" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Module\n", + "\n", + "We will use dataset Leather from MVTec AD. \n", + "\n", + "> See the notebooks below for more details on datamodules. \n", + "> [github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "task = TaskType.SEGMENTATION\n", + "datamodule = MVTec(\n", + " root=dataset_root,\n", + " category=\"leather\",\n", + " image_size=256,\n", + " train_batch_size=32,\n", + " eval_batch_size=32,\n", + " num_workers=8,\n", + " task=task,\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "We will use `PaDiM` (performance is not the best, but it is fast to train).\n", + "\n", + "> See the notebooks below for more details on models. \n", + "> [github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instantiate the model." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "model = Padim(\n", + " # only use one layer to speed it up\n", + " layers=[\"layer1\"],\n", + " n_features=64,\n", + " backbone=\"resnet18\",\n", + " pre_trained=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Average AUPIMO (Basic)\n", + "\n", + "The easiest way to use AUPIMO is via the collection of pixel metrics in the engine.\n", + "\n", + "By default, the average AUPIMO is calculated." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "engine = Engine(\n", + " pixel_metrics=\"AUPIMO\", # others can be added\n", + " accelerator=\"auto\", # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n", + " devices=1,\n", + " logger=False,\n", + ")\n", + "engine.fit(datamodule=datamodule, model=model)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "F1Score class exists for backwards compatibility. It will be removed in v1.1. Please use BinaryF1Score from torchmetrics instead\n", + "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "880e325e4e4842b2b679340ca8007849", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Testing: | | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃ Test metric ┃ DataLoader 0 ┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ image_AUROC │ 0.9887908697128296 │\n", + "│ image_F1Score │ 0.9726775884628296 │\n", + "│ pixel_AUPIMO │ 0.7428419829089654 │\n", + "└───────────────────────────┴───────────────────────────┘\n", + "\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[36m \u001b[0m\u001b[36m image_AUROC \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9887908697128296 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m image_F1Score \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9726775884628296 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m pixel_AUPIMO \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7428419829089654 \u001b[0m\u001b[35m \u001b[0m│\n", + "└───────────────────────────┴───────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[{'pixel_AUPIMO': 0.7428419829089654,\n", + " 'image_AUROC': 0.9887908697128296,\n", + " 'image_F1Score': 0.9726775884628296}]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# will output the AUPIMO score on the test set\n", + "engine.test(datamodule=datamodule, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Individual AUPIMO Scores (Detailed)\n", + "\n", + "AUPIMO assigns one recall score per anomalous image in the dataset.\n", + "\n", + "It is possible to access each of the individual AUPIMO scores and look at the distribution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Collect the predictions and the ground truth." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ckpt_path is not provided. Model weights will not be loaded.\n", + "F1Score class exists for backwards compatibility. It will be removed in v1.1. Please use BinaryF1Score from torchmetrics instead\n", + "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e8116b80da39406e966c2099ecb2fdb1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Predicting: | | 0/? [00:00" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.hist(aupimo_result.aupimos.numpy(), bins=np.linspace(0, 1, 11), edgecolor=\"black\")\n", + "ax.set_ylabel(\"Count (number of images)\")\n", + "ax.yaxis.set_major_locator(MaxNLocator(5, integer=True))\n", + "ax.set_xlim(0, 1)\n", + "ax.set_xlabel(\"AUPIMO [%]\")\n", + "ax.xaxis.set_major_formatter(PercentFormatter(1))\n", + "ax.grid()\n", + "ax.set_title(\"AUPIMO distribution\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cite Us\n", + "\n", + "AUPIMO was developed during [Google Summer of Code 2023 (GSoC 2023)](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd) with the `anomalib` team from Intel's OpenVINO Toolkit.\n", + "\n", + "arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n", + "\n", + "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n", + "\n", + "```bibtex\n", + "@misc{bertoldo2024aupimo,\n", + " author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n", + " title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n", + " year={2024},\n", + " url={https://arxiv.org/abs/2401.01984}, \n", + "}\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "anomalib-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb new file mode 100644 index 0000000000..ea322102f8 --- /dev/null +++ b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb @@ -0,0 +1,1415 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# AUPIMO\n", + "\n", + "Advance use cases of the metric AUPIMO (pronounced \"a-u-pee-mo\").\n", + "\n", + "> For basic usage, please check the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb).\n", + "\n", + "Includes:\n", + "- selection of test representative samples for qualitative analysis\n", + "- visualization of the AUPIMO metric with heatmaps" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# What is AUPIMO?\n", + "\n", + "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n", + "\n", + "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n", + "\n", + "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n", + "\n", + "But:\n", + "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n", + "- the FPR (X-axis) considers the (average of) **normal** images only; \n", + "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n", + "\n", + "\\* The score (the area under the curve) is normalized to be in [0, 1].\n", + "\n", + "AUPIMO can be interpreted as\n", + "\n", + "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n", + "\n", + "References in the last cell.\n", + "\n", + "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Install `anomalib` using `pip`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released # noqa: TD003\n", + "%pip install ../.." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Change the directory to have access to the datasets." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "# NOTE: Provide the path to the dataset root directory.\n", + "# If the datasets is not downloaded, it will be downloaded\n", + "# to this directory.\n", + "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "import matplotlib as mpl\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.ticker import PercentFormatter\n", + "from scipy import stats\n", + "\n", + "from anomalib import TaskType\n", + "from anomalib.data import MVTec\n", + "from anomalib.data.utils import read_image\n", + "from anomalib.engine import Engine\n", + "from anomalib.metrics import AUPIMO\n", + "from anomalib.models import Padim" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "pd.set_option(\"display.float_format\", \"{:.2f}\".format)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basics\n", + "\n", + "This part was covered in the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb), so we'll not discuss it here.\n", + "\n", + "It will train a model and evaluate it using AUPIMO.\n", + "We will use dataset Leather from MVTec AD with `PaDiM` (performance is not the best, but it is fast to train).\n", + "\n", + "> See the notebooks below for more details on:\n", + "> - datamodules: [100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules);\n", + "> - models: [200_models](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# train the model\n", + "task = TaskType.SEGMENTATION\n", + "datamodule = MVTec(\n", + " root=dataset_root,\n", + " category=\"leather\",\n", + " image_size=256,\n", + " train_batch_size=32,\n", + " eval_batch_size=32,\n", + " num_workers=8,\n", + " task=task,\n", + ")\n", + "model = Padim(\n", + " # only use one layer to speed it up\n", + " layers=[\"layer1\"],\n", + " n_features=64,\n", + " backbone=\"resnet18\",\n", + " pre_trained=True,\n", + ")\n", + "engine = Engine(\n", + " pixel_metrics=\"AUPIMO\", # others can be added\n", + " accelerator=\"auto\", # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n", + " devices=1,\n", + " logger=False,\n", + ")\n", + "engine.fit(datamodule=datamodule, model=model)\n", + "# infer\n", + "predictions = engine.predict(dataloaders=datamodule.test_dataloader(), model=model, return_predictions=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compute AUPIMO" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n" + ] + } + ], + "source": [ + "aupimo = AUPIMO(\n", + " # with `False` all the values are returned in a dataclass\n", + " return_average=False,\n", + ")\n", + "\n", + "anomaly_maps = []\n", + "masks = []\n", + "labels = []\n", + "image_paths = []\n", + "for batch in predictions:\n", + " anomaly_maps.append(batch_anomaly_maps := batch[\"anomaly_maps\"].squeeze(dim=1))\n", + " masks.append(batch_masks := batch[\"mask\"])\n", + " labels.append(batch[\"label\"])\n", + " image_paths.append(batch[\"image_path\"])\n", + " aupimo.update(anomaly_maps=batch_anomaly_maps, masks=batch_masks)\n", + "\n", + "# list[list[str]] -> list[str]\n", + "image_paths = [item for sublist in image_paths for item in sublist]\n", + "anomaly_maps = torch.cat(anomaly_maps, dim=0)\n", + "masks = torch.cat(masks, dim=0)\n", + "labels = torch.cat(labels, dim=0)\n", + "\n", + "# `pimo_result` has the PIMO curves of each image\n", + "# `aupimo_result` has the AUPIMO values\n", + "# i.e. their Area Under the Curve (AUC)\n", + "pimo_result, aupimo_result = aupimo.compute()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Statistics and score distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MEAN\n", + "aupimo_result.aupimos[labels == 1].mean().item()=0.742841961578308\n", + "OTHER STATISTICS\n", + "DescribeResult(nobs=92, minmax=(0.0, 1.0), mean=0.742841961578308, variance=0.08757792704451817, skewness=-0.9285678601866055, kurtosis=-0.3299211772047075)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the normal images have `nan` values because\n", + "# recall is not defined for them so we ignore them\n", + "print(f\"MEAN\\n{aupimo_result.aupimos[labels == 1].mean().item()=}\")\n", + "print(f\"OTHER STATISTICS\\n{stats.describe(aupimo_result.aupimos[labels == 1])}\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.hist(aupimo_result.aupimos[labels == 1].numpy(), bins=np.linspace(0, 1, 11), edgecolor=\"black\")\n", + "ax.set_ylabel(\"Count (number of images)\")\n", + "ax.set_xlim(0, 1)\n", + "ax.set_xlabel(\"AUPIMO [%]\")\n", + "ax.xaxis.set_major_formatter(PercentFormatter(1))\n", + "ax.grid()\n", + "ax.set_title(\"AUPIMO distribution\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Until here we just reproduded the notebook with the basic usage of AUPIMO." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Selecting Representative Samples for Qualitative Analysis\n", + "\n", + "Instead of cherry picking or inspecting the 92 samples from above, we'll try to choose them smartly.\n", + "\n", + "Our goal here is to select a handful of samples in a meaningful way.\n", + "\n", + "> Notice that a random selection from the distribution above would probably miss the worst cases.\n", + "\n", + "We will summarize this distribution with a boxplot, then select the samples corresponding to the statistics in it." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(7, 2))\n", + "boxplot_data = ax.boxplot(\n", + " aupimo_result.aupimos[labels == 1].numpy(),\n", + " vert=False,\n", + " widths=0.4,\n", + ")\n", + "_ = ax.set_yticks([])\n", + "ax.set_xlim(0 - (eps := 2e-2), 1 + eps)\n", + "ax.xaxis.set_major_formatter(PercentFormatter(1))\n", + "ax.set_xlabel(\"AUPIMO [%]\")\n", + "ax.set_title(\"AUPIMO Scores Boxplot\")\n", + "num_images = (labels == 1).sum().item()\n", + "ax.annotate(\n", + " text=f\"Number of images: {num_images}\",\n", + " xy=(0.03, 0.95),\n", + " xycoords=\"axes fraction\",\n", + " xytext=(0, 0),\n", + " textcoords=\"offset points\",\n", + " annotation_clip=False,\n", + " verticalalignment=\"top\",\n", + ")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get the values in the boxplot (e.g., whiskers, quartiles, etc.), we're going to use `matplotlib`'s internal function `mpl.cbook.boxplot_stats()`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['mean', 'iqr', 'cilo', 'cihi', 'whishi', 'whislo', 'fliers', 'q1', 'med', 'q3'])\n" + ] + } + ], + "source": [ + "boxplot_data = mpl.cbook.boxplot_stats(aupimo_result.aupimos[labels == 1].numpy())[0]\n", + "print(boxplot_data.keys())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll select 5 of those and find images in the dataset that match them." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " statistic value image_index\n", + "0 whislo 0.00 65\n", + "1 q1 0.53 58\n", + "2 med 0.89 63\n", + "3 q3 1.00 22\n", + "4 whishi 1.00 0\n" + ] + } + ], + "source": [ + "image_selection = []\n", + "\n", + "for key in [\"whislo\", \"q1\", \"med\", \"q3\", \"whishi\"]:\n", + " value = boxplot_data[key]\n", + " # find the image that is closest to the value of the statistic\n", + " # `[labels == 1]` is not used here so that the image's\n", + " # indexes are the same as the ones in the dataset\n", + " # we use `sort()` -- instead of `argmin()` -- so that\n", + " # the `nan`s are not considered (they are at the end)\n", + " closest_image_index = (aupimo_result.aupimos - value).abs().argsort()[0]\n", + " image_selection.append({\"statistic\": key, \"value\": value, \"image_index\": closest_image_index.item()})\n", + "\n", + "image_selection = pd.DataFrame(image_selection)\n", + "print(image_selection)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that they are sorted from the worst to the best AUPIMO score." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualizing the Representative Samples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize what the heatmaps of these samples." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# will be used to normalize the anomaly maps to fit a colormap\n", + "global_vmin, global_vmax = torch.quantile(anomaly_maps, torch.tensor([0.02, 0.98]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(2, 5, figsize=(16, 7), layout=\"constrained\")\n", + "\n", + "for ax_column, (_, row) in zip(axes.T, image_selection.iterrows(), strict=False):\n", + " ax_above, ax_below = ax_column\n", + " image = cv2.resize(read_image(image_paths[row.image_index]), (256, 256))\n", + " anomaly_map = anomaly_maps[row.image_index].numpy()\n", + " mask = masks[row.image_index].squeeze().numpy()\n", + " ax_above.imshow(image)\n", + " ax_above.contour(mask, levels=[0.5], colors=\"magenta\", linewidths=1)\n", + " ax_below.imshow(image)\n", + " ax_below.imshow(anomaly_map, cmap=\"jet\", vmin=global_vmin, vmax=global_vmax, alpha=0.30)\n", + " ax_below.contour(mask, levels=[0.5], colors=\"magenta\", linewidths=1)\n", + " ax_above.set_title(f\"{row.statistic}: {row.value:.0%} AUPIMO image {row.image_index}\")\n", + "\n", + "for ax in axes.flatten():\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "\n", + "axes[0, 0].set_ylabel(\"Image + GT Mask\")\n", + "axes[1, 0].set_ylabel(\"Image + GT Mask + Anomaly Map\")\n", + "fig.text(\n", + " 0.03,\n", + " -0.01,\n", + " \"Magenta: contours of the ground truth (GT) mask. \"\n", + " \"Anomaly maps colored in JET colormap with global (across all images) min-max normalization.\",\n", + " ha=\"left\",\n", + " va=\"top\",\n", + " fontsize=\"small\",\n", + " color=\"dimgray\",\n", + ")\n", + "\n", + "fig.suptitle(\"Anomalous samples from AUPIMO boxplot's statistics\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The heatmaps give the impression that all samples are properly detected, right?\n", + "\n", + "Notice that the lowest AUPIMO (left) is 0, but the heatmap is (contradictorily) showing a good detection.\n", + "\n", + "Why is that?\n", + "\n", + "These heatmaps are colored with a gradient from the minimum to the maximum value in all the heatmaps from the test set.\n", + "\n", + "This is not taking into account the contraints (FPR restriction) in AUPIMO.\n", + "\n", + "Let's compare with the heatmaps from some normal images." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(2, 5, figsize=(16, 7), layout=\"constrained\")\n", + "\n", + "# random selection of normal images\n", + "rng = np.random.default_rng(42)\n", + "normal_images_selection = rng.choice(np.where(labels == 0)[0], size=5, replace=False)\n", + "\n", + "for ax_column, index in zip(axes.T, normal_images_selection, strict=False):\n", + " ax_above, ax_below = ax_column\n", + " image = cv2.resize(read_image(image_paths[index]), (256, 256))\n", + " anomaly_map = anomaly_maps[index].numpy()\n", + " ax_above.imshow(image)\n", + " ax_below.imshow(image)\n", + " ax_below.imshow(anomaly_map, cmap=\"jet\", vmin=global_vmin, vmax=global_vmax, alpha=0.30)\n", + " ax_above.set_title(f\"image {index}\")\n", + "\n", + "for ax in axes.flatten():\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "\n", + "axes[0, 0].set_ylabel(\"Image\")\n", + "axes[1, 0].set_ylabel(\"Image + Anomaly Map\")\n", + "fig.text(\n", + " 0.03,\n", + " -0.01,\n", + " \"Anomaly maps colored in JET colormap with global (across all images) min-max normalization.\",\n", + " ha=\"left\",\n", + " va=\"top\",\n", + " fontsize=\"small\",\n", + " color=\"dimgray\",\n", + ")\n", + "\n", + "fig.suptitle(\"Normal samples (test set)\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the normal images also have high anomaly scores (\"hot\" colors) although there is no anomaly.\n", + "\n", + "As a matter of fact, the heatmaps can barely differentiate between some normal and anomalous images.\n", + "\n", + "See the two heatmaps below for instance." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(7, 4), layout=\"constrained\")\n", + "\n", + "for ax, index in zip(axes.flatten(), [87, 65], strict=False):\n", + " image = cv2.resize(read_image(image_paths[index]), (256, 256))\n", + " anomaly_map = anomaly_maps[index].numpy()\n", + " mask = masks[index].squeeze().numpy()\n", + " ax.imshow(image)\n", + " ax.contour(mask, levels=[0.5], colors=\"magenta\", linewidths=1)\n", + " ax.imshow(anomaly_map, cmap=\"jet\", vmin=global_vmin, vmax=global_vmax, alpha=0.30)\n", + " ax.set_title(f\"image {index}\")\n", + "\n", + "for ax in axes.flatten():\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "\n", + "axes[0].set_title(f\"{axes[0].get_title()} (normal)\")\n", + "axes[1].set_title(f\"{axes[1].get_title()} (anomalous)\")\n", + "\n", + "fig.text(\n", + " 0.03,\n", + " -0.01,\n", + " \"Magenta: contours of the ground truth (GT) mask.\\n\"\n", + " \"Anomaly maps colored in JET colormap with global (across all images) min-max normalization.\",\n", + " ha=\"left\",\n", + " va=\"top\",\n", + " fontsize=\"small\",\n", + " color=\"dimgray\",\n", + ")\n", + "\n", + "fig.suptitle(\"Normal vs. Anomalous Samples\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One would expect image 65 (anomalous) to a 'hotter' heatmap than image 87 (normal), but it is the opposite.\n", + "\n", + "This shows that the model is not doing a great job." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualizing the AUPIMO on the Heatmaps\n", + "\n", + "We will create another visualization to link the heatmaps to AUPIMO.\n", + "\n", + "Recall that AUPIMO computes this integral (simplified):\n", + "\n", + "$$\n", + " \\int_{\\log(L)}^{\\log(U)} \n", + " \\operatorname{TPR}^{i}\\left( \\operatorname{FRP^{-1}}( z ) \\right)\n", + " \\, \n", + " \\mathrm{d}\\log(z) \n", + "$$\n", + "\n", + "The integration bounds -- $L$[ower] and $U$[pper] -- are FPR values.\n", + "\n", + "> More details about their meaning in the next notebook.\n", + "\n", + "We will leverage these two bounds to create a heatmap that shows them in a gradient like this:\n", + "\n", + "![Visualization of AUPIMO on the heatmaps](./pimo_viz.svg)\n", + "\n", + "If the anomaly score is\n", + "1. too low (below the lowest threshold of AUPIMO) $\\rightarrow$ not shown; \n", + "2. between the bounds $\\rightarrow$ shown in a JET gradient;\n", + "3. too high (above the highest threshold of AUPIMO) $\\rightarrow$ shown in a single color.\n", + "\n", + "> Technical detail: lower/upper bound of FPR correspond to the upper/lower bound of threshold.\n", + "\n", + "> **Why low values are not shown?**\n", + ">\n", + "> Because the values below the lower (threshold) bound would _never_ be seen as \"anomalous\" by the metric.\n", + ">\n", + "> Analogously, high values are shown in red because they are _always_ seen as \"anomalous\" by the metric." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FPR bounds\n", + "Lower bound: 0.00001\n", + "Upper bound: 0.00010\n", + "Thresholds corresponding to the FPR bounds\n", + "Lower threshold: 0.504\n", + "Upper threshold: 0.553\n" + ] + } + ], + "source": [ + "# the fpr bounds are fixed in advance in the metric object\n", + "print(f\"\"\"FPR bounds\n", + "Lower bound: {aupimo.fpr_bounds[0]:.5f}\n", + "Upper bound: {aupimo.fpr_bounds[1]:.5f}\"\"\")\n", + "\n", + "# their corresponding thresholds depend on the model's behavior\n", + "# so they only show in the result object\n", + "print(f\"\"\"Thresholds corresponding to the FPR bounds\n", + "Lower threshold: {aupimo_result.thresh_lower_bound:.3g}\n", + "Upper threshold: {aupimo_result.thresh_upper_bound:.3g}\"\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# we re-sample other normal images\n", + "# the FPR bounds are so strict that the heatmaps in the normal images\n", + "# become almost invisible with this colormap\n", + "max_anom_score_per_image = anomaly_maps.max(dim=2).values.max(dim=1).values # noqa: PD011\n", + "normal_images_with_highest_max_score = sorted(\n", + " zip(max_anom_score_per_image[labels == 0], torch.where(labels == 0)[0], strict=False),\n", + " reverse=True,\n", + " key=lambda x: x[0],\n", + ")\n", + "normal_images_with_highest_max_score = [idx.item() for _, idx in normal_images_with_highest_max_score[:5]]\n", + "\n", + "fig, axes = plt.subplots(2, 5, figsize=(16, 7), layout=\"constrained\")\n", + "\n", + "for ax, (_, row) in zip(axes[0], image_selection.iterrows(), strict=False):\n", + " image = cv2.resize(read_image(image_paths[row.image_index]), (256, 256))\n", + " anomaly_map = anomaly_maps[row.image_index].numpy()\n", + " mask = masks[row.image_index].squeeze().numpy()\n", + " ax.imshow(image)\n", + " #\n", + " # where the magic happens!\n", + " #\n", + " ax.imshow(\n", + " # anything below the lower threshold is set to `nan` so it's not shown\n", + " # because such values would never be detected as anomalies with AUPIMO's contraints\n", + " np.where(anomaly_map < aupimo_result.thresh_lower_bound, np.nan, anomaly_map),\n", + " cmap=\"jet\",\n", + " alpha=0.50,\n", + " # notice that vmin/vmax changed here to use the thresholds from the result object\n", + " vmin=aupimo_result.thresh_lower_bound,\n", + " vmax=aupimo_result.thresh_upper_bound,\n", + " )\n", + " ax.contour(anomaly_map, levels=[aupimo_result.thresh_lower_bound], colors=[\"blue\"], linewidths=1)\n", + " ax.contour(mask, levels=[0.5], colors=\"magenta\", linewidths=1)\n", + " ax.set_title(f\"{row.statistic}: {row.value:.0%}AUPIMO image {row.image_index}\")\n", + "\n", + "for ax, index in zip(axes[1], normal_images_with_highest_max_score, strict=False):\n", + " image = cv2.resize(read_image(image_paths[index]), (256, 256))\n", + " anomaly_map = anomaly_maps[index].numpy()\n", + " mask = masks[index].squeeze().numpy()\n", + " ax.imshow(image)\n", + " ax.imshow(\n", + " np.where(anomaly_map < aupimo_result.thresh_lower_bound, np.nan, anomaly_map),\n", + " cmap=\"jet\",\n", + " alpha=0.30,\n", + " vmin=aupimo_result.thresh_lower_bound,\n", + " vmax=aupimo_result.thresh_upper_bound,\n", + " )\n", + " ax.contour(anomaly_map, levels=[aupimo_result.thresh_lower_bound], colors=[\"blue\"], linewidths=1)\n", + " ax.set_title(f\"image {index}\")\n", + "\n", + "for ax in axes.flatten():\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "\n", + "axes[0, 0].set_ylabel(\"Anomalous\")\n", + "axes[1, 0].set_ylabel(\"Normal\")\n", + "fig.text(\n", + " 0.03,\n", + " -0.01,\n", + " \"Magenta: contours of the ground truth (GT) mask. \"\n", + " \"Anomaly maps colored in JET colormap between the thresholds in AUPIMO's integral. \"\n", + " \"Lower values are transparent, higher values are red.\",\n", + " ha=\"left\",\n", + " va=\"top\",\n", + " fontsize=\"small\",\n", + " color=\"dimgray\",\n", + ")\n", + "\n", + "fig.suptitle(\"Visualization linked to AUPIMO's bounds\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now the AUPIMO scores make sense with what you see in the heatmaps.\n", + "\n", + "The samples on the left and right are special cases: \n", + "- left (0% AUPIMO): nothing is seen because the model completely misses the anomaly\\*;\n", + "- right (100% AUPIMO): is practically red only because the detected the anomaly very well. \n", + "\n", + "\\* Because the scores in image 65 are as low as those in normal images." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cite Us\n", + "\n", + "AUPIMO was developed during [Google Summer of Code 2023 (GSoC 2023)](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd) with the `anomalib` team from Intel's OpenVINO Toolkit.\n", + "\n", + "arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n", + "\n", + "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n", + "\n", + "```bibtex\n", + "@misc{bertoldo2024aupimo,\n", + " author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n", + " title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n", + " year={2024},\n", + " url={https://arxiv.org/abs/2401.01984}, \n", + "}\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Utils\n", + "\n", + "Here we provide some utility functions to reproduce the techniques shown in this notebook.\n", + "\n", + "They are `numpy` compatible and cover edge cases not discussed here (check the examples)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Representative samples from the boxplot's statistics\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy import ndarray\n", + "from torch import Tensor\n", + "\n", + "\n", + "def _validate_tensor_or_ndarray(x: Tensor | ndarray) -> ndarray:\n", + " if not isinstance(x, Tensor | ndarray):\n", + " msg = f\"Expected argument to be a tensor or ndarray, but got {type(x)}.\"\n", + " raise TypeError(msg)\n", + "\n", + " if isinstance(x, Tensor):\n", + " x = x.cpu().numpy()\n", + "\n", + " return x\n", + "\n", + "\n", + "def _validate_values(values: ndarray) -> None:\n", + " if values.ndim != 1:\n", + " msg = f\"Expected argument `values` to be a 1D, but got {values.ndim}D.\"\n", + " raise ValueError(msg)\n", + "\n", + "\n", + "def _validate_labels(labels: ndarray) -> ndarray:\n", + " if labels.ndim != 1:\n", + " msg = f\"Expected argument `labels` to be a 1D, but got {labels.ndim}D.\"\n", + " raise ValueError(msg)\n", + "\n", + " # if torch.is_floating_point(labels):\n", + " if np.issubdtype(labels.dtype, np.floating):\n", + " msg = f\"Expected argument `labels` to be of int or binary types, but got float: {labels.dtype}.\"\n", + " raise TypeError(msg)\n", + "\n", + " # check if it is binary and convert to int\n", + " if np.issubdtype(labels.dtype, np.bool_):\n", + " labels = labels.astype(int)\n", + "\n", + " unique_values = np.unique(labels)\n", + " nor_0_nor_1 = (unique_values != 0) & (unique_values != 1)\n", + " if nor_0_nor_1.any():\n", + " msg = f\"Expected argument `labels` to have 0s and 1s as ground truth labels, but got values {unique_values}.\"\n", + " raise ValueError(msg)\n", + "\n", + " return labels\n", + "\n", + "\n", + "def boxplot_stats(\n", + " values: Tensor | ndarray,\n", + " labels: Tensor | ndarray,\n", + " only_label: int | None = 1,\n", + " flier_policy: str | None = None,\n", + " repeated_policy: str | None = \"avoid\",\n", + ") -> list[dict[str, str | int | float | None]]:\n", + " \"\"\"Compute boxplot statistics of `values` and find the samples that are closest to them.\n", + "\n", + " This function uses `matplotlib.cbook.boxplot_stats`, which is the same function used by `matplotlib.pyplot.boxplot`.\n", + "\n", + " Args:\n", + " values (Tensor | ndarray): Values to compute boxplot statistics from.\n", + " labels (Tensor | ndarray): Labels of the samples (0=normal, 1=anomalous). Must have the same shape as `values`.\n", + " only_label (int | None): If 0 or 1, only use samples of that class. If None, use both. Defaults to 1.\n", + " flier_policy (str | None): What happens with the fliers ('outliers')?\n", + " - None: Do not include fliers.\n", + " - 'high': Include only high fliers.\n", + " - 'low': Include only low fliers.\n", + " - 'both': Include both high and low fliers.\n", + " Defaults to None.\n", + " repeated_policy (str | None): What happens if a sample has already selected [for another statistic]?\n", + " - None: Don't care, repeat the sample.\n", + " - 'avoid': Avoid selecting the same one, go to the next closest.\n", + " Defaults to 'avoid'.\n", + "\n", + " Returns:\n", + " list[dict[str, str | int | float | None]]: List of boxplot statistics.\n", + " Keys:\n", + " - 'statistic' (str): Name of the statistic.\n", + " - 'value' (float): Value of the statistic (same units as `values`).\n", + " - 'nearest' (float): Value of the sample in `values` that is closest to the statistic.\n", + " Some statistics (e.g. 'mean') are not guaranteed to be a value in `values`.\n", + " This value is the actual one when they that is the case.\n", + " - 'index': Index in `values` that has the `nearest` value to the statistic.\n", + " \"\"\"\n", + " # operate on numpy arrays only for simplicity\n", + " values = _validate_tensor_or_ndarray(values) # (N,)\n", + " labels = _validate_tensor_or_ndarray(labels) # (N,)\n", + "\n", + " # validate the arguments\n", + " _validate_values(values)\n", + " labels = _validate_labels(labels)\n", + " if values.shape != labels.shape:\n", + " msg = (\n", + " \"Expected arguments `values` and `labels` to have the same shape, \"\n", + " f\"but got {values.shape=} and {labels.shape=}.\"\n", + " )\n", + " raise ValueError(msg)\n", + " assert only_label in {None, 0, 1}, f\"Invalid argument `only_label`: {only_label}\"\n", + " assert flier_policy in {None, \"high\", \"low\", \"both\"}, f\"Invalid argument `flier_policy`: {flier_policy}\"\n", + " assert repeated_policy in {None, \"avoid\"}, f\"Invalid argument `repeated_policy`: {repeated_policy}\"\n", + "\n", + " if only_label is not None and only_label not in labels:\n", + " msg = f\"Argument {only_label=} but `labels` does not contain this class.\"\n", + " raise ValueError(msg)\n", + "\n", + " # only consider samples of the given label\n", + " # `values` and `labels` now have shape (n,) instead of (N,), where n <= N\n", + " label_filter_mask = (labels == only_label) if only_label is not None else np.ones_like(labels, dtype=bool)\n", + " values = values[label_filter_mask] # (n,)\n", + " labels = labels[label_filter_mask] # (n,)\n", + " indexes = np.nonzero(label_filter_mask)[0] # (n,) values are indices in {0, 1, ..., N-1}\n", + "\n", + " indexes_selected = set() # values in {0, 1, ..., N-1}\n", + "\n", + " def append(records_: dict, statistic_: str, value_: float) -> None:\n", + " indices_sorted_by_distance = np.abs(values - value_).argsort() # (n,)\n", + " candidate = indices_sorted_by_distance[0] # idx that refers to {0, 1, ..., n-1}\n", + "\n", + " nearest = values[candidate]\n", + " index = indexes[candidate] # index has value in {0, 1, ..., N-1}\n", + " label = labels[candidate]\n", + "\n", + " if index in indexes_selected and repeated_policy == \"avoid\":\n", + " for candidate in indices_sorted_by_distance:\n", + " index_of_candidate = indexes[candidate]\n", + " if index_of_candidate in indexes_selected:\n", + " continue\n", + " # if the code reaches here, it means that `index_of_candidate` is not repeated\n", + " # if this is never reached, the first choice will be kept\n", + " nearest = values[candidate]\n", + " label = labels[candidate]\n", + " index = index_of_candidate\n", + " break\n", + "\n", + " indexes_selected.add(index)\n", + "\n", + " records_.append(\n", + " {\n", + " \"statistic\": statistic_,\n", + " \"value\": float(value_),\n", + " \"nearest\": float(nearest),\n", + " \"index\": int(index),\n", + " \"label\": int(label),\n", + " },\n", + " )\n", + "\n", + " # function used in `matplotlib.boxplot`\n", + " boxplot_stats = mpl.cbook.boxplot_stats(values)[0] # [0] is for the only boxplot\n", + "\n", + " records = []\n", + " for stat, val in boxplot_stats.items():\n", + " if stat in {\"iqr\", \"cilo\", \"cihi\"}:\n", + " continue\n", + "\n", + " if stat != \"fliers\":\n", + " append(records, stat, val)\n", + " continue\n", + "\n", + " if flier_policy is None:\n", + " continue\n", + "\n", + " for val_ in val:\n", + " stat_ = \"flierhi\" if val_ > boxplot_stats[\"med\"] else \"flierlo\"\n", + " if flier_policy == \"high\" and stat_ == \"flierlo\":\n", + " continue\n", + " if flier_policy == \"low\" and stat_ == \"flierhi\":\n", + " continue\n", + " # else means that they match or `fliers == \"both\"`\n", + " append(records, stat_, val_)\n", + "\n", + " return sorted(records, key=lambda r: r[\"value\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic Usage" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " statistic value nearest index label\n", + "0 whislo 0.00 0.00 65 1\n", + "1 q1 0.53 0.53 58 1\n", + "2 mean 0.74 0.75 7 1\n", + "3 med 0.89 0.89 63 1\n", + "4 q3 1.00 1.00 22 1\n", + "5 whishi 1.00 1.00 0 1\n" + ] + } + ], + "source": [ + "# basic usage\n", + "boxplot_statistics = boxplot_stats(aupimo_result.aupimos, labels)\n", + "boxplot_statistics = pd.DataFrame.from_records(boxplot_statistics)\n", + "print(boxplot_statistics)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Repeated Statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " statistic value nearest index label\n", + "0 whislo 0.00 0.00 67 1\n", + "1 q1 0.59 0.59 58 1\n", + "2 mean 0.78 0.79 43 1\n", + "3 med 0.98 0.99 9 1\n", + "4 whishi 1.00 1.00 0 1\n", + "5 q3 1.00 1.00 36 1\n" + ] + } + ], + "source": [ + "# repeated values\n", + "# if the distribution is very skewed to one side,\n", + "# some statistics may have the same value\n", + "# e.g. the Q3 and the high whisker\n", + "#\n", + "# let's simulate this situation\n", + "\n", + "# increase all values by 10% and clip to [0, 1]\n", + "mock = torch.clip(aupimo_result.aupimos.clone() * 1.10, 0, 1)\n", + "\n", + "# 'avoid' is the default policy\n", + "# notice how Q3 and the high whisker have the same value, but different indexes\n", + "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, repeated_policy=\"avoid\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " statistic value nearest index label\n", + "0 whislo 0.00 0.00 67 1\n", + "1 q1 0.59 0.59 58 1\n", + "2 mean 0.78 0.79 43 1\n", + "3 med 0.98 0.99 9 1\n", + "4 whishi 1.00 1.00 0 1\n", + "5 q3 1.00 1.00 0 1\n" + ] + } + ], + "source": [ + "# this behavior can be changed to allow repeated values\n", + "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, repeated_policy=None)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fliers" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# fliers\n", + "# if the distribution is very skewed to one side,\n", + "# it is possible that some extreme values are considered\n", + "# are considered as outliers, showing as fliers in the boxplot\n", + "#\n", + "# there are two types of fliers: high and low\n", + "# they are defined as:\n", + "# - high: values > high whisker = Q3 + 1.5 * IQR\n", + "# - low: values < low whisker = Q1 - 1.5 * IQR\n", + "# where IQR = Q3 - Q1\n", + "\n", + "# let's artificially simulate this situation\n", + "# we will create a distortion in the values so that\n", + "# high values (close to 1) become even higher\n", + "# and low values (close to 0) become even lower\n", + "\n", + "\n", + "def distortion(vals: Tensor) -> Tensor:\n", + " \"\"\"Artificial distortion to simulate a skewed distribution.\n", + "\n", + " To visualize it:\n", + " ```\n", + " fig, ax = plt.subplots()\n", + " t = np.linspace(0, 1, 100)\n", + " ax.plot(t, np.clip(distortion(t), 0, 1), label=\"distortion\")\n", + " ax.plot(t, t, label=\"identity\", linestyle=\"--\")\n", + " fig\n", + " ```\n", + " \"\"\"\n", + " return vals + 0.12 * (vals * (1 - vals) * 4)\n", + "\n", + "\n", + "mock = torch.clip(distortion(aupimo_result.aupimos.clone()), 0, 1)\n", + "\n", + "fig, ax = plt.subplots(figsize=(7, 2))\n", + "ax.boxplot(\n", + " mock[labels == 1].numpy(),\n", + " vert=False,\n", + " widths=0.4,\n", + ")\n", + "_ = ax.set_yticks([])\n", + "ax.set_xlim(0 - (eps := 2e-2), 1 + eps)\n", + "ax.xaxis.set_major_formatter(PercentFormatter(1))\n", + "ax.set_xlabel(\"AUPIMO [%]\")\n", + "ax.set_title(\"AUPIMO Scores Boxplot\")\n", + "num_images = (labels == 1).sum().item()\n", + "ax.annotate(\n", + " text=f\"Number of images: {num_images}\",\n", + " xy=(0.03, 0.95),\n", + " xycoords=\"axes fraction\",\n", + " xytext=(0, 0),\n", + " textcoords=\"offset points\",\n", + " annotation_clip=False,\n", + " verticalalignment=\"top\",\n", + ")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " statistic value nearest index label\n", + "0 whislo 0.24 0.24 44 1\n", + "1 q1 0.65 0.65 58 1\n", + "2 mean 0.79 0.78 29 1\n", + "3 med 0.94 0.93 63 1\n", + "4 q3 1.00 1.00 22 1\n", + "5 whishi 1.00 1.00 0 1\n" + ] + } + ], + "source": [ + "# `None` is the default policy, so the fliers are not returned\n", + "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, flier_policy=None)))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "with option 'low'\n", + " statistic value nearest index label\n", + "0 flierlo 0.00 0.00 65 1\n", + "1 flierlo 0.00 0.00 67 1\n", + "2 flierlo 0.01 0.01 71 1\n", + "3 flierlo 0.09 0.09 64 1\n", + "4 whislo 0.24 0.24 44 1\n", + "5 q1 0.65 0.65 58 1\n", + "6 mean 0.79 0.78 29 1\n", + "7 med 0.94 0.93 63 1\n", + "8 q3 1.00 1.00 22 1\n", + "9 whishi 1.00 1.00 0 1\n", + "with option 'both'\n", + " statistic value nearest index label\n", + "0 flierlo 0.00 0.00 65 1\n", + "1 flierlo 0.00 0.00 67 1\n", + "2 flierlo 0.01 0.01 71 1\n", + "3 flierlo 0.09 0.09 64 1\n", + "4 whislo 0.24 0.24 44 1\n", + "5 q1 0.65 0.65 58 1\n", + "6 mean 0.79 0.78 29 1\n", + "7 med 0.94 0.93 63 1\n", + "8 q3 1.00 1.00 22 1\n", + "9 whishi 1.00 1.00 0 1\n" + ] + } + ], + "source": [ + "# one can choose to include only high or low fliers, or both\n", + "# since there are only low fliers...\n", + "\n", + "# 'low' and 'both' will return the same result\n", + "print(\"with option 'low'\")\n", + "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, flier_policy=\"low\")))\n", + "\n", + "print(\"with option 'both'\")\n", + "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, flier_policy=\"both\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "with option 'high'\n", + " statistic value nearest index label\n", + "0 whislo 0.24 0.24 44 1\n", + "1 q1 0.65 0.65 58 1\n", + "2 mean 0.79 0.78 29 1\n", + "3 med 0.94 0.93 63 1\n", + "4 q3 1.00 1.00 22 1\n", + "5 whishi 1.00 1.00 0 1\n" + ] + } + ], + "source": [ + "# and 'high' will return no fliers (same as `flier_policy=None` in this case)\n", + "print(\"with option 'high'\")\n", + "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, flier_policy=\"high\")))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Other applications and `only_label` argument" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "stats for the maximum anomaly score in the anomaly maps\n", + " statistic value nearest index label\n", + "0 whislo 0.46 0.46 65 1\n", + "1 q1 0.63 0.63 48 1\n", + "2 med 0.70 0.71 10 1\n", + "3 mean 0.73 0.73 118 1\n", + "4 q3 0.81 0.81 115 1\n", + "5 whishi 1.00 1.00 22 1\n" + ] + } + ], + "source": [ + "# other applications\n", + "# since the function is agnostic to the meaning of the values\n", + "# we can also use it to find representative samples\n", + "# with another metric or signal\n", + "#\n", + "# in the last plot cell we used the maximum anomaly score per image\n", + "# to select normal images, so let's reuse that criterion here\n", + "\n", + "# recompute it for didactic purposes\n", + "max_anom_score_per_image = anomaly_maps.max(dim=2).values.max(dim=1).values # noqa: PD011\n", + "print(\"stats for the maximum anomaly score in the anomaly maps\")\n", + "print(pd.DataFrame.from_records(boxplot_stats(max_anom_score_per_image, labels)))\n", + "# notice that the indices are not the same as before" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " statistic value nearest index label\n", + "0 whislo 0.42 0.42 90 0\n", + "1 q1 0.43 0.43 80 0\n", + "2 med 0.45 0.45 105 0\n", + "3 mean 0.46 0.46 89 0\n", + "4 q3 0.48 0.48 75 0\n", + "5 whishi 0.52 0.52 95 0\n" + ] + } + ], + "source": [ + "# we can also use the `only_label` argument to select only the\n", + "# samples from the normal class\n", + "print(pd.DataFrame.from_records(boxplot_stats(max_anom_score_per_image, labels, only_label=0)))\n", + "# notice the labels are all 0 now" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " statistic value nearest index label\n", + "0 whislo 0.42 0.42 90 0\n", + "1 q1 0.52 0.52 95 0\n", + "2 med 0.65 0.65 17 1\n", + "3 mean 0.66 0.66 45 1\n", + "4 q3 0.77 0.77 108 1\n", + "5 whishi 1.00 1.00 22 1\n" + ] + } + ], + "source": [ + "# or we can consider data from both classes (`None` option)\n", + "print(pd.DataFrame.from_records(boxplot_stats(max_anom_score_per_image, labels, only_label=None)))\n", + "# notice that the labels are mixed" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cite Us\n", + "\n", + "AUPIMO was developed during [Google Summer of Code 2023 (GSoC 2023)](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd) with the `anomalib` team from Intel's OpenVINO Toolkit.\n", + "\n", + "arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n", + "\n", + "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n", + "\n", + "```bibtex\n", + "@misc{bertoldo2024aupimo,\n", + " author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n", + " title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n", + " year={2024},\n", + " url={https://arxiv.org/abs/2401.01984}, \n", + "}\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "anomalib-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb new file mode 100644 index 0000000000..6911b9c546 --- /dev/null +++ b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb @@ -0,0 +1,927 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# AUPIMO\n", + "\n", + "Advance use cases of the metric AUPIMO (pronounced \"a-u-pee-mo\").\n", + "\n", + "> For basic usage, please check the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb).\n", + "\n", + "Includes:\n", + "- visualization of the PIMO curve\n", + "- theoretical AUPIMO of a random classifier (\"baseline\")\n", + "- understanding the x-axis (FPR) bounds\n", + "- customizing the x-axis (FPR) bounds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# What is AUPIMO?\n", + "\n", + "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n", + "\n", + "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n", + "\n", + "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n", + "\n", + "But:\n", + "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n", + "- the FPR (X-axis) considers the (average of) **normal** images only; \n", + "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n", + "\n", + "\\* The score (the area under the curve) is normalized to be in [0, 1].\n", + "\n", + "AUPIMO can be interpreted as\n", + "\n", + "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n", + "\n", + "References in the last cell.\n", + "\n", + "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Install `anomalib` using `pip`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released # noqa: TD003\n", + "%pip install ../.." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Change the directory to have access to the datasets." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "# NOTE: Provide the path to the dataset root directory.\n", + "# If the datasets is not downloaded, it will be downloaded\n", + "# to this directory.\n", + "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "import numpy as np\n", + "import torch\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.axes import Axes\n", + "from matplotlib.ticker import FixedLocator, PercentFormatter\n", + "from numpy import ndarray\n", + "from scipy import stats\n", + "from torch import Tensor\n", + "\n", + "from anomalib import TaskType\n", + "from anomalib.data import MVTec\n", + "from anomalib.data.utils import read_image\n", + "from anomalib.engine import Engine\n", + "from anomalib.metrics import AUPIMO\n", + "from anomalib.models import Padim" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basics\n", + "\n", + "This part was covered in the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb), so we'll not discuss it here.\n", + "\n", + "It will train a model and evaluate it using AUPIMO.\n", + "We will use dataset Leather from MVTec AD with `PaDiM` (performance is not the best, but it is fast to train).\n", + "\n", + "> See the notebooks below for more details on:\n", + "> - datamodules: [100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules);\n", + "> - models: [200_models](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# train the model\n", + "task = TaskType.SEGMENTATION\n", + "datamodule = MVTec(\n", + " root=dataset_root,\n", + " category=\"leather\",\n", + " image_size=256,\n", + " train_batch_size=32,\n", + " eval_batch_size=32,\n", + " num_workers=8,\n", + " task=task,\n", + ")\n", + "model = Padim(\n", + " # only use one layer to speed it up\n", + " layers=[\"layer1\"],\n", + " n_features=64,\n", + " backbone=\"resnet18\",\n", + " pre_trained=True,\n", + ")\n", + "engine = Engine(\n", + " pixel_metrics=\"AUPIMO\", # others can be added\n", + " accelerator=\"auto\", # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n", + " devices=1,\n", + " logger=False,\n", + ")\n", + "engine.fit(datamodule=datamodule, model=model)\n", + "# infer\n", + "predictions = engine.predict(dataloaders=datamodule.test_dataloader(), model=model, return_predictions=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compute AUPIMO" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n" + ] + } + ], + "source": [ + "aupimo = AUPIMO(\n", + " # with `False` all the values are returned in a dataclass\n", + " return_average=False,\n", + ")\n", + "\n", + "anomaly_maps = []\n", + "masks = []\n", + "labels = []\n", + "image_paths = []\n", + "for batch in predictions:\n", + " anomaly_maps.append(batch_anomaly_maps := batch[\"anomaly_maps\"].squeeze(dim=1))\n", + " masks.append(batch_masks := batch[\"mask\"])\n", + " labels.append(batch[\"label\"])\n", + " image_paths.append(batch[\"image_path\"])\n", + " aupimo.update(anomaly_maps=batch_anomaly_maps, masks=batch_masks)\n", + "\n", + "# list[list[str]] -> list[str]\n", + "image_paths = [item for sublist in image_paths for item in sublist]\n", + "anomaly_maps = torch.cat(anomaly_maps, dim=0)\n", + "masks = torch.cat(masks, dim=0)\n", + "labels = torch.cat(labels, dim=0)\n", + "\n", + "# `pimo_result` has the PIMO curves of each image\n", + "# `aupimo_result` has the AUPIMO values\n", + "# i.e. their Area Under the Curve (AUC)\n", + "pimo_result, aupimo_result = aupimo.compute()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Statistics and score distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MEAN\n", + "aupimo_result.aupimos[labels == 1].mean().item()=0.742841961578308\n", + "OTHER STATISTICS\n", + "DescribeResult(nobs=92, minmax=(0.0, 1.0), mean=0.742841961578308, variance=0.08757792704451818, skewness=-0.9285678601866053, kurtosis=-0.3299211772047079)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the normal images have `nan` values because\n", + "# recall is not defined for them so we ignore them\n", + "print(f\"MEAN\\n{aupimo_result.aupimos[labels == 1].mean().item()=}\")\n", + "print(f\"OTHER STATISTICS\\n{stats.describe(aupimo_result.aupimos[labels == 1])}\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.hist(aupimo_result.aupimos[labels == 1].numpy(), bins=np.linspace(0, 1, 11), edgecolor=\"black\")\n", + "ax.set_ylabel(\"Count (number of images)\")\n", + "ax.set_xlim(0, 1)\n", + "ax.set_xlabel(\"AUPIMO [%]\")\n", + "ax.xaxis.set_major_formatter(PercentFormatter(1))\n", + "ax.grid()\n", + "ax.set_title(\"AUPIMO distribution\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Until here we just reproduded the notebook with the basic usage of AUPIMO." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The PIMO curve \n", + "\n", + "We'll select a bunch of images to visualize the PIMO curves.\n", + "\n", + "To make sure we have best and worst detection examples, we'll use the representative samples selected in the previous notebook ([701b_aupimo_advanced_i.ipynb](./701b_aupimo_advanced_i.ipynb)).\n", + "\n", + "> Note the FPR (X-axis) is the average (in-image) FPR of the normal images in the test set. We'll note it as `FPRn`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# representative samples (in terms of the AUPIMO value)\n", + "# from lowest to highest AUPIMO score\n", + "samples = [65, 7, 58, 63, 22]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def fmt_pow10(value: float) -> str:\n", + " \"\"\"Format the power of 10.\"\"\"\n", + " return \"1\" if value == 1 else f\"$10^{{{int(np.log10(value))}}}$\"\n", + "\n", + "\n", + "def plot_pimo_with_auc_zone(\n", + " ax: Axes,\n", + " tpr: ndarray,\n", + " fpr: ndarray,\n", + " lower_bound: float,\n", + " upper_bound: float,\n", + " fpr_in_auc: ndarray,\n", + " tpr_in_auc: ndarray,\n", + ") -> None:\n", + " \"\"\"Helper function to plot the PIMO curve with the AUC zone.\"\"\"\n", + " # plot\n", + " ax.plot(fpr, tpr, linewidth=3.5)\n", + " ax.axvspan(lower_bound, upper_bound, color=\"magenta\", alpha=0.3, zorder=-1)\n", + " ax.fill_between(fpr_in_auc, tpr_in_auc, alpha=1, color=\"tab:purple\", zorder=1)\n", + "\n", + " # config plots\n", + " ax.set_ylabel(\"TPR [%]\")\n", + " ax.yaxis.set_major_locator(FixedLocator(np.linspace(0, 1, 6)))\n", + " ax.yaxis.set_major_formatter(PercentFormatter(1, 0, symbol=\"\"))\n", + " ax.set_ylim(0, 1 + 3e-2)\n", + " ax.set_xlabel(\"FPRn\")\n", + " ax.set_xscale(\"log\")\n", + " ax.xaxis.set_major_locator(FixedLocator(np.logspace(-6, 0, 7)))\n", + " ax.xaxis.set_major_formatter(lambda x, _: fmt_pow10(x))\n", + " ax.set_xlim(1e-6 / (eps := (1 + 3e-1)), 1 * eps)\n", + " ax.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 3, figsize=(10, 5), layout=\"tight\")\n", + "\n", + "for ax, index in zip(axes.flatten(), samples, strict=False):\n", + " score = aupimo_result.aupimos[index].item()\n", + " tpr = pimo_result.per_image_tprs[index]\n", + " fpr = pimo_result.shared_fpr\n", + " lower_bound, upper_bound = aupimo.fpr_bounds\n", + " threshs_auc_mask = (pimo_result.thresholds > aupimo_result.thresh_lower_bound) & (\n", + " pimo_result.thresholds < aupimo_result.thresh_upper_bound\n", + " )\n", + " fpr_in_auc = fpr[threshs_auc_mask]\n", + " tpr_in_auc = tpr[threshs_auc_mask]\n", + "\n", + " plot_pimo_with_auc_zone(ax, tpr, fpr, lower_bound, upper_bound, fpr_in_auc, tpr_in_auc)\n", + " ax.set_title(f\"Image {index} ({score:.0%} AUPIMO)\")\n", + "\n", + "axes[-1, -1].axis(\"off\")\n", + "axes[-1, -1].text(\n", + " -0.08,\n", + " 0,\n", + " \"\"\"\n", + "FPRn: Avg. [in-image] False Positive Rate (FPR)\n", + " on normal images only ('n').\n", + "\n", + "TPR: [in-image] True Positive Rate (TPR),\n", + " or Recall.\n", + "\n", + "Integration zone in light pink, and area\n", + "under the curve (AUC) in purple.\n", + "\n", + "This area is normalized by the range size\n", + "so that AUPIMO is in [0, 1].\n", + "\"\"\",\n", + " ha=\"left\",\n", + " va=\"bottom\",\n", + " fontsize=\"x-small\",\n", + " color=\"dimgray\",\n", + " font=\"monospace\",\n", + ")\n", + "\n", + "fig.suptitle(\"PIMO curves\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Meaning of the FPRn bounds\n", + "\n", + "AUPIMOo only uses _normal images_ in the X-axis -- i.e. the $\\operatorname{FPRn}$.\n", + "\n", + "**Why?** \n", + "\n", + "Because the integration range is a validation\\* of \"usable operating thresholds\", so using $\\operatorname{FPRn}$ makes it unbiased (to the anomalies).\n", + "\n", + "> Recall that, in practice, a threshold is set to decide if a pixel/image is anomalous.\n", + "> \n", + "> This strategy was inspired on [AUPRO](https://link.springer.com/article/10.1007/s11263-020-01400-4).\n", + "\n", + "---\n", + "\n", + "**Definition 1**: Average FPR on Normal Images ($\\operatorname{FPRn}$):\n", + "\n", + "$$\n", + " \\operatorname{FPRn} : t \\mapsto \\frac{1}{N} \\sum_{i=1}^{N} \\; \\times \\; \\operatorname{FPR}^{i}(t)\n", + "$$\n", + "\n", + "where $i$ and $N$ are, respectively, the index and the number of normal images in the test set. Note that $\\operatorname{FPRn}$ is the empirical average of $\\operatorname{FPR}^{i}$, so \n", + "\n", + "$$\n", + " \\operatorname{FPRn} \\approx \\mathbb{E} \\left[ \\operatorname{FPR}^{i} \\right]\n", + "$$\n", + "\n", + "**Defintion 2**: FPR of the $i$-th normal image ($\\operatorname{FPR}^{i}$): \n", + "\n", + "$$\n", + " \\operatorname{FPR}^{i} : t \\mapsto \\frac{\\text{Area of } \\mathbb{a}^{i} \\text{ above } t}{\\text{Area of } \\mathbb{a}^{i}}\n", + "$$\n", + "\n", + "where $\\mathbb{a}^{i}$ is the anomaly score map of the $i$-th image.\n", + "\n", + "---\n", + "\n", + "No further ado, let's visualize this $\\operatorname{FPRn}$!\n", + "\n", + "> For more details on this topic, check our paper in the last cell." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualizing the FPR of normal images ($\\operatorname{FPR}^{i}$)\n", + "\n", + "$\\operatorname{FPRn}$ is the average of $\\operatorname{FPR}^{i}$, so let's first visualize the latter." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# visalization of $FPR^i$\n", + "# since normal images do not have anomalous pixels\n", + "# their FPR actually correspond to the ratio of pixels\n", + "# (wrongly) classified as anomalous\n", + "\n", + "# we'll visualize 3 levels of FPR^(i) on some normal images\n", + "FRP_levels = [1e-2, 1e-3, 1e-4]\n", + "# technical detail: decreasing order of FPR --> increasing order of threshold\n", + "\n", + "\n", + "def threshold_from_fpr(anomaly_map: Tensor, fpr_level: float | Tensor) -> float:\n", + " \"\"\"Find the threshold that corresponds to the given FPR level.\n", + "\n", + " Args:\n", + " anomaly_map (torch.Tensor): Anomaly map, assumed to be from a normal image.\n", + " fpr_level (float): Desired FPR level.\n", + "\n", + " Returns:\n", + " float: Threshold such that `(anomaly_map > threshold).mean() == fpr_level`.\n", + " \"\"\"\n", + " # make a dicothomic search\n", + " lower, upper = anomaly_map.min(), anomaly_map.max() # initial bounds\n", + " middle = (lower + upper) / 2\n", + " fpr_level = torch.tensor(fpr_level)\n", + "\n", + " def fpr(threshold: Tensor) -> Tensor:\n", + " return (anomaly_map > threshold).float().mean()\n", + "\n", + " while not torch.isclose(fpr(middle), fpr_level, rtol=1e-2):\n", + " if torch.isclose(lower, upper, rtol=1e-3):\n", + " break\n", + " if fpr(middle) < fpr_level:\n", + " upper = middle\n", + " else:\n", + " lower = middle\n", + " middle = (lower + upper) / 2\n", + " return middle.item()\n", + "\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(13, 5), layout=\"constrained\")\n", + "\n", + "# select normal images with low and high mean anomaly scores\n", + "avg_anom_score_per_image = anomaly_maps.mean(dim=(1, 2))\n", + "# get the indices of the normal images sorted by their mean anomaly score\n", + "argsort = avg_anom_score_per_image.sort().indices\n", + "argsort = argsort[torch.isin(argsort, torch.where(labels == 0)[0])]\n", + "# select first, median and last\n", + "normal_images_selection = argsort[[0, len(argsort) // 2, -1]]\n", + "\n", + "# heatmaps will be normalized across *normal* images\n", + "# so the range of thresholds have an exact mapping to the range of [0, 1] in FPRn\n", + "# PS: it is not exactly true because we don't get a min-max, but a quantile-based normalization\n", + "global_normal_vmin, global_normal_vmax = torch.quantile(anomaly_maps[labels == 0], torch.tensor([0.02, 0.98]))\n", + "\n", + "for ax, index in zip(axes, normal_images_selection, strict=False):\n", + " image = cv2.resize(read_image(image_paths[index]), (256, 256))\n", + " anomaly_map = anomaly_maps[index]\n", + " thresholds = [threshold_from_fpr(anomaly_map, fpr_level) for fpr_level in FRP_levels]\n", + " anomaly_map = anomaly_map.numpy()\n", + "\n", + " ax.imshow(image)\n", + " ax.imshow(anomaly_map, cmap=\"jet\", alpha=0.10, vmin=global_normal_vmin, vmax=global_normal_vmax)\n", + " c = ax.contour(anomaly_map, levels=thresholds, linewidths=1, colors=[\"blue\", \"yellow\", \"red\"])\n", + " ax.set_title(f\"image {index}\")\n", + "\n", + "for ax in axes.flatten():\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "\n", + "fig.text(\n", + " 0.03,\n", + " -0.01,\n", + " \"Anomaly maps colored in JET colormap with min-max normalization across all normal images. \"\n", + " \" $\\\\operatorname{FPR}^{i}$ levels: \"\n", + " f\"Blue = {fmt_pow10(FRP_levels[0])} Yellow = {fmt_pow10(FRP_levels[1])} Red = {fmt_pow10(FRP_levels[2])}\",\n", + " ha=\"left\",\n", + " va=\"top\",\n", + " color=\"dimgray\",\n", + ")\n", + "\n", + "fig.suptitle(\"Contours of $\\\\operatorname{FPR}^{i}$ levels on normal samples from the test set\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A few notes about the different FPR levels:\n", + "- $10^{-2}$ (blue): images have many and/or quite visible false positive regions;\n", + "- $10^{-3}$ (yellow): most regions disappear, but a few are still visible; \n", + "- $10^{-4}$ (red): usually one or two regions, barely visible." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualizing the Average FPR on Normal Images ($\\operatorname{FPRn}$)\n", + "\n", + "Let's now visualize the $\\operatorname{FPRn}$ and the variance of $\\operatorname{FPR}^{i}$ across the normal images." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# visalization of $FPRn$\n", + "# this one is an average behavior of the previous\n", + "# so one should expect a similar behavior but with\n", + "# some variations at each FPR level\n", + "\n", + "# we'll visualize the same FPR levels\n", + "FRP_levels = [1e-2, 1e-3, 1e-4]\n", + "# technical detail: decreasing order of FPR --> increasing order of threshold\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(14, 5.2), layout=\"constrained\")\n", + "\n", + "# function `threshold_from_fpr()` is replaced by an equivalent function\n", + "# for FPRn is already implemented in `pimo_result.thresh_at`\n", + "thresholds = [pimo_result.thresh_at(fpr_level)[1] for fpr_level in FRP_levels]\n", + "# note that all images used the same (ie 'shared') thresholds now\n", + "\n", + "# `normal_images_selection` is the same from the previous cell\n", + "for ax, index in zip(axes, normal_images_selection, strict=False):\n", + " image = cv2.resize(read_image(image_paths[index]), (256, 256))\n", + " anomaly_map = anomaly_maps[index]\n", + " fprs = [(anomaly_map > threshold).float().mean() for threshold in thresholds]\n", + " anomaly_map = anomaly_map.numpy()\n", + "\n", + " ax.imshow(image)\n", + " # `global_normal_vmin` and `global_normal_vmax` are the same from the previous cell\n", + " ax.imshow(anomaly_map, cmap=\"jet\", alpha=0.10, vmin=global_normal_vmin, vmax=global_normal_vmax)\n", + " c = ax.contour(anomaly_map, levels=thresholds, linewidths=1, colors=[\"blue\", \"yellow\", \"red\"])\n", + " ax.set_title(f\"image {index}\")\n", + "\n", + " ax.annotate(\n", + " \"$\\\\operatorname{FPR}^{i}$ levels: \"\n", + " f\"Blue = {fprs[0] * 100:.1g}% Yellow = {fprs[1] * 100:.1g}% Red = {fprs[2] * 100:.1g}%\",\n", + " xy=(0.01, 0.01),\n", + " xycoords=\"axes fraction\",\n", + " ha=\"left\",\n", + " va=\"bottom\",\n", + " color=\"white\",\n", + " )\n", + "\n", + "for ax in axes.flatten():\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + "\n", + "fig.text(\n", + " 0.03,\n", + " -0.01,\n", + " \"Anomaly maps colored in JET colormap with min-max normalization across all normal images. \"\n", + " \" $\\\\operatorname{FPRn}$ levels: \"\n", + " f\"Blue = {fmt_pow10(FRP_levels[0])} Yellow = {fmt_pow10(FRP_levels[1])} Red = {fmt_pow10(FRP_levels[2])}\",\n", + " ha=\"left\",\n", + " va=\"top\",\n", + " color=\"dimgray\",\n", + ")\n", + "\n", + "fig.suptitle(\"Contours of $\\\\operatorname{FPRn}$ levels on normal samples from the test set\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Discussion\n", + "\n", + "#### Variance\n", + "\n", + "Note that each $\\operatorname{FPR}^{i}$ has a wide variance\\* of visual results across images.\n", + " \n", + "For instance, the blue level ranges from 0.2% to 3%, which visually is a huge difference, and the red level doesn't even show in most images.\n", + "\n", + "This variance is specific to each model-dataset, we observed many state-of-the-art models on the datasets from MVTec-AD and VisA, and we noticed that low levels tend to have a negligible visual variance.\n", + "\n", + "#### Default bounds (L and U)\n", + "\n", + "So how were the default bounds chosen?\n", + "\n", + "> Recall: \n", + "> \n", + "> $$\n", + "> \\text{AUPIMO} \n", + "> \\; = \\; \n", + "> \\frac{1}{\\log(U/L)}\n", + "> \\int_{\\log(L)}^{\\log(U)} \n", + "> \\operatorname{TPR}^{i}\\left( \\operatorname{FRPn^{-1}}( z ) \\right)\n", + "> \\, \n", + "> \\mathrm{d}\\log(z) \n", + "> $$\n", + "\n", + "##### Upper bound U = 10^{-4}\n", + "\n", + "The upper bound $U$ sets the requirement level of the detection task.\n", + "\n", + "The lower the $U$, the harder the task, and ideally we'd like it be zero (i.e. anomalies are detected with no false positives).\n", + "\n", + "Compared to the images' content, the regions at $\\operatorname{FPRn} = 10^{-4}$ are _visually negligible_\\*.\n", + " \n", + "##### Lower bound L = 10^{-5}\n", + "\n", + "The lower bound $L$ has two numerical motivations.\n", + "\n", + "First, AUPIMO's integral is in log scale, so necessarily $L > 0$ and more weight is given to lower FPR levels.\n", + "\n", + "Second, images/masks/anomaly maps have finite resolution ($\\approx 10^{6}$ pixels/image\\*) -- so $\\operatorname{FPR}^{i}$ and $\\operatorname{FPRn}$ have discrete ranges.\n", + "\n", + "At $\\operatorname{FPRn} = 10^{-5}$, the discretization effects are still reasonable.\n", + "\n", + "##### Be careful!\n", + "\n", + "\\* These observations are based on the datasets we analyzed (from MVTec-AD and VisA).\n", + "\n", + "For other datasets, the default bounds may not be the best choice.\n", + "\n", + "Fortunately, AUPIMO allows customizing the bounds!\n", + "\n", + "> More details on these topics in our paper (see the last cell)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Custom FPRn bounds\n", + "\n", + "It's very easy to customize the $\\operatorname{FPRn}$ bounds $L$ and $U$ in AUPIMO.\n", + "\n", + "You can guess from the signature:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mAUPIMO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnum_thresholds\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m300000\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfpr_bounds\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1e-05\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.0001\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mreturn_average\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mforce\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "Area Under the Per-Image Overlap (PIMO) curve.\n", + "\n", + "This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code.\n", + "The tensors are converted to numpy arrays and then passed and validated in the numpy code.\n", + "The results are converted back to tensors and wrapped in an dataclass object.\n", + "\n", + "Scores are computed from the integration of the PIMO curves within the given FPR bounds, then normalized to [0, 1].\n", + "It can be thought of as the average TPR of the PIMO curves within the given FPR bounds.\n", + "\n", + "Details: `anomalib.metrics.per_image.pimo`.\n", + "\n", + "Notation:\n", + " N: number of images\n", + " H: image height\n", + " W: image width\n", + " K: number of thresholds\n", + "\n", + "Attributes:\n", + " anomaly_maps: floating point anomaly score maps of shape (N, H, W)\n", + " masks: binary (bool or int) ground truth masks of shape (N, H, W)\n", + "\n", + "Args:\n", + " num_thresholds: number of thresholds to compute (K)\n", + " fpr_bounds: lower and upper bounds of the FPR integration range\n", + " force: whether to force the computation despite bad conditions\n", + "\n", + "Returns:\n", + " tuple[PIMOResult, AUPIMOResult]: PIMO and AUPIMO results dataclass objects. See `PIMOResult` and `AUPIMOResult`.\n", + "\u001b[0;31mInit docstring:\u001b[0m\n", + "Area Under the Per-Image Overlap (PIMO) curve.\n", + "\n", + "Args:\n", + " num_thresholds: [passed to parent `PIMO`] number of thresholds used to compute the PIMO curve\n", + " fpr_bounds: lower and upper bounds of the FPR integration range\n", + " return_average: if True, return the average AUPIMO score; if False, return all the individual AUPIMO scores\n", + " force: if True, force the computation of the AUPIMO scores even in bad conditions (e.g. few points)\n", + "\u001b[0;31mFile:\u001b[0m ~/miniconda3/envs/anomalib-dev/lib/python3.10/site-packages/anomalib/metrics/pimo/pimo.py\n", + "\u001b[0;31mType:\u001b[0m ABCMeta\n", + "\u001b[0;31mSubclasses:\u001b[0m " + ] + } + ], + "source": [ + "AUPIMO?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's recompute the scores with the following situation: \n", + "- $U = 10^{-2}$ to make the detection task easier;\n", + "- $L = 10^{-4}$ assuming that \"small\" anomalies are not important for the application." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n" + ] + } + ], + "source": [ + "aupimo_custom = AUPIMO(\n", + " # with `False` all the values are returned in a dataclass\n", + " return_average=False,\n", + " # customized!\n", + " fpr_bounds=(1e-4, 1e-2),\n", + ")\n", + "\n", + "# we already have all of them in concatenated tensors\n", + "# so we don't need to loop over the batches like before\n", + "aupimo_custom.update(anomaly_maps=anomaly_maps, masks=masks)\n", + "pimo_result_custom, aupimo_result_custom = aupimo_custom.compute()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 3, figsize=(10, 5), layout=\"tight\")\n", + "\n", + "for ax, index in zip(axes.flatten(), samples, strict=False):\n", + " score = aupimo_result_custom.aupimos[index].item()\n", + " tpr = pimo_result_custom.per_image_tprs[index]\n", + " fpr = pimo_result_custom.shared_fpr\n", + " lower_bound, upper_bound = aupimo_custom.fpr_bounds\n", + " threshs_auc_mask = (pimo_result_custom.thresholds > aupimo_result_custom.thresh_lower_bound) & (\n", + " pimo_result_custom.thresholds < aupimo_result_custom.thresh_upper_bound\n", + " )\n", + " fpr_in_auc = fpr[threshs_auc_mask]\n", + " tpr_in_auc = tpr[threshs_auc_mask]\n", + "\n", + " plot_pimo_with_auc_zone(ax, tpr, fpr, lower_bound, upper_bound, fpr_in_auc, tpr_in_auc)\n", + " ax.set_title(f\"Image {index} ({score:.0%} AUPIMO)\")\n", + "\n", + "axes[-1, -1].axis(\"off\")\n", + "axes[-1, -1].text(\n", + " -0.08,\n", + " 0,\n", + " \"\"\"\n", + "FPRn: Avg. [in-image] False Positive Rate (FPR)\n", + " on normal images only ('n').\n", + "\n", + "TPR: [in-image] True Positive Rate (TPR),\n", + " or Recall.\n", + "\n", + "Integration zone in light pink, and area\n", + "under the curve (AUC) in purple.\n", + "\n", + "This area is normalized by the range size\n", + "so that AUPIMO is in [0, 1].\n", + "\"\"\",\n", + " ha=\"left\",\n", + " va=\"bottom\",\n", + " fontsize=\"x-small\",\n", + " color=\"dimgray\",\n", + " font=\"monospace\",\n", + ")\n", + "\n", + "fig.suptitle(\"PIMO curves\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the AUPIMO score increased with the easier task :) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cite Us\n", + "\n", + "AUPIMO was developed during [Google Summer of Code 2023 (GSoC 2023)](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd) with the `anomalib` team from Intel's OpenVINO Toolkit.\n", + "\n", + "arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n", + "\n", + "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n", + "\n", + "```bibtex\n", + "@misc{bertoldo2024aupimo,\n", + " author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n", + " title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n", + " year={2024},\n", + " url={https://arxiv.org/abs/2401.01984}, \n", + "}\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "anomalib-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb b/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb new file mode 100644 index 0000000000..7cbd29823b --- /dev/null +++ b/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# AUPIMO Score of a Random Model\n", + "\n", + "If model randomly assigns scores to the pixels -- i.e. no discrimination -- its AUROC score will be 50%. \n", + "\n", + "What would be its AUPIMO score?\n", + "\n", + "> AUPIMO is pronounced \"a-u-pee-mo\".\n", + "\n", + "> For basic usage, please check the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb).\n", + "\n", + "> For PIMO curve plots, please check the notebook [701c_aupimo_advanced_ii.ipynb](./701c_aupimo_advanced_ii.ipynb)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# What is AUPIMO?\n", + "\n", + "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n", + "\n", + "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n", + "\n", + "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n", + "\n", + "But:\n", + "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n", + "- the FPR (X-axis) considers the (average of) **normal** images only; \n", + "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n", + "\n", + "\\* The score (the area under the curve) is normalized to be in [0, 1].\n", + "\n", + "AUPIMO can be interpreted as\n", + "\n", + "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n", + "\n", + "References in the last cell.\n", + "\n", + "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Install `anomalib` using `pip`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released # noqa: TD003\n", + "%pip install ../.." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.axes import Axes\n", + "from matplotlib.ticker import FixedLocator, PercentFormatter\n", + "from numpy import ndarray" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Random Model\n", + "\n", + "If a model cannot discriminate between normal and anomalous images, the survival fuctions\\* of the anomaly scores conditioned to each class would be the same.\n", + "\n", + "> \\* https://en.wikipedia.org/wiki/Survival_function\n", + "\n", + "In other words, FPR and TPR would be the same.\n", + "\n", + "Let's simulate this situation." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "thresholds = torch.linspace(0, 1, 1001)\n", + "\n", + "# fpr and tpr as a function of the threshold (i.e. the survival functions)\n", + "# generaly look like logistic functions flipped horizontally\n", + "# their actual shapes don't matter much, but rather how they compare to each other\n", + "# in this case, since they're the same, this choice is arbitrary as long as\n", + "# they're monotonically decreasing with the threshold\n", + "fpr = 1 - 1e2 / (1e2 + torch.exp(-20 * (thresholds - 0.5)))\n", + "tpr = fpr.clone()\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(8, 2), constrained_layout=True, sharey=True)\n", + "\n", + "axes[0].plot(thresholds, fpr, label=\"FPR\")\n", + "axes[1].plot(thresholds, tpr, label=\"TPR\")\n", + "\n", + "for ax in axes:\n", + " ax.set_xlabel(\"Threshold\")\n", + " ax.legend(loc=\"upper right\")\n", + " ax.set_yticks([0, 0.5, 1])\n", + " ax.set_xticks([])\n", + " ax.grid()\n", + "\n", + "fig.supylabel(\"FPR or TPR\", x=-0.03)\n", + "fig.suptitle(\"Simulated FPR and TPR curves\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PIMO curve\n", + "\n", + "In the ROC curve, the FPR = TPR looks like a straight line.\n", + "\n", + "What does it look like in the PIMO curve?" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# utility plot functions (from the previous notebook)\n", + "\n", + "\n", + "def fmt_pow10(value: float) -> str:\n", + " \"\"\"Format the power of 10.\"\"\"\n", + " return \"1\" if value == 1 else f\"$10^{{{int(np.log10(value))}}}$\"\n", + "\n", + "\n", + "def plot_pimo_with_auc_zone(\n", + " ax: Axes,\n", + " tpr: ndarray,\n", + " fpr: ndarray,\n", + " lower_bound: float,\n", + " upper_bound: float,\n", + " fpr_in_auc: ndarray,\n", + " tpr_in_auc: ndarray,\n", + ") -> None:\n", + " \"\"\"Helper function to plot the PIMO curve with the AUC zone.\"\"\"\n", + " # plot\n", + " ax.plot(fpr, tpr, linewidth=3.5)\n", + " ax.axvspan(lower_bound, upper_bound, color=\"magenta\", alpha=0.3, zorder=-1)\n", + " ax.fill_between(fpr_in_auc, tpr_in_auc, alpha=1, color=\"tab:purple\", zorder=1)\n", + "\n", + " # config plots\n", + " ax.set_ylabel(\"TPR [%]\")\n", + " ax.yaxis.set_major_locator(FixedLocator(np.linspace(0, 1, 6)))\n", + " ax.yaxis.set_major_formatter(PercentFormatter(1, 0, symbol=\"\"))\n", + " ax.set_ylim(0, 1 + 3e-2)\n", + " ax.set_xlabel(\"FPR\")\n", + " ax.set_xscale(\"log\")\n", + " ax.xaxis.set_major_locator(FixedLocator(np.logspace(-6, 0, 7)))\n", + " ax.xaxis.set_major_formatter(lambda x, _: fmt_pow10(x))\n", + " ax.set_xlim(1e-6 / (eps := (1 + 3e-1)), 1 * eps)\n", + " ax.grid()\n", + "\n", + "\n", + "# simulate a random model's curve\n", + "lower_bound, upper_bound = 1e-5, 1e-4\n", + "threshs_auc_mask = (fpr > lower_bound) & (fpr < upper_bound)\n", + "fpr_in_auc = fpr[threshs_auc_mask]\n", + "tpr_in_auc = tpr[threshs_auc_mask]\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4.5))\n", + "plot_pimo_with_auc_zone(ax, tpr, fpr, lower_bound, upper_bound, fpr_in_auc, tpr_in_auc)\n", + "\n", + "fig.text(\n", + " 0.15,\n", + " -0.01,\n", + " \"\"\"\n", + "FPR: Avg. [in-image] False Positive Rate (FPR) on normal images only.\n", + "\n", + "TPR: [in-image] True Positive Rate (TPR), or Recall.\n", + "\n", + "Integration zone in light pink, and area under the curve (AUC) in purple.\n", + "\n", + "This area is normalized by the range size so that AUPIMO is in [0, 1].\n", + "\"\"\",\n", + " ha=\"left\",\n", + " va=\"top\",\n", + " fontsize=\"x-small\",\n", + " color=\"dimgray\",\n", + " font=\"monospace\",\n", + ")\n", + "\n", + "fig.suptitle(\"Random model's PIMO curve\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# AUPIMO Score\n", + "\n", + "Recall that AUPIMO is computed from this integral:\n", + "\n", + "$$\n", + " \\frac{1}{\\log(U/L)}\n", + " \\int_{\\log(L)}^{\\log(U)} \n", + " \\operatorname{TPR}^{i}\\left( \\operatorname{FRP^{-1}}( z ) \\right)\n", + " \\, \n", + " \\mathrm{d}\\log(z) \n", + "$$\n", + "\n", + "where the integration bounds -- $L$[ower] and $U$[pper] -- are the FPR bounds.\n", + "\n", + "By assuming $\\operatorname{TPR}^{i} = \\operatorname{FPR}$, the AUPIMO score only depends on the FPR bounds:\n", + "\n", + "$$\n", + " \\text{AUPIMO of a random model} = \\frac{U - L}{\\log(U/L)}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "random_model_aupimo(1e-4, 1e-5)=0.004%\n" + ] + } + ], + "source": [ + "def random_model_aupimo(lower_bound: float, upper_bound: float) -> float:\n", + " \"\"\"AUPIMO score obtained by a random model (no class discrimination).\"\"\"\n", + " return (upper_bound - lower_bound) / np.log(upper_bound / lower_bound)\n", + "\n", + "\n", + "print(f\"{random_model_aupimo(1e-4, 1e-5)=:.3%}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how a random model's AUPIMO score of $0.004%$ is numerically neglegible in the scale up to 100% -- while its AUROC is 50%.\n", + "\n", + "It's easier to interpret the meaning of AUPIMO scores: \n", + "- $0$%: random or worse, \n", + "- $100$%: perfect." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cite Us\n", + "\n", + "AUPIMO was developed during [Google Summer of Code 2023 (GSoC 2023)](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd) with the `anomalib` team from Intel's OpenVINO Toolkit.\n", + "\n", + "arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n", + "\n", + "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n", + "\n", + "```bibtex\n", + "@misc{bertoldo2024aupimo,\n", + " author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n", + " title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n", + " year={2024},\n", + " url={https://arxiv.org/abs/2401.01984}, \n", + "}\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "anomalib-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb b/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb new file mode 100644 index 0000000000..e117006951 --- /dev/null +++ b/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb @@ -0,0 +1,1507 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# AUPIMO statistical comparison between two models\n", + "\n", + "Model A has a higher average AUPIMO than model B. Can you be _sure_ that A is better than B? \n", + "\n", + "We'll use statistical tests here to make informed decisions about this.\n", + "\n", + "This notebook covers:\n", + "- load/save functions to import/export AUPIMO scores;\n", + "- statistical tests between two models, in particular:\n", + " - parametrical test with Student's t-test;\n", + " - non-parametrical test with Wilcoxon signed-rank test;\n", + "\n", + "> AUPIMO is pronounced \"a-u-pee-mo\".\n", + "\n", + "> For basic usage, please check the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# What is AUPIMO?\n", + "\n", + "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n", + "\n", + "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n", + "\n", + "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n", + "\n", + "But:\n", + "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n", + "- the FPR (X-axis) considers the (average of) **normal** images only; \n", + "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n", + "\n", + "\\* The score (the area under the curve) is normalized to be in [0, 1].\n", + "\n", + "AUPIMO can be interpreted as\n", + "\n", + "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n", + "\n", + "References in the last cell.\n", + "\n", + "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Install `anomalib` using `pip`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released # noqa: TD003\n", + "%pip install ../.." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import urllib.request\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.ticker import FixedLocator, IndexLocator, MaxNLocator, PercentFormatter\n", + "from scipy import stats\n", + "\n", + "from anomalib.metrics.pimo import AUPIMOResult" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "pd.options.display.float_format = \"{:.3f}\".format" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load AUPIMO scores\n", + "\n", + "Unlike previous notebook, we will not train and evaluate the models here.\n", + "\n", + "We'll load the AUPIMO scores from the benchmark presented in our paper (check the reference in the last cell).\n", + "\n", + "These scores can be found in AUPIMO's official repository in [`jpcbertoldo:aupimo/data/experiments/benchmark`](https://github.com/jpcbertoldo/aupimo/tree/main/data/experiments/benchmark). " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading benchmark results for model 'patchcore_wr101' and dataset 'mvtec/capsule'\n", + "Dowloading JSON file from https://raw.githubusercontent.com/jpcbertoldo/aupimo/refs/heads/main/data/experiments/benchmark/patchcore_wr101/mvtec/capsule/aupimo/aupimos.json\n", + "Converting payload to dataclass\n", + "Done!\n", + "Loading benchmark results for model 'patchcore_wr50' and dataset 'mvtec/capsule'\n", + "Dowloading JSON file from https://raw.githubusercontent.com/jpcbertoldo/aupimo/refs/heads/main/data/experiments/benchmark/patchcore_wr50/mvtec/capsule/aupimo/aupimos.json\n", + "Converting payload to dataclass\n", + "Done!\n" + ] + } + ], + "source": [ + "def get_benchmark_scores_url(model: str, dataset: str) -> str:\n", + " \"\"\"Generate the URL for the JSON file of a specific model and dataset.\"\"\"\n", + " root_url = \"https://raw.githubusercontent.com/jpcbertoldo/aupimo/refs/heads/main/data/experiments/benchmark\"\n", + " models = {\n", + " \"efficientad_wr101_m_ext\",\n", + " \"efficientad_wr101_s_ext\",\n", + " \"fastflow_cait_m48_448\",\n", + " \"fastflow_wr50\",\n", + " \"padim_r18\",\n", + " \"padim_wr50\",\n", + " \"patchcore_wr101\",\n", + " \"patchcore_wr50\",\n", + " \"pyramidflow_fnf_ext\",\n", + " \"pyramidflow_r18_ext\",\n", + " \"rd++_wr50_ext\",\n", + " \"simplenet_wr50_ext\",\n", + " \"uflow_ext\",\n", + " }\n", + " if model not in models:\n", + " msg = f\"Model '{model}' not available. Choose one of {sorted(models)}.\"\n", + " raise ValueError(msg)\n", + " datasets = {\n", + " \"mvtec/bottle\",\n", + " \"mvtec/cable\",\n", + " \"mvtec/capsule\",\n", + " \"mvtec/carpet\",\n", + " \"mvtec/grid\",\n", + " \"mvtec/hazelnut\",\n", + " \"mvtec/leather\",\n", + " \"mvtec/metal_nut\",\n", + " \"mvtec/pill\",\n", + " \"mvtec/screw\",\n", + " \"mvtec/tile\",\n", + " \"mvtec/toothbrush\",\n", + " \"mvtec/transistor\",\n", + " \"mvtec/wood\",\n", + " \"mvtec/zipper\",\n", + " \"visa/candle\",\n", + " \"visa/capsules\",\n", + " \"visa/cashew\",\n", + " \"visa/chewinggum\",\n", + " \"visa/fryum\",\n", + " \"visa/macaroni1\",\n", + " \"visa/macaroni2\",\n", + " \"visa/pcb1\",\n", + " \"visa/pcb2\",\n", + " \"visa/pcb3\",\n", + " \"visa/pcb4\",\n", + " \"visa/pipe_fryum\",\n", + " }\n", + " if dataset not in datasets:\n", + " msg = f\"Dataset '{dataset}' not available. Choose one of {sorted(datasets)}.\"\n", + " raise ValueError(msg)\n", + " return f\"{root_url}/{model}/{dataset}/aupimo/aupimos.json\"\n", + "\n", + "\n", + "def download_json(url_str: str) -> dict[str, str | float | int | list[str]]:\n", + " \"\"\"Download the JSON content from an URL.\"\"\"\n", + " with urllib.request.urlopen(url_str) as url: # noqa: S310\n", + " return json.load(url)\n", + "\n", + "\n", + "def load_aupimo_result_from_json_dict(payload: dict[str, str | float | int | list[str]]) -> AUPIMOResult:\n", + " \"\"\"Convert the JSON payload to an AUPIMOResult dataclass.\"\"\"\n", + " if not isinstance(payload, dict):\n", + " msg = f\"Invalid payload. Must be a dictionary. Got {type(payload)}.\"\n", + " raise TypeError(msg)\n", + " try:\n", + " return AUPIMOResult(\n", + " fpr_lower_bound=payload[\"fpr_lower_bound\"],\n", + " fpr_upper_bound=payload[\"fpr_upper_bound\"],\n", + " # `num_threshs` vs `num_thresholds` is an inconsistency with an older version of the JSON file\n", + " num_thresholds=payload[\"num_threshs\"] if \"num_threshs\" in payload else payload[\"num_thresholds\"],\n", + " thresh_lower_bound=payload[\"thresh_lower_bound\"],\n", + " thresh_upper_bound=payload[\"thresh_upper_bound\"],\n", + " aupimos=torch.tensor(payload[\"aupimos\"], dtype=torch.float64),\n", + " )\n", + "\n", + " except KeyError as ex:\n", + " msg = f\"Invalid payload. Missing key {ex}.\"\n", + " raise ValueError(msg) from ex\n", + "\n", + " except (TypeError, ValueError) as ex:\n", + " msg = f\"Invalid payload. Cause: {ex}.\"\n", + " raise ValueError(msg) from ex\n", + "\n", + "\n", + "def get_benchmark_aupimo_scores(model: str, dataset: str, verbose: bool = True) -> AUPIMOResult:\n", + " \"\"\"Get the benchmark AUPIMO scores for a specific model and dataset.\n", + "\n", + " Args:\n", + " model: The model name. See `_get_json_url` for the available models.\n", + " dataset: The \"collection/dataset\", where 'collection' is either 'mvtec' or 'visa', and 'dataset' is\n", + " the name of the dataset within the collection. See `_get_json_url` for the available datasets.\n", + " verbose: Whether to print the progress.\n", + "\n", + " Returns:\n", + " A `AUPIMOResult` dataclass with the AUPIMO scores from the benchmark results.\n", + "\n", + " More details in our paper: https://arxiv.org/abs/2401.01984\n", + " \"\"\"\n", + " if verbose:\n", + " print(f\"Loading benchmark results for model '{model}' and dataset '{dataset}'\")\n", + " url = get_benchmark_scores_url(model, dataset)\n", + " if verbose:\n", + " print(f\"Dowloading JSON file from {url}\")\n", + " payload = download_json(url)\n", + " if verbose:\n", + " print(\"Converting payload to dataclass\")\n", + " aupimo_result = load_aupimo_result_from_json_dict(payload)\n", + " if verbose:\n", + " print(\"Done!\")\n", + " return payload, aupimo_result\n", + "\n", + "\n", + "json_model_a, aupimo_result_model_a = get_benchmark_aupimo_scores(\"patchcore_wr101\", \"mvtec/capsule\")\n", + "_, aupimo_result_model_b = get_benchmark_aupimo_scores(\"patchcore_wr50\", \"mvtec/capsule\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's remove the `nan` values from the normal images." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "modela.shape=(109,) modelb.shape=(109,) labels.shape=(109,)\n" + ] + } + ], + "source": [ + "# corresponding paths to the images\n", + "# where the AUPIMO scores were computed from\n", + "paths = json_model_a[\"paths\"]\n", + "\n", + "# extract the labels (i.e. anomaly type or 'good')\n", + "labels = np.array([p.split(\"/\")[-2] for p in paths])\n", + "\n", + "# let's extract only the AUPIMO scores from anomalies\n", + "modela = aupimo_result_model_a.aupimos[labels != \"good\"].numpy()\n", + "modelb = aupimo_result_model_b.aupimos[labels != \"good\"].numpy()\n", + "labels = labels[labels != \"good\"]\n", + "print(f\"{modela.shape=} {modelb.shape=} {labels.shape=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(6, 3))\n", + "ax.boxplot(\n", + " [modela, modelb],\n", + " tick_labels=[f\"A mean: {modela.mean():.0%}\", f\"B mean: {modelb.mean():.0%}\"],\n", + " vert=False,\n", + " showmeans=True,\n", + " meanline=True,\n", + " widths=0.5,\n", + ")\n", + "ax.invert_yaxis()\n", + "ax.set_title(\"AUPIMO scores distributions from two models\")\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Is this difference significant?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image by image comparison\n", + "\n", + "Since we have the scores of each model for each image, we can compare them image by image." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "modela_is_better = modela > modelb\n", + "ax.scatter(modela[modela_is_better], modelb[modela_is_better], alpha=0.3, s=10, color=\"red\", marker=\"o\")\n", + "ax.scatter(modela[~modela_is_better], modelb[~modela_is_better], alpha=0.3, s=10, color=\"blue\", marker=\"o\")\n", + "ax.plot([0, 1], [0, 1], color=\"black\", linestyle=\"--\")\n", + "ax.set_xlabel(\"Model A\")\n", + "ax.set_ylabel(\"Model B\")\n", + "ax.set_title(\"AUPIMO scores direct comparison\")\n", + "ax.grid()\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The dashed line is where both models have the same AUPIMO score.\n", + "\n", + "Notice that there are images where one performs better than the other and vice-versa." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parametric Comparison\n", + "\n", + "Before using the statistical test, let's first visualize the data seen by the test.\n", + "\n", + "We'll use a _paired_ t-test, which means we'll compare the AUPIMO scores of the same image one by one." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_samples = modela.shape[0]\n", + "indexes = np.arange(num_samples)\n", + "\n", + "fig, ax = plt.subplots(figsize=(18, 4))\n", + "\n", + "# plot sample index vs score and their mean\n", + "ax.scatter(indexes, modela, s=30, color=\"tab:blue\", marker=\"o\", label=\"Model A\", zorder=3, alpha=0.6)\n", + "ax.axhline(modela.mean(), color=\"tab:blue\", linestyle=\"--\", label=\"Mean\", zorder=3)\n", + "ax.scatter(indexes, modelb, s=30, color=\"tab:red\", marker=\"o\", label=\"Model B\", zorder=3, alpha=0.6)\n", + "ax.axhline(modelb.mean(), color=\"tab:red\", linestyle=\"--\", label=\"Mean\", zorder=3)\n", + "\n", + "# configure the x-axis\n", + "ax.set_xlabel(\"Sample index\")\n", + "ax.set_xlim(0 - (eps := 0.01 * num_samples), num_samples + eps)\n", + "ax.xaxis.set_major_locator(IndexLocator(5, 0))\n", + "ax.xaxis.set_minor_locator(IndexLocator(1, 0))\n", + "\n", + "# configure the y-axis\n", + "ax.set_ylabel(\"AUPIMO [%]\")\n", + "ax.set_ylim(0 - 0.05, 1 + 0.05)\n", + "ax.yaxis.set_major_locator(MaxNLocator(6))\n", + "ax.yaxis.set_major_formatter(PercentFormatter(1))\n", + "\n", + "# configure the grid, legend, etc\n", + "ax.grid(axis=\"both\", which=\"major\", linestyle=\"-\")\n", + "ax.grid(axis=\"x\", which=\"minor\", linestyle=\"--\", alpha=0.5)\n", + "ax.legend(ncol=4, loc=\"upper left\", bbox_to_anchor=(0, -0.08))\n", + "ax.set_title(\"AUPIMO scores direct comparison\")\n", + "\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that several images actually have the same AUPIMO score for both models (e.g. from 10 to 15).\n", + "\n", + "Others like 21 show a big difference -- model B didn't detect the anomaly at all, but model A did a good job (60% AUPIMO).\n", + "\n", + "Let's simplify this and only show the differences." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "differences = modela - modelb\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 3))\n", + "ax.hist(differences, bins=np.linspace(-1, 1, 61), edgecolor=\"black\")\n", + "ax.axvline(differences.mean(), color=\"black\", linestyle=\"--\", label=\"Mean\")\n", + "\n", + "# configure the x-axis\n", + "ax.set_xlabel(\"AUPIMO [%]\")\n", + "ax.set_xlim(-1, 1)\n", + "ax.xaxis.set_major_locator(MaxNLocator(9))\n", + "ax.xaxis.set_minor_locator(MaxNLocator(41))\n", + "ax.xaxis.set_major_formatter(PercentFormatter(1))\n", + "\n", + "# configure the y-axis\n", + "ax.set_ylabel(\"Count\")\n", + "\n", + "# configure the grid, legend, etc\n", + "ax.grid(axis=\"both\", which=\"major\", linestyle=\"-\", alpha=1, linewidth=1.0)\n", + "ax.grid(axis=\"x\", which=\"minor\", linestyle=\"-\", alpha=0.3)\n", + "ax.legend(loc=\"upper right\")\n", + "ax.set_title(\"AUPIMO scores differences distribution (Model A - Model B)\")\n", + "\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It looks like there is a bias to the right indeed (so model A > model B). \n", + "\n", + "Is that statistically significant or just random?\n", + "\n", + "> **Dependent t-test for paired samples**\n", + "> \n", + "> - null hypothesis: `average(A) == average(B)` \n", + "> - alternative hypothesis: `average(A) != average(B)`\n", + "> \n", + "> See [`scipy.stats.ttest_rel`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_rel.html) and [\" Wikipedia's page on \"Student's t-test\"](https://en.wikipedia.org/wiki/Student's_t-test#Dependent_t-test_for_paired_samples).\n", + ">\n", + "> **Confidence Level**\n", + "> \n", + "> Instead of reporting the p-value, we'll report the \"confidence level\" [that the null hypothesis is false], which is `1 - pvalue`.\n", + "> \n", + "> *Higher* confidence level *more confident* that `average(A) > average(B)`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test_result=TtestResult(statistic=2.8715471705520033, pvalue=0.004917091449731462, df=108)\n", + "confidence=99.5%\n" + ] + } + ], + "source": [ + "test_result = stats.ttest_rel(modela, modelb)\n", + "confidence = 1.0 - float(test_result.pvalue)\n", + "print(f\"{test_result=}\")\n", + "print(f\"{confidence=:.1%}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So, we're very confident that model A has a higher AUPIMO score than model B.\n", + "\n", + "Maybe is that due to some big differences in a few images?\n", + "\n", + "What if we don't count much for these big differences?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Non-parametric (rank comparison)\n", + "\n", + "In non-parametric comparison, bigger differences don't matter more than smaller differences. \n", + "\n", + "It's all about their relative position.\n", + "\n", + "Let's look at the analogous plots for this type of comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the `-` sign is to sort in descending order because higher AUPIMO is better\n", + "# the rank values are 1 or 2 because there are only two models\n", + "# where 1 is the best and 2 is the worst\n", + "# when the scores are the same, 1.5 is assigned to both models\n", + "ranks = stats.rankdata(-np.stack([modela, modelb], axis=1), method=\"average\", axis=1)\n", + "ranksa, ranksb = ranks[:, 0], ranks[:, 1]\n", + "\n", + "num_samples = ranks.shape[0]\n", + "indexes = np.arange(num_samples)\n", + "\n", + "fig, ax = plt.subplots(figsize=(18, 2.5))\n", + "\n", + "# plot sample index vs score and their mean\n", + "ax.scatter(indexes, ranksa, s=30, color=\"tab:blue\", marker=\"o\", label=\"Model A\", zorder=3, alpha=0.6)\n", + "ax.axhline(ranksa.mean(), color=\"tab:blue\", linestyle=\"--\", label=\"Mean\", zorder=3)\n", + "ax.scatter(indexes, ranksb, s=30, color=\"tab:red\", marker=\"o\", label=\"Model B\", zorder=3, alpha=0.6)\n", + "ax.axhline(ranksb.mean(), color=\"tab:red\", linestyle=\"--\", label=\"Mean\", zorder=3)\n", + "\n", + "# configure the x-axis\n", + "ax.set_xlabel(\"Sample index\")\n", + "ax.set_xlim(0 - (eps := 0.01 * num_samples), num_samples + eps)\n", + "ax.xaxis.set_major_locator(IndexLocator(5, 0))\n", + "ax.xaxis.set_minor_locator(IndexLocator(1, 0))\n", + "\n", + "# configure the y-axis\n", + "ax.set_ylabel(\"AUPIMO Rank\")\n", + "ax.set_ylim(1 - 0.1, 2 + 0.1)\n", + "ax.yaxis.set_major_locator(FixedLocator([1, 1.5, 2]))\n", + "ax.invert_yaxis()\n", + "\n", + "# configure the grid, legend, etc\n", + "ax.grid(axis=\"both\", which=\"major\", linestyle=\"-\")\n", + "ax.grid(axis=\"x\", which=\"minor\", linestyle=\"--\", alpha=0.5)\n", + "ax.legend(ncol=4, loc=\"upper left\", bbox_to_anchor=(0, -0.15))\n", + "ax.set_title(\"AUPIMO scores ranks\")\n", + "\n", + "fig.text(\n", + " 0.9,\n", + " -0.1,\n", + " \"Ranks: 1 is the best, 2 is the worst, 1.5 when the scores are the same.\",\n", + " ha=\"right\",\n", + " va=\"top\",\n", + " fontsize=\"small\",\n", + ")\n", + "\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, blue seems to have a slight advantage, but -- again -- is it significant enough to be sure that model A is better than model B?\n", + "\n", + "Remember that AUPIMO is a recall metric, so it is basically a ratio of the area of anomalies. \n", + "\n", + "Is it relevant if model A has 1% more recall than model B in a given image?\n", + "\n", + "> You can check that out in [`701b_aupimo_advanced_i.ipybn`](./701b_aupimo_advanced_i.ipynb).\n", + "\n", + "We'll --arbitrarily -- assume that only differences above 5% are relevant." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABboAAAEsCAYAAAAFEQVZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC0cElEQVR4nOydd3hUVfrHvzNppJBACBA6AUIRlQVRBFSwUIS1t0V0QcSKa8e2Fiwr2Ne1d1xFsQE2WEWko6goP5QOBhEIKCBJSEgymTm/PzDDTDLlnpu5N2/ufD/Pw6OZOWfO+ZzznveeOZnccSmlFAghhBBCCCGEEEIIIYSQBoq7vjtACCGEEEIIIYQQQgghhNQFHnQTQgghhBBCCCGEEEIIadDwoJsQQgghhBBCCCGEEEJIg4YH3YQQQgghhBBCCCGEEEIaNDzoJoQQQgghhBBCCCGEENKg4UE3IYQQQgghhBBCCCGEkAYND7oJIYQQQgghhBBCCCGENGh40E0IIYQQQgghhBBCCCGkQcODbkIIIYQQQgghhBBCCCENGh50E0IIIYQQQhyPy+XCNddcU9/dIIQQQgghFsGDbkIIIYQQUm88++yzcLlc6NevX8jnt2zZApfLhUcffTTk848++ihcLhe2bNnif2zw4MFwuVz+f9nZ2Tj66KPx6quvwufz+cuNHTsWGRkZQa9XXTc/Pz9ke3PnzvW/7vvvv1/r+dWrV+Oiiy5CmzZtkJKSgtatW2P06NFYvXp1tKEghBBCCCGE1AEedBNCCCGEkHpj2rRp6NixI7755hts2rQpZq/btm1bvPHGG3jjjTdw1113oaqqCpdeeinuuOOOqHUbNWqETZs24ZtvvgnZ30aNGoWsN2PGDPTp0wfz5s3DJZdcgmeffRaXXnop5s+fjz59+mDmzJl19iKEEEIIIYSEhgfdhBBCCCGkXigoKMCyZcvw+OOPo3nz5pg2bVrMXjsrKwsXXXQRLrroItxwww1YunQp2rZti6effhoejydi3c6dO6Nbt254++23gx4vLy/HzJkzMXLkyFp1Nm/ejIsvvhidOnXCqlWr8MADD+DSSy/F/fffj1WrVqFTp064+OKL8fPPP8fM0SrKy8uDPvluJ6WlpfXSLiGEEEIIafjwoJsQQgghhNQL06ZNQ9OmTTFy5Eice+65MT3orklaWhqOPfZYlJaW4vfff49aftSoUXjnnXeCDnw//vhjlJWV4fzzz69V/pFHHkFZWRlefPFFNG/ePOi5nJwcvPDCCygtLcXDDz8cte2nnnoKPXv2RFpaGpo2bYq+ffvirbfeCiqzfft2XHrppWjdujVSUlKQl5eHq666CpWVlf4yP//8M8477zxkZ2f7/T/99NOg11mwYAFcLhemT5+OO++8E23atEFaWhqKi4sBAMuXL8fw4cORlZWFtLQ0DBo0CEuXLg16jZKSElx//fXo2LEjUlJS0KJFCwwZMgTff/99RM9JkybB5XJhzZo1uPDCC9G0aVMcd9xxAIBVq1Zh7Nix6NSpExo1aoTc3FyMGzcOe/bsCfkamzZtwtixY9GkSRNkZWXhkksuQVlZWdSxfuCBB+B2u/HUU09pjT8hhBBCCJFHYn13gBBCCCGExCfTpk3D2WefjeTkZIwaNQrPPfccvv32Wxx99NGWtPfzzz8jISEBTZo0iVr2wgsvxKRJk7BgwQKcdNJJAIC33noLJ598Mlq0aFGr/Mcff4yOHTvi+OOPD/l6J5xwAjp27FjroLkmL730Eq699lqce+65uO6661BeXo5Vq1Zh+fLluPDCCwEAO3bswDHHHIN9+/bh8ssvR/fu3bF9+3a8//77KCsrQ3JyMnbt2oUBAwagrKwM1157LZo1a4bXX38dp59+Ot5//32cddZZQe3ef//9SE5Oxs0334yKigokJyfjyy+/xKmnnoqjjjoK99xzD9xuN1577TWcdNJJWLx4MY455hgAwJVXXon3338f11xzDQ477DDs2bMHS5Yswdq1a9GnT5+oY33eeechPz8fDz74IJRSAA7eC/3nn3/GJZdcgtzcXKxevRovvvgiVq9eja+//houlyvoNc4//3zk5eVh8uTJ+P777/Hyyy+jRYsWeOihh8K2e+edd+LBBx/ECy+8gMsuu8zw+BNCCCGEEJnwoJsQQgghhNjOihUrsG7dOv8naY877ji0bdsW06ZNi8lBt9frxe7duwEAu3fvxnPPPYfvv/8ep512GtLS0qLWz8/P93+S96STTsK+ffswe/ZsvPTSS7XKFhUVYceOHTjjjDMivuaRRx6Jjz76CCUlJWjcuHHIMp9++il69uyJ9957L+zr3H777di5cyeWL1+Ovn37+h+/7777/AfFU6ZMwa5du7B48WL/p6Qvu+wyHHnkkbjxxhtxxhlnwO0+9Med5eXl+O6775CamgoAUErhyiuvxIknnog5c+b4D5avuOIK9OzZE3feeSc+//xzf58vu+wyPPbYY/7Xu+WWWyKORSC9evWq9Ynpq6++GjfddFPQY8ceeyxGjRqFJUuW1PqFQu/evfHKK6/4f96zZw9eeeWVsAfdN998M5544gm89tprGDNmjP9xI+NPCCGEEEJkwluXEEIIIYQQ25k2bRpatmyJE088EQDgcrlwwQUXYPr06fB6vXV+/XXr1qF58+Zo3rw5evTogaeeegojR47Eq6++avg1LrzwQsyYMQOVlZV4//33kZCQUOuT0MDBW3cACHt4XU3189W3BQlFkyZNsG3bNnz77bchn/f5fJg1axZOO+20oEPuaqoPpGfPno1jjjnGf8gNABkZGbj88suxZcsWrFmzJqjemDFj/IfcALBy5Ups3LgRF154Ifbs2YPdu3dj9+7dKC0txcknn4xFixb5b+vSpEkTLF++HDt27IjoH44rr7yy1mOBfSkvL8fu3btx7LHHAkDIW6LUfI3jjz8ee/bsqTXWSilcc801ePLJJ/Hmm28GHXJXu0Qaf0IIIYQQIhcedBNCCCGEEFvxer2YPn06TjzxRBQUFGDTpk3YtGkT+vXrh127dmHevHnar1nzVhYdO3bE3Llz8cUXX2DJkiXYuXMnPvnkE+Tk5Bh+zb/97W8oKirCnDlzMG3aNPz1r38NeZhd/Vj1gXc4jByI33rrrcjIyMAxxxyD/Px8TJgwIeie2L///juKi4tx+OGHR2zrl19+Qbdu3Wo93qNHD//zgeTl5QX9vHHjRgAHD8Crf2FQ/e/ll19GRUUFioqKAAAPP/wwfvrpJ7Rr1w7HHHMMJk2apPWlmzXbBoC9e/fiuuuuQ8uWLZGamormzZv7y1W3G0j79u2Dfm7atCkA4I8//gh6/L///S+eeeYZPPXUUxg1alSt14k2/oQQQgghRC68dQkhhBBCCLGVL7/8EoWFhZg+fTqmT59e6/lp06Zh6NChAIBGjRoBAA4cOBDytaq/cLC6XDXp6ek45ZRT6tTPVq1aYfDgwXjsscewdOlSfPDBByHLZWVloVWrVli1alXE11u1ahXatGmDzMzMsGV69OiB9evX45NPPsH//vc/fPDBB3j22Wdx99134957762TTyQCP0ENwP9p7UceeQR/+ctfQtbJyMgAcPD+2McffzxmzpyJzz//HI888ggeeughzJgxA6eeeqp229WvuWzZMkycOBF/+ctfkJGRAZ/Ph+HDhwd9QWg1CQkJIV+7+lYu1QwcOBArV67E008/jfPPPx/Z2dlBz9fX+BNCCCGEkLrDg25CCCGEEGIr06ZNQ4sWLfDMM8/Uem7GjBmYOXMmnn/+ef8nedPS0rB+/fqQr7V+/XqkpaVpfVJbhwsvvBDjx49HkyZNMGLEiLDl/vrXv+Kll17CkiVLgm4XUs3ixYuxZcsWXHHFFVHbTE9PxwUXXIALLrgAlZWVOPvss/Gvf/0Lt99+O5o3b47MzEz89NNPEV+jQ4cOIcds3bp1/ucj0blzZwBAZmamoV8YtGrVCldffTWuvvpq/Pbbb+jTpw/+9a9/GTrorskff/yBefPm4d5778Xdd9/tf7z6U+Z1oUuXLnj44YcxePBgDB8+HPPmzav1CftI41/zFyqEEEIIIUQOvHUJIYQQQgixjQMHDmDGjBn461//inPPPbfWv2uuuQYlJSX46KOPABz8pO7QoUPx8ccfY+vWrUGvtXXrVnz88ccYOnRo2E/01pVzzz0X99xzD5599lkkJyeHLTdx4kSkpqbiiiuuwJ49e4Ke27t3L6688kqkpaVh4sSJEdurWTc5ORmHHXYYlFLweDxwu90488wz8fHHH+O7776rVb/6E8wjRozAN998g6+++sr/XGlpKV588UV07NgRhx12WMR+HHXUUejcuTMeffRR7N+/v9bzv//+O4CDt6GpeSuRFi1aoHXr1qioqIjYRjiq57Lmp7H//e9/m3q9mhx55JGYPXs21q5di9NOOy3orwWijT8hhBBCCJELP9FNCCGEEEJs46OPPkJJSQlOP/30kM8fe+yxaN68OaZNm4YLLrgAAPDggw/i2GOPRZ8+fXD55ZejY8eO2LJlC1588UW4XC48+OCDlvU3KysLkyZNilouPz8fr7/+OkaPHo0jjjgCl156KfLy8rBlyxa88sor2L17N95++23/J6XDMXToUOTm5mLgwIFo2bIl1q5di6effhojR470f/L4wQcfxOeff45Bgwbh8ssvR48ePVBYWIj33nsPS5YsQZMmTXDbbbfh7bffxqmnnoprr70W2dnZeP3111FQUIAPPvgAbnfkz7u43W68/PLLOPXUU9GzZ09ccsklaNOmDbZv34758+cjMzMTH3/8MUpKStC2bVuce+656NWrFzIyMvDFF1/g22+/xWOPPWZ4nAPJzMzECSecgIcffhgejwdt2rTB559/joKCAlOvF4pjjz0WH374IUaMGIFzzz0Xs2bNQlJSkqHxJ4QQQgghMuFBNyGEEEIIsY1p06ahUaNGGDJkSMjn3W43Ro4ciWnTpmHPnj1o1qwZevTogeXLl2PSpEl45ZVXsHfvXmRnZ2PIkCG455570L17d5stQnPeeeehe/fumDx5sv9wu1mzZjjxxBNxxx13RP0CSQC44oorMG3aNDz++OPYv38/2rZti2uvvRZ33nmnv0ybNm2wfPly3HXXXZg2bRqKi4vRpk0bnHrqqUhLSwMAtGzZEsuWLcOtt96Kp556CuXl5TjyyCPx8ccfY+TIkYZ8Bg8ejK+++gr3338/nn76aezfvx+5ubno16+f/xYsaWlpuPrqq/H5559jxowZ8Pl86NKlC5599llcddVVJkbxIG+99Rb+8Y9/4JlnnoFSCkOHDsWcOXPQunVr069Zk5NOOgnvvvsuzjnnHFx88cV46623DI0/IYQQQgiRiUvV/JtAQgghhBBCCCGEEEIIIaQBwXt0E0IIIYQQQgghhBBCCGnQ8KCbEEIIIYQQQgghhBBCSIOGB92EEEIIIYQQQgghhBBCGjQ86CaEEEIIIYQQQgghhBDSoOFBNyGEEEIIIYQQQgghhJAGDQ+6CSGEEEIIIYQQQgghhDRoEuu7A3bj8/mwY8cONG7cGC6Xq767QwghhBBCCCGEEEIIISQESimUlJSgdevWcLsjf2Y77g66d+zYgXbt2tV3NwghhBBCCCGEEEIIIYQY4Ndff0Xbtm0jlom7g+7GjRsDODg4mZmZhut5PB58/vnnGDp0KJKSkgzV8Xq92Lx5Mzp37oyEhISYl7erDV13qR66deyYczN1nOIudawkxruZOk5xZ7zTnfEe+zrx6u6UeDdTxynujHe6M94jQ3fGuxVtmKnjFHepYyUx3s3UcYq7U+LdTB0zbZihuLgY7dq185/pRiLuDrqrb1eSmZmpfdCdlpaGzMxMraDKyMhAZmam4QDRKW9XG7ruUj1069gx52bqOMVd6lhJjHczdZzizninO+M99nXi1d0p8W6mjlPcGe90Z7xHhu6MdyvaMFPHKe5Sx0pivJup4xR3p8S7mTpm2qgLRm5BzS+jJIQQQgghhBBCCCGEENKg4UE3IYQQQgghhBBCCCGEkAYND7otxO12Iz8/P+o3gpotb1cbukj1oLssd6ljpYtd8xGv7ox3ulvVhi5SPeguy51rXV6c6CLVg+6y3KWOlRni1V2qB91luUsdK12k7k+c4u6UeDdTx65rlQ5yeuJQqqqqLC1vVxu6SPWgu7VI9JDobVcdp7gz3q2vY3UbUuNEF6kedLcWqR7x6i7R20wdp8y5mTpOcZc6VmaIV3epHnS3FokeEr3tquMUd6fEu5k6dl2rjMKDbgvx+XwoKCiAz+ezpLxdbegi1YPustyljpUuds1HvLoz3uluVRu6SPWguyx3rnV5caKLVA+6y3KXOlZmiFd3qR50l+Uudax0kbo/cYq7U+LdTB27rlU68KCbEEIIIYQQQgghhBBCSIOGB92EEEIIIYQQQgghhBBCGjQ86LYY3Ruym7mBux1t6CLVg+7WItFDordddZzizni3vo7VbUiNE12ketDdWqR6xKu7RG8zdZwy52bqOMVd6liZIV7dpXrQ3Vokekj0tquOU9ydEu9m6kj6IkoASKzvDjiZhIQEdO3a1bLydrWhi1QPustylzpWutg1H/Hqzninu1Vt6CLVg+6y3LnW5cWJLlI96C7LXepYmSFe3aV60F2Wu9Sx0kXq/sQp7k6JdzN17LpW6VCvB92LFi3CI488ghUrVqCwsBAzZ87EmWeeGbHOggULcOONN2L16tVo164d7rzzTowdO9ayPlZUebF0024sXLcL/7fRje/VWgzq3hIDu+QgJTEhYl2lFEpLS5Geng6XyxW1LZ3y1f1atOF3FP5RhlZN03BC1+ZR+2WmDV13XW8zdewYKzNIc69LHV0kedgx577KSpQuW4bSpUtRXrgTjVrlIn3gQKQPGAB3cnLM6lRj1N1MG7prvS7jK2mt25Hf7RorO2Le7Pjq9MmOa1v1GilZvBi5P/6I31etQuPjj4+6Dpnf5eRr3Tpm5lw3l9q11nX7ZTbedftlprxOnbrEiZX7WDtyVl3qGKUuewcrrwnV6MaJtOu6nWOlg1Ou67rYEe9mPCTu5czUkbrWJc+htL2c1Pd6ZpG2P6lLv3SR+v7Faur1oLu0tBS9evXCuHHjcPbZZ0ctX1BQgJEjR+LKK6/EtGnTMG/ePIwfPx6tWrXCsGHDYt6/iiovnl+wGUs37YHLpeDxAut27cfanaX4cVsRrhzcOWLw+nw+bNu2Dfn5+UhIiH5xMlq+Zr+UpwL7yquwZkdJ1H6ZbUPHXdfbTB07xsoMktzrWkcXKR52zLmvshJ7XnwJpV9/DbjdOODzAcXFKF+7DuU/rUazyy+rtVE2U0fX3Uwbumu9ruMrZa3bkd/tGis7Yr6u42ukT3Zc2wLXiHK54Kr0oGLDRlSu3xB1HTK/y8jXunXMzLluLrVrrev2qy7xrtMvs+WN1olFnFixj7UjZ9W1jqHXjcHewYprgq671Ou63WNlFKdc13WxI97NeEjcy5mpI3WtS59DSXs5qe/16oKk/Uld+6WL1PcvVlOvN1I59dRT8cADD+Css84yVP75559HXl4eHnvsMfTo0QPXXHMNzj33XDzxxBOW9G/ppt1YumkPcrMaoWOzdGQlAx2bpSM3qxGWbt6DpZt2W9KuTr/yctLRLC0ReTmx7ZdUd13sGCsiCzvmvHTZMpR+/TWSWrZEcocOQHY2kjt0QFLLlij9+muULlsWkzp29Et3rUtdU7r9siPH2TVWdl8TdMfXaJ/qY+16MzNjvg6JceyIEzNzrptL7Vrruv1ySrzXNU4aeo63mrruHay6Jugidc4ljpVd/ZK4RuyIdzNIbUNi/JpZ61LHVyJO8bADjpVcGtQ9ur/66iuccsopQY8NGzYM119/fdg6FRUVqKio8P9cXFwMAPB4PPB4PBHbW7huF1wuhdQkN3w+H4CDv61ITXLDBYWF63bh+M7ZYet7vV54vV54PB5//UgYLV+zX0r5DPfLbBs67rreZurYMVbV8REtTuriYaaOHW3Y4W6VR13mHDDmXrJ4MZTLBaSm/tmGgs/ngys1FcrlQsnixWg0cGCd6+i6m2lDd63XdXylrHU78rtdY2VHnqvr+Brpkx3XtpprBDg4724D69Ap+R3Qz/GS8rVuHTNzrptL7Vrruv2qS7zr9MtseaN1YhEn1e5W7pWtyFl1rWPVnsaOa4Kuu9Trut1jFW/XdV13O+LdjIfEvZyZOlLXuvQ5lLSXk/peL5CGvI+tS7+cdD5lBh1vl1JKWdYTDVwuV9R7dHft2hWXXHIJbr/9dv9js2fPxsiRI1FWVobU1NRadSZNmoR777231uNvvfUW0tLSIvbptQ1ueLxAVoi/6iyqBJISgEu6WjeR9dkvqe66OMWDGMeOOc+dNg2uSg+8mZm1nksoLoZKTsLO0aPrXMeOfumOl9Q1JdHDrrGS6GKmT1LXLrEOO+LEjnxt11rX7ZdT4l1qPpF6PdTFKXsHqW1IHCu7+iVxjdgR72aQ2obE+JUaixLj3QxO8bADjpW9lJWV4cILL0RRUREyQ+TwQBrUJ7rNcPvtt+PGG2/0/1xcXIx27dph6NChUQfne7UW63btR7tm6fD5fNi+bRvatG0Lt9sN755SdG+ZgREjelitELFfNYlVv6S661KXsfJ4PJg7dy6GDBmCpKQkq7sqiobsXtf1YcT991WrULFhI5Lbt6/1XOUvvyClaz76jBhR5zq6mGlDd63bkX/MoNsvO3KcXWNlR56ry/ga7ZMd4xW4Rny+g/eTa/vnvMdqHTYEpOR4O+LEzJzr5lK71rpuv5wS73WNk4ae4+uCVXsaO64Jukidc7vHKt6u64FIiXczSNzLmakjda1Ln0MzWLWXc8q1zQ6cMucNheq7cxihQR105+bmYteuXUGP7dq1C5mZmSE/zQ0AKSkpSElJqfV4UlJS1OAY1L0l1u4sxQHPwT8/AAC3240DHh8UXBjUvWXE11BKoaioCFlZWYa/rdRI+cB+packoLKyEsnJySit8Ebtl5k2dN11vc3UsWOsqjESK2Y9zNSxo41qrHS3yiMWcw5Edm98/PGoXL8BOHAA7vQ0fxu+0jK4lELj44+vVddMHV13M23orvW6jq+UtW5HfrdrrOzIc3UZX6N9suPaFrRG/tw3uN1u4MCBqOvQafkdMJ7jJeVr3Tpm5lw3l9q11nX7VZd41+mX2fJG69Q1Tqzax9qRs+pap5pY72nsuCbouku9rts9VtXEy3Vd192OeDfjIXEvZ6aO1LUufQ4l7eWkvtcLRUPcx9a1X4AzzqfMoHO436AOuvv374/Zs2cHPTZ37lz079/fkvYGdsnBj9uKsHTzHrigsL/y4G9mFFwY2LkZBnbJiVjf5/Nh586daNy4seFvKzVSPrBfbgA+TzncSY3gA6L2y0wbuu663mbq2DFWZpDkXtc6ukjxsGPO0wcMQPlPq//8xnYXDvgUlNsF+BTSjz0W6QMGxKSOrruZNnTXel3HV8patyO/2zVWdsR8XcbXaJ/suLYFrhHlciGhpASVv/wCl4q+DpnfZeRr3Tpm5lw3l9q11nX7VZd41+mX2fJG69Q1Tqzax9qRs+paxwh13TtYdU3QdZd6Xbd7rIzilOu6LnbEuxkPiXs5M3WkrnXpcyhpLyf1vV5dkLQ/qWu/dJH6/sVq6vWge//+/di0aZP/54KCAqxcuRLZ2dlo3749br/9dmzfvh3//e9/AQBXXnklnn76adxyyy0YN24cvvzyS7z77rv49NNPLelfSmICrhzcGUe0zcLCdbvwf8V70L1lBgZ1b4mBXXKQklg/kxjUr/W/oaCwAnm5GRjUrUXM+iXVXRc7xorIwo45dycno9nll6HR4T2xf8kSHCgoQEpeHjKOOw7pAwbAnVz7Rl1m6tjRL921LnVN6fbLjhxn11jZfk3QHV+DfbJ77ZYsXgz1449I6ZqPxscfH7N1SIxjR5yYmXPdXGrXWtftl1Pivc5x0sBzvNXUee9g0TVBF6lzLnGs7OqXxDViR7ybQWobEuPXzFqXOr4ScYqHHXCsBKPqkfnz5ysAtf6NGTNGKaXUmDFj1KBBg2rV+ctf/qKSk5NVp06d1GuvvabVZlFRkQKgioqKtOpVVlaqWbNmqcrKSsN1qqqq1Nq1a1VVVZUl5e1qQ9ddqoduHTvm3Ewdp7hLHSuJ8W6mjlPcGe90t6qNeI13peLX3SnxbqaOU9wZ73Q3AuOd7la1IXGs+J6V8W5VG3SXFSdOWutm0DnLrddPdA8ePBhKqbDPT506NWSdH374wcJexQ6Xy4X09HTD96nRLW9XG7pI9aC7LHepY6WLXfMRr+6Md7pb1YYuUj3oLsuda11enOgi1YPustyljpUZ4tVdqgfdZblLHStdpO5PnOLulHg3U8eua5UODeoe3Q0Nt9uNdu3aWVberjZ0kepBd1nuUsdKF7vmI17dGe90t6oNXaR60F2WO9e6vDjRRaoH3WW5Sx0rM8Sru1QPustylzpWukjdnzjF3SnxbqaOXdcqHdz13QEn4/P5sHv3bvh8PkvK29WGLlI96C7LXepY6WLXfMSrO+Od7la1oYtUD7rLcudalxcnukj1oLssd6ljZYZ4dZfqQXdZ7lLHShep+xOnuDsl3s3UsetapQMPui1EKYXdu3dHvD1LXcrb1YYuUj3oLstd6ljpYtd8xKs7453uVrWhi1QPusty51qXFye6SPWguyx3qWNlhnh1l+pBd1nuUsdKF6n7E6e4OyXezdSx61qlAw+6CSGEEEIIIYQQQgghhDRoeNBNCCGEEEIIIYQQQgghpEHDg24LcblcyMrK0vq2Up3ydrWhi1QPustylzpWutg1H/Hqzninu1Vt6CLVg+6y3LnW5cWJLlI96C7LXepYmSFe3aV60F2Wu9Sx0kXq/sQp7k6JdzN17LpW6ZBY3x1wMm63G61atbKsvF1t6CLVg+6y3KWOlS52zUe8ujPe6W5VG7pI9aC7LHeudXlxootUD7rLcpc6VmaIV3epHnSX5S51rHSRuj9xirtT4t1MHbuuVTrwE90W4vP5UFhYqPVtpTrl7WpDF6kedJflLnWsdLFrPuLVnfFOd6va0EWqB91luXOty4sTXaR60F2Wu9SxMkO8ukv1oLssd6ljpYvU/YlT3J0S72bq2HWt0oEH3RailEJRUZHWt5XqlLerDV2ketBdlrvUsdLFrvmIV3fGO92takMXqR50l+XOtS4vTnSR6kF3We5Sx8oM8eou1YPustyljpUuUvcnTnF3SrybqWPXtUoHHnQTQgghhBBCCCGEEEIIadDwoJsQQgghhBBCCCGEEEJIg4YH3RbicrmQk5Oj9W2lOuXtakMXqR50l+Uudax0sWs+4tWd8U53q9rQRaoH3WW5c63LixNdpHrQXZa71LEyQ7y6S/Wguyx3qWOli9T9iVPcnRLvZurYda3SIbG+O+Bk3G43cnJyLCtvVxu6SPWguyx3qWOli13zEa/ujHe6W9WGLlI96C7LnWtdXpzoItWD7rLcpY6VGeLVXaoH3WW5Sx0rXaTuT5zi7pR4N1PHrmuVDvxEt4X4fD78+uuvWt9WqlPerjZ0kepBd1nuUsdKF7vmI17dGe90t6oNXaR60F2WO9e6vDjRRaoH3WW5Sx0rM8Sru1QPustylzpWukjdnzjF3SnxbqaOXdcqHXjQbSFKKZSWlmp9W6lOebva0EWqB91luUsdK13smo94dWe8092qNnSR6kF3We5c6/LiRBepHnSX5S51rMwQr+5SPeguy13qWOkidX/iFHenxLuZOnZdq3TgQTchhBBCCCGEEEIIIYSQBg0PugkhhBBCCCGEEEIIIYQ0aHjQbSFutxu5ublwu40Ns255u9rQRaoH3WW5Sx0rXeyaj3h1Z7zT3ao2dJHqQXdZ7lzr8uJEF6kedJflLnWszBCv7lI96C7LXepY6SJ1f+IUd6fEu5k6dl2rdEis7w44GZfLhSZNmlhW3q42dJHqQXe9OrpI9JDobVcdp7gz3q2vo4tEd4neZuo4Zc7N1HGKO9e68fJ2taGLVA+669XRRaKHHd5m2nGKu1QPuuvV0UWih0Rvu+o4xd0p8W6mjl3XKh3kHLk7EJ/Ph59//lnr20p1ytvVhi5SPeguy13qWOli13zEqzvjne5WtaGLVA+6y3LnWpcXJ7pI9aC7LHepY2WGeHWX6kF3We5Sx0oXqfsTp7g7Jd7N1LHrWqUDD7otRCmFyspKrW8r1SlvVxu6SPWguyx3qWOli13zEa/ujHe6W9WGLlI96C7LnWtdXpzoItWD7rLcpY6VGeLVXaoH3WW5Sx0rXaTuT5zi7pR4N1PHrmuVDjzoJoQQQgghhBBCCCGEENKg4UE3IYQQQgghhBBCCCGEkAYND7otxO12o23btlrfVqpT3q42dJHqQXdZ7lLHShe75iNe3RnvdLeqDV2ketBdljvXurw40UWqB91luUsdKzPEq7tUD7rLcpc6VrpI3Z84xd0p8W6mjl3XKh0S67sDTsblciEjI8Oy8na1oYtUD7rLcpc6VrrYNR/x6s54p7tVbegi1YPusty51uXFiS5SPeguy13qWJkhXt2letBdlrvUsdJF6v7EKe5OiXczdey6Vukg58jdgXi9XmzYsAFer9eS8na1oYtUD7rLcpc6VrrYNR/x6s54p7tVbegi1YPusty51uXFiS5SPeguy13qWJkhXt2letBdlrvUsdJF6v7EKe5OiXczdey6VunAg26L8fl8lpa3qw1dpHrQ3Vokekj0tquOU9wZ79bXsboNqXGii1QPuluLVI94dZfobaaOU+bcTB2nuEsdKzPEq7tUD7pbi0QPid521XGKu1Pi3Uwdu65VRuFBNyGEEEIIIYQQQgghhJAGjfZB99tvvx32uYkTJ9apM4QQQgghhBBCCCGEEEKILtoH3VdddRXmzJlT6/EbbrgBb775Zkw65RTcbjfy8vK0vq1Up7xdbegi1YPustyljpUuds1HvLoz3uluVRu6SPWguyx3rnV5caKLVA+6y3KXOlZmiFd3qR50l+Uudax0kbo/cYq7U+LdTB27rlU6aPdk2rRpGDVqFJYsWeJ/7B//+AfeffddzJ8/P6adcwKJiYmWlrerDV2ketDdWiR6SPS2q45T3Bnv1texug2pcaKLVA+6W4tUj3h1l+htpo5T5txMHae4Sx0rM8Sru1QPuluLRA+J3nbVcYq7U+LdTB27rlVG0T7oHjlyJJ599lmcfvrpWLFiBa6++mrMmDED8+fPR/fu3a3oY4PF5/Nh48aNhm/MrlverjZ0kepBd1nuUsdKF7vmI17dGe90t6oNXaR60F2WO9e6vDjRRaoH3WW5Sx0rM8Sru1QPustylzpWukjdnzjF3SnxbqaOXdcqHUwdu1944YXYt28fBg4ciObNm2PhwoXo0qVLrPtGCCGEEEIIIYQQQgghhETF0EH3jTfeGPLx5s2bo0+fPnj22Wf9jz3++OOx6RkhhBBCCCGEEEIIIYQQYgBDB90//PBDyMe7dOmC4uJi//Mulyt2PSOEEEIIIYQQQgghhBBCDGDooJtfMmkOt9uN/Px8rW8r1SlvVxu6SPWguyx3qWOli13zEa/ujHe6W9WGLlI96C7LnWtdXpzoItWD7rLcpY6VGeLVXaoH3WW5Sx0rXaTuT5zi7pR4N1PHrmuVDnJ64lCqqqosLW9XG7pI9aC7tUj0kOhtVx2nuDPera9jdRtS40QXqR50txapHvHqLtHbTB2nzLmZOk5xlzpWZohXd6kedLcWiR4Sve2q4xR3p8S7mTp2XauMon3QXVpairvuugsDBgxAly5d0KlTp6B/5BA+nw8FBQVa31aqU96uNnSR6kF3We5Sx0oXu+YjXt0Z73S3qg1dpHrQXZY717q8ONFFqgfdZblLHSszxKu7VA+6y3KXOla6SN2fOMXdKfFupo5d1yodDN26JJDx48dj4cKFuPjii9GqVSvel5sQQgghhBBCCCGEEEJIvaJ90D1nzhx8+umnGDhwoBX9IYQQQgghhBBCCCGEEEK00L51SdOmTZGdnW1FXxyJ7g3ZzdzA3Y42dJHqQXdrkegh0duuOk5xZ7xbX8fqNqTGiS5SPehuLVI94tVdoreZOk6ZczN1nOIudazMEK/uUj3obi0SPSR621XHKe5OiXczdSR9ESUAuJRSSqfCm2++iQ8//BCvv/460tLSrOqXZRQXFyMrKwtFRUXIzMw0XM/j8WD27NkYMWIEkpKSLOyhPOLVPV69AbrTPb7c49UboDvd48s9Xr0ButM9vtzj1Rugezy6x6s3QHe6x5d7vHpXo3OWq33s/thjj+Gzzz5Dy5YtccQRR6BPnz5B/8ghlFLYv38/jP4uQbe8XW3oItWD7rLcpY6VLnbNR7y6M97pblUbukj1oLssd651eXGii1QPustylzpWZohXd6kedJflLnWsdJG6P3GKu1Pi3Uwdu65VOmgfdJ955pm46aabcPPNN+Pcc8/FGWecEfSPHMLn82Hbtm1a31aqU96uNnSR6kF3We5Sx0oXu+YjXt0Z73S3qg1dpHrQXZY717q8ONFFqgfdZblLHSszxKu7VA+6y3KXOla6SN2fOMXdKfFupo5d1yodtL+M8p577rGiH4QQQgghhBBCCCGEEEKIKWTdMZwQQgghhBBCCCGEEEII0UT7E91erxdPPPEE3n33XWzduhWVlZVBz+/duzdmnWvouFwuJCcnw+VyWVLerjZ0kepBd1nuUsdKF7vmI17dGe90t6oNXaR60F2WO9e6vDjRRaoH3WW5Sx0rM8Sru1QPustylzpWukjdnzjF3SnxbqaOXdcqHbQPuu+99168/PLLuOmmm3DnnXfin//8J7Zs2YJZs2bh7rvvtqKPDRa3241OnTpZVt6uNnSR6kF3We5Sx0oXu+YjXt0Z73S3qg1dpHrQXZY717q8ONFFqgfdZblLHSszxKu7VA+6y3KXOla6SN2fOMXdKfFupo5d1yodtG9dMm3aNLz00ku46aabkJiYiFGjRuHll1/G3Xffja+//tqKPjZYlFLYt2+f1reV6pS3qw1dpHrQXZa71LHSxa75iFd3xjvdrWpDF6kedJflzrUuL050kepBd1nuUsfKDPHqLtWD7rLcpY6VLlL3J05xd0q8m6lj17VKB+2D7p07d+KII44AAGRkZKCoqAgA8Ne//hWffvppbHvXwPH5fNi5c6fWt5XqlLerDV2ketBdlrvUsdLFrvmIV3fGO92takMXqR50l+XOtS4vTnSR6kF3We5Sx8oM8eou1YPustyljpUuUvcnTnF3SrybqWPXtUoH7VuXtG3bFoWFhWjfvj06d+6Mzz//HH369MG3336LlJQUK/oYc1xJKSir9CKxsqrWc26XC42SEvw/l/1ZxuOpQoX34M9JyhWxbDVerxflHt/BOokIKnug0gsFFbL8gUovMlIjl63G5w0OpnKPF74Iv0lJSXAZLpuWfCg8PL5g90hlKzyHvBMSar9+alKC//49FVVeeH0qaKwC64QqCyBk+UaJCXC7D5atrPKhqsZCC6yTnuKOWBY4NOden0LSn4+FK1tNYsDweLw+eLzhyyYnuJGYcPB3TVU+FXa8apX1+iKOb1KCG0kBZSu9vrDjG1jW61OoqPIGuQfOeaLbjeTE2mWrCWwjJcnlL+vzKZTXKBtYvrLKh9SEhIhl/QTEq1IKBzzhyya4Xf75UErVWp+B1FzLNd0jlS2rrAo7H+FyRKj5qFm25roPrJOYAKQmm8snkda9xxM8Rlblk8qq8PEL1Fz3keNdJ5+EyxGh4l0nn6SluJEQJZ9Ul/f6FP4M96g5IiFgTnXyiTdKPqmZIyLFe6gcEW58w+WIUOUDy4Za92bzSUWVD2l/DnC0HBF4/YxW1u1yISngowE6+SRS/NYln1Sv+1Dj64IrYo4IjPlk5Q4qG2otB7bR2GA+8XqDxzOW+SRw3Vd6I8d7zXwSKd5DrXvdfBKqfEpiQsQcES6fRFr3Xu+hPVG0sgDgCmizem8Qjprr3mg+8fpUxHgPlSOM5JPAdW8mnwTGeyOXGymJkXOEmXyCGnMaLUfYkU8OVHpRGeL6BoTPEUbySc31WbNO4PW+vvJJYkC+C3z/EAqdfFJz3UeaD518Ei5HRMsnodZ9YLynuxP8ewOdfBItR7hhvKxOPqmZI4zmk+p1H2o/F65stXfNNhLcrog5IrBOchKM5xOP159PgMjrXjefJGiUDconEfbjoXJElTf0HiVcjggX75FyhG4+CZzzrKSkiGUD2wj85Gm0HJEckK+jlQ1c954Y5pNQOSJcvIfLEaHmI/D9Q6gcEVgnNdkVdB4Rbt17vV5Umcwnoc4YAglayyry+VStda+ZT8LFb7gcUdd8UvO8MNRarp7zCo8XSQHxHmndK818UnMf4Q4Tv7XWvUY+0Tk3CCxbVhlhH1YD7YPus846C/PmzUO/fv3wj3/8AxdddBFeeeUVbN26FTfccIPuy9UL7W/8AMc+uizkcyd2a47XLjnG//NR938REJCJuOWbL/3P9cvLxjtX9Pf/fNxD87G3NPjLOQ9SgCPbZuGja47zP3LK4wuxfd+BkH3Ib/E75t44yP/z6U8vwcbf9ocs26ZJI7xyZhv/z+e/8BVWbSsKWTY7PRnf3nGS/+cxr36D5QWhvzw0NSkBa+8f7v/51fVu3Lz8y5BlAWDLlJH+/7/p/VWY89MuAAUhy665b5g/eO+Y8RM++H5bwLPBdVbceQqaZRz8BcoDn6zFG1//UuPVDpVffMuJaJedBgB49PP1eHHRz2F6W4DPbzgBXVs2BgA8M38Tnpy3MUzZRHTuXYyj8nIAAK8tLcDkOevClAWmXXo0mv35/29/sxV3f7g6bNlXx/bFSd1bAgC+3FyCx//7Rdiyz1zYByOPbAUA+HzNb/jH9AKEG99Hzj0S5/VtBwBYtPF3jJv6XcCzwXXuO6Mn/t6/IwDgm4K9GPVS4O2HguP99lO744pBnQEAP20vwhnPLA3T2wJcd3I+bhjSFQCw6ff9GPrEorBu449TuPOvPQEA2/cdwPEPzw9b9qJ+7XFRj4NJfW9pJY56IPyYndOnLR4+53AAwAGPF0fcG77siCNy8ezoo/w/3/JNsHsgNXPEMQ/O/zNH1J6P6DniUB3jOaIA+S0yNHJEIZbedrL/50g5omlaEib1OvRztBzx06Qh/p+venMF5q//PWRZIDhHPLz4Nyx5M3T8AsE54s5ZP2HGDzsQLt4j54jgOpFzRPCcG88RBfhwwkD0atcEgJEckYOB+S0ARM8RL1/cB23/3BPM+mE7Jr6/KmzZwByxdGspRkbIJ4E5YvGmPRHjPXKOCB7f6DniUHnjOaIAl5/QCXeM6AHASI7w4oGzDv7VWbQccVbv1hjc6OD/H/B4cdjdn4UtO+KIXDz1t7/4f45UtmaOuOCdLaioCh2/NXPEoEcWYm+ZB6HiPXqOOFTHWI44OO9tmqRi6W2H9gYR9xFp2/D93UP9P0fLETNHd/T/HC1HbP7XoT3Hje+uxOwfd4YtG5gj/rPsd3zxRrjrfXCOmDxnPaZFiPfIOSJ4TqLniEPljeeIArx92bHo3/ngTiJajrj35Fx073bw/6PliP9ccKT//z9bvQsT3vo+bNnAHPHd9rKI+SQwR3y7ZS9GTwu/P4mcI4LrRM8Rh8obyxEH5/3iYzvg/jMP7g2i5Yize1fg8Qt6A4ieI049vCWu65vh/zlajnj574f2HMHvNYKpmSPGvP8LiipCj2/4HFE75qPniENtGM8RBchOT8b3dx3aG0TOEVuD3mtEyxH/G9vZ///RcsT/3XWov7XfawQTmCNe/HY3PomQTwJzxGNzN+DlJVsQLt4j54jgOtFzxKHyxnLEwTkPfK8RLUfcMbilP59EyxEPnXM4eh1UC/FeI5jAHPHTrvKI+SQwR6zeUYyzIuST8DmidrxHzxGH2jCeIwpwTp+2eOz8gxvn6DmiDM9d1Nf/c6Syg7s2x20DMv0/R8sRb4479LrhzyNq54jLZ/6K30pDj2/kHBFcJ3qOOFTeeI4oqHUeET5HHJzzwPca0XLErNF5/v+PliO+CTg/CX0ecYjAHDH1+z34IEI+CcwRzy3cjP98GT7ew+eI2vEePUccasN4jigIeq8RLUfcOLA5evyZT6LliEmn9cCxfx6g1H6vEUxgjvi1FOh1f/jzqZo54swI+SRyjgiuEz1HHCpvPEcU1DqPCF82EZ/u+z+8Pq6f/5HIOaIp7h2U7f9ZJ0cMe3Ixtu8rD1m2Zo649pNt2Lov9PhqvdfQ2EdEQvuge8qUKf7/v+CCC9ChQwcsW7YM+fn5OO2007Q7QOqKC+np6VrfiKpT3myf4hUz4+tyubT+GkLQl9nGBN1YlBfv0rH2W5zNxHtiovFLj9PmTsvH5Pg2aiB/XdXQMBvvzopgPazO1y6XC4lJ2ltZx9CoUSNLc6TL5UKjRo20yjsJPR/r9+Mul8t5m0ANrN7PuVwuJCUmRS8YUN5JNEpJMR6/mvEOHByv1FTj+cR5F0+d/Z898V79aeJ4JE0nX0N/PlwuV9Anbo214hxSNPKJ7vXTDE7L13qYy9fp6ekwGpculwtul/ZdsS3FpWJ4x/DvvvsOffv2jV6wHikuLkaTnBbYsaMQmZmNaz0f/tYlHnz22ecYNmyoP2lFu3VJpNeNdDuSaH9yHKms2T8DiFTW4/Hgw09mY8jQoWETts7rhrsdSV3LRrvVgG7Z6jk/feSpaJSSbOh1o/05YSDR/lQoXFmdPxHU/XPCQ7cuqR3v0W5dEki0PyM2Wzban/+YLRu4Pj0eD2Z+PDvIPVxZQG/dS88RHo8HC774HCNGjEBSUpIl+cRIWbtzRKh418kn0W5LEK6shBxxoLwCH8/+X9h4D5cjQtHQcoTP68W8z/+HESNGIDEx0XCOAKxb93bliMCYT05KtnwfEeuyZnPE/gMVmD0nfLzHeh9RjYQc4fJ58flnB+Pd5U6wfB8RivrKEYHx3igl2fJ9BCAnR1R6Kmtd3wB57zViXTYRPsyZMwcjRoyAz+UW+16jmljmiMB4T2+UIva9RijqmiNC7efClQ2HHe81gNiu+wT4MHv2bIwYMQKeMLdxCPW6Dek8IlzZwDnPSk81/LoN5TyimtC3Lgkd79Lea1iRIzweDz75dDZOGhL+fErCe41Y54jqOR8xfBgy0hpFLKvzuuHKSssRxcUlaNU8G0VFRcjMzAxXHYCJT3Tv378fCQkJSE09lEhWrlyJu+66C7Nnz651DzWJKE8F0pITggYwHP7DXpdCSsLBn5PCfHqo5uv5fD7s3bsX2dnZcLuDf8MRONGhykcrG1hn9+7d/jYCAzNc+eo2opUNJMkd2T2Q5AQX9u79I6R3TaoXfqSxqlnWSPnkRDeSa3zXanAdV8SywKE5TzBQNrCN3bv3IDs7OyhpR8Ln86Hoj8jugbhdQFnxPkPlE/+8IBkZ3wS3y3C8B5YN9AjVhjtE2Zrlo5UNrBMY79HWcGAbRtZ7NdHWeiCNEt1Rx7aa6j4YmY+a6z5W+STSuve4gi84VuQTn8+H/UXG8gMAJLldKNkX+3wSuJajxXss8kl1+UbZ2aj+7Xi0HBEY7zr5ZJ9GPklMcBuO9+p1r5tPopUPte5jkU9crsj5xONRhsvWbMNoPvH5fIbzNaCXT6rXvZl8Ehzzwc+FWstm8okd+xOfz2c4PwBASqLxeK9ey7r5JJb7k0jrvmY70XJEYLwnBrxZjYRuPnFBGY53nXzirmM+CYr3gL1kuHVvJp/YsT/RzSepyQlIdCUainmdfFJzfUaqU1/5xOPx+P8/8P1DJHTzSaIbKN5nbD6syieh1n1gvAeuc518Ei1HBM6HTj75w+D1DdDLJ9Xr3sj7dZ18Emrdh6ujk0+A2ucGNevo5BOP59Ahok4+KS02Hu+pyQmG4hc4tJbtyCeBcx6tbGAbe/bs8bcRLUcEltfJJ8X7NPbjJvKJkXgPXPdm8km4OpHWfV3ySYKBeK/G7TL+fh0m8omR+A1c97HMJ0DotVw95yk14juW+aR2v6LHvG4+0TmHDCxbFeFctCaGP1/+66+/on///sjKykJWVhZuvPFGlJWV4e9//zv69euH9PR0LFsW+r7X8YpSCrt374bRD83rlrerDV2ketBdlrvUsdLFrvmIV3fGO92takMXqR50l+XOtS4vTnSR6kF3We5Sx8oM8eou1YPustyljpUuUvcnTnF3SrybqWPXtUoHwx9xnDhxIsrLy/Hkk09ixowZePLJJ7F48WL069cPmzdvRtu2ba3sJyGEEEIIIYQQQgghhBASEsMH3YsWLcKMGTNw7LHH4vzzz0dubi5Gjx6N66+/3sLuEUIIIYQQQgghhBBCCCGRMXzrkl27diEvLw8A0KJFC6SlpeHUU0+1rGNOwOVyISsrS+sb2HXK29WGLlI96C7LXepY6WLXfMSrO+Od7la1oYtUD7rLcudalxcnukj1oLssd6ljZYZ4dZfqQXdZ7lLHShep+xOnuDsl3s3UsetapYPWl1EGfyGUG8nJyTHvkJNwu91o1aqVZeXtakMXqR50l+Uudax0sWs+4tWd8U53q9rQRaoH3WW5c63LixNdpHrQXZa71LEyQ7y6S/Wguyx3qWOli9T9iVPcnRLvZurYda3SwfAnupVS6Nq1K7Kzs5GdnY39+/ejd+/e/p+r/5FD+Hw+FBYWwufzRS9sorxdbegi1YPustyljpUuds1HvLoz3uluVRu6SPWguyx3rnV5caKLVA+6y3KXOlZmiFd3qR50l+Uudax0kbo/cYq7U+LdTB27rlU6GD7ofu211/Dvf/8bTzzxBJ544gm89tprePLJJ/0/V/8jh1BKoaioSOvbSnXK29WGLlI96C7LXepY6WLXfMSrO+Od7la1oYtUD7rLcudalxcnukj1oLssd6ljZYZ4dZfqQXdZ7lLHShep+xOnuDsl3s3UsetapYPhW5eMGTPGyn4QQgghhBBCCCGEEEIIIaYw/IluQgghhBBCCCGEEEIIIUQiPOi2EJfLhZycHK1vK9Upb1cbukj1oLssd6ljpYtd8xGv7ox3ulvVhi5SPeguy51rXV6c6CLVg+6y3KWOlRni1V2qB91luUsdK12k7k+c4u6UeDdTx65rlQ6Gb11C9HG73cjJybGsvF1t6CLVg+6y3KWOlS52zUe8ujPe6W5VG7pI9aC7LHeudXlxootUD7rLcpc6VmaIV3epHnSX5S51rHSRuj9xirtT4t1MHbuuVTrwE90W4vP58Ouvv2p9W6lOebva0EWqB91luUsdK13smo94dWe8092qNnSR6kF3We5c6/LiRBepHnSX5S51rMwQr+5SPeguy13qWOkidX/iFHenxLuZOnZdq3QwfdC9e/du7N69O5Z9cRxKKZSWlmp9W6lOebva0EWqB91luUsdK13smo94dWe8092qNnSR6kF3We5c6/LiRBepHnSX5S51rMwQr+5SPeguy13qWOkidX/iFHenxLuZOnZdq3TQOujet28fJkyYgJycHLRs2RItW7ZETk4OrrnmGuzbt8+iLhJCCCGEEEIIIYQQQggh4TF8j+69e/eif//+2L59O0aPHo0ePXoAANasWYOpU6di3rx5WLZsGZo2bWq48UWLFuGRRx7BihUrUFhYiJkzZ+LMM88MW37BggU48cQTaz1eWFiI3Nxcw+1aTXnZAayY8Rl+n78I3t92YV2Llmh+4gk46uxhaJSWWufydvTJrjZEj9WXi1BRuB2ffrgQzU+KrYdd7qbbsNDdDg8zmHG3Azvc7UDiWjeD1Fxqug1h8a6L1PmQmhd1511qvnYKUsdKavxajVPySVAd5ngRbdhBPM+5RHfu5fSQuA6l5h879nJ2uEh1lzjvTjqfsguXMvj58uuvvx7z5s3DF198gZYtWwY9t3PnTgwdOhQnn3wynnjiCcONz5kzB0uXLsVRRx2Fs88+2/BB9/r165GZmel/vEWLFnC7jX04vbi4GFlZWSgqKgp6jWh4PB7Mnj0bI0aMQFJSUthy5WUHMPfOR5C4cgWU242q5BQkVlbA5fOh6i9HYcgDE4MmXbd8TZRSKCoqQlZWVthvOa1rG0bczbQhfax8bjcOwIVUKLhj6GGXe13asMrdDg/dOTfrrttGXftllXsgRvOc1R52rHUz3nbHoqQ8Z8bFbHkzHvF2batrHSPzLjVf16WObo4z04aktR6IpH2sxGub1P24HWtd16OudexYI5Ku63WpY8c+1sp+6dZxSrw7cS9npo6kta7br4ZwTbBqL6frYaYdqe4S3+s56Xyqruic5Rq+dcmsWbPw6KOP1jrkBoDc3Fw8/PDDmDlzplZHTz31VDzwwAM466yztOq1aNECubm5/n9GD7ntYMWMz5C4cgUqs3PgadUWqllzeFq1RWXTZkj8vxVYMeOzOpWvicvlQpMmTSIuprq2YYW3mTq2j1VuG5RnZMKT2yamHna516kNi9zt8AjEyJybdddto879ssi9LljlYcdaN4PtsSgoz5lxMVvelEecXdvqXMfAvEvN13Wto4tV8e6UPNcQ4sQKbzP9krrWdT3qWseuNWIE6TnLjn2slf3SreOUeHfiXs5MHUlrXbdfDeKaYNFeTtfDTDtS3SW+13PS+ZSdGD4hLiwsRM+ePcM+f/jhh2Pnzp0x6VQ0/vKXv6BVq1YYMmQIli5dGrFsRUUFiouLg/4BB3/7p/vPSL3fv1wEn9sN1SgVSilUVlZCKQWVmgblcuH3LxfVqXzNfxUVFdi4cSMqKipi1icz7mbaED9WOPjHDgqx9bDLvU5tWORuh4funJt1122jzv2yyF13rdvhYcdaN+NteywKynN1GV+r1kg8X9vqXMfAvEvN13Wto7sHtCrenZLnGkKcGHGXuh+3Y63XdXylrhEp13XbxyrOrusS492Jeznb4teitS5+DgXt5eyYQ6nuEt/rOel8Khb/jGL4Ht05OTnYsmUL2rZtG/L5goICZGdnG27YDK1atcLzzz+Pvn37oqKiAi+//DIGDx6M5cuXo0+fPiHrTJ48Gffee2+txz///HOkpaVp92Hu3LkRn68o3I4quFC+f/+hxyoqAACN4Ia3cDtmz55tunw41qxZE7M+hSOSu5k2GspYle4vjamHXe6xaCPW7nZ4hCLSnJt1120jVv2KtXsoouU53TYkrvVQxDq/m+mT1Dyn20YsykerE8/XtljViTTvUvN1LOro5jgzbUhY66GQsI+VeG2Tuh+3Y63resSqjh1rRMJ1PRZ17NjHWtEv3TpOiXcn7+XM1JGw1nX71ZCuCbHey+l6mGlHqrvE93pOOp+qK2VlZYbLGj7oHjZsGP75z39i7ty5SE5ODnquoqICd911F4YPH268lybo1q0bunXr5v95wIAB2Lx5M5544gm88cYbIevcfvvtuPHGG/0/FxcXo127dhg6dKj2Pbrnzp2LIUOGRLz/06cfLkTS1gIkZmQAUKis9CA5OQmAC8n796GyVRuMGDHCdPmaeL1ebN68GZ07d0ZCQkJM+mTG3Uwb0sdKQaF0fynSM9LhiqGHXe51acMqdzs8dOfcrLtuG3Xtl1XugRjNc1Z72LHWzXjbHYuS8pwZF7PlzXjE27WtrnWMzLvUfF2XOro5zkwbktZ6IJL2sRKvbVL343asdV2PutaxY41Iuq7XpY4d+1gr+6Vbxynx7sS9nJk6kta6br8awjXBqr2croeZdqS6S3yv56TzqbpSfXcOIxg+6L7vvvvQt29f5OfnY8KECejevTuUUli7di2effZZVFRUhD1stpJjjjkGS5YsCft8SkoKUlJSaj2elJRkOBnq1Gt+0gkofnUzXAfKoNLSABcAlwuusjK4lELzk04Iqq9bviZutxsJCQlISkoKu6Dq2oYRdzNtSB8rpB78xL8LLrgOxM7DLve6tGGVux0eunNu1l23jbr2yyr3UBjNj1Z52LHWzXjbHYuS8pwZF7PlzXjE27WtrnWMzLvUfF3XOoDeHtCqeHdKnmsIcWLEXep+3I61rutR1zp2rRFAxnW9LnXs2Mda2S/dOk6Jdyfu5czUkbTWdfvVEK4JVu3ldD3MtCPVXeJ7PSedT9UVndczfNDdtm1bfPXVV7j66qtx++23Q6mD94dxuVwYMmQInn76abRr106/t3Vk5cqVaNWqle3thuOos4dh7verkPx/K6CK/4A7KQWJnj+/fbTXUTjq7GF1Kl8Tt9uNtm3bRvxCzrq2YYW3mTq2j1XRXjSCG8n798GlVMw87HKvUxsWudvhEYiROTfrrttGnftlkXtdsMrDjrVuBttjUVCeM+Nitrwpjzi7ttW5joF5l5qv61pHF6vi3Sl5riHEiRXeZvolda3retS1jl1rxAjSc5Yd+1gr+6Vbxynx7sS9nJk6kta6br8axDXBor2croeZdqS6S3yv56TzKTtxqeoTaw3++OMPbNy4EQDQpUsX0/fm3r9/PzZt2gQA6N27Nx5//HGceOKJyM7ORvv27XH77bdj+/bt+O9//wsA+Pe//428vDz07NkT5eXlePnll/HUU0/h888/x8knn2yozeLiYmRlZaGoqEj71iWzZ8/GiBEjov4mobzsAFbM+Ay75y+G6489UE2bIefE43HU2cPQKC21zuXNUJc2jLqbaUPyWP3+5SJUFG5HSqs2aH7SCTH1sMvdbBtWutvhYQYz7nZgh3s1OnlOF4lrvRor87sZ4jnedYnna1td6hidd6n52ixW5jgzOCXPSY8TK9e6LlLXulTMzom067odxPOcS3TnXk4PO9a6XX2yug079nJ2uEh1lzjvTjqfqgtaZ7mqHpk/f74CUOvfmDFjlFJKjRkzRg0aNMhf/qGHHlKdO3dWjRo1UtnZ2Wrw4MHqyy+/1GqzqKhIAVBFRUVa9SorK9WsWbNUZWWl4TpVVVVq/fr1qqqqypLydrWh6y7VQ7eOHXNupo5T3KWOlcR4N1PHKe6Md7pb1Ua8xrtS8evulHg3U8cp7ox3uhuB8U53q9qQOFZ8z8p4t6oNusuKEyetdTPonOUavnXJuHHjDJV79dVXjb4kBg8e7L8FSiimTp0a9PMtt9yCW265xfDrS8Dn81la3q42dJHqQXdrkegh0duuOk5xZ7xbX8fqNqTGiS5SPehuLVI94tVdoreZOk6ZczN1nOIudazMEK/uUj3obi0SPSR621XHKe5OiXczdey6VhnF8EH31KlT0aFDB/Tu3Tvi4TQhhBBCCCGEEEIIIYQQYieGD7qvuuoqvP322ygoKMAll1yCiy66yPS9uQkhhBBCCCGEEEIIIYSQWGH4a3afeeYZFBYW4pZbbsHHH3+Mdu3a4fzzz8dnn33GT3iHwe12Iy8vT+ubiXXK29WGLlI96C7LXepY6WLXfMSrO+Od7la1oYtUD7rLcudalxcnukj1oLssd6ljZYZ4dZfqQXdZ7lLHShep+xOnuDsl3s3UsetapYNWT1JSUjBq1CjMnTsXa9asQc+ePXH11VejY8eO2L9/v1V9bNAkJhr+0Lyp8na1oYtUD7pbi0QPid521XGKO+Pd+jpWtyE1TnSR6kF3a5HqEa/uEr3N1HHKnJup4xR3qWNlhnh1l+pBd2uR6CHR2646TnF3SrybqWPXtcoopo/c3W43XC4XlFLwer2x7JNj8Pl82Lhxo+Ebs+uWt6sNXaR60F2Wu9Sx0sWu+YhXd8Y73a1qQxepHnSX5c61Li9OdJHqQXdZ7lLHygzx6i7Vg+6y3KWOlS5S9ydOcXdKvJupY9e1Sgetg+6Kigq8/fbbGDJkCLp27Yoff/wRTz/9NLZu3YqMjAyr+kgIIYQQQgghhBBCCCGEhMXw58uvvvpqTJ8+He3atcO4cePw9ttvIycnx8q+EUIIIYQQQgghhBBCCCFRMXzQ/fzzz6N9+/bo1KkTFi5ciIULF4YsN2PGjJh1jhBCCCGEEEIIIYQQQgiJhuGD7r///e9wuVxW9sVxuN1u5Ofna31bqU55u9rQRaoH3WW5Sx0rXeyaj3h1Z7zT3ao2dJHqQXdZ7lzr8uJEF6kedJflLnWszBCv7lI96C7LXepY6SJ1f+IUd6fEu5k6dl2rdDB80D116lQLu+FcqqqqkJycbFl5u9rQRaoH3WW5Sx0rXeyaj3h1Z7zT3ao2dJHqQXdZ7lzr8uJEF6kedJflLnWszBCv7lI96C7LXepY6SJ1f+IUd6fEu5k6dl2rjCLnyN2B+Hw+FBQUaH1bqU55u9rQRaoH3WW5Sx0rXeyaj3h1Z7zT3ao2dJHqQXdZ7lzr8uJEF6kedJflLnWszBCv7lI96C7LXepY6SJ1f+IUd6fEu5k6dl2rdDD8ie6zzz7bUDneo5sQQgghhBBCCCGEEEKInRg+6M7KyrKyH4QQQgghhBBCCCGEEEKIKQwfdL/22mtW9sNWUl0u+A4cgC8xhH5CAtwpKf4ffWVlB//r8cBVWQlfWRl8SUkHn3S74W7UqFZZ/89er7+OKykpuOyBA4BSocsfOICEjIyIZf3P+XxBN333lZcDkf5kICXFXz5aWXdamv//XR5PsHuEsr6KikPeCQm1yrpSU/1fbOqrrASqqoLHKqBOqLIAQpZ3NWoE159uqrIS6s+y/n4F1HGnp0csCxyac+X1An96hytbjUpM9I+v8nigPJ6wZV3JyXD9GYMuny/seNUsq6qqIo9vUhJc1f2tqoKqrAw/voFlvV6oioog98A5dyUmwvXnfZcCy/rHK3B8U1IOlfX5oMrLa/Wzuryq9ACpCRHL+uu4XIfGVymoAwfClkVi4sH17HZDKVVrfQZRY93XWusRyvrKysLPR5gcEXI+apatse6D6iQmwp2aGrZsUPma+STCuvfViFetfFJRAXi9YYsG5ZOqqsjxXmPdxyyfhMkRIeNdJ5+kpfnbCZtPquPd6wWqy0bJEerP+DVSNiif/BnvYce3Ro6IFO+hckTY8Q2TI0Lm68CyIda92Xziq6xEwp9rI1qOUAFrJmo+SUgAAvK7mXwScj5C5AjD+eTPdR9yPlyuiDkiKOaTk4PLhlj3gW0kNG4csWxgnaD9SZQcoZNPAte9y+s1nE9UQD4JGe8h1r12PgkV7ykpEXNE2HwSYd37vF64AmM4Wj4J+EL56r1BOALXvVY+CTNW/rIhcoShfBKw7k3lk8B4T02Fu7psmHVvJp/4gOB4j5IjDOeTGuteK58cOBB0DQ2K+TA5wlA+qbHua9YJek+gk08irHvdfKIC3uMFvn8IhVY+CVr3nsjxrpNPwuSIqPkkxLoPjHeVnn7o/YNOPomSI5TbfWh/Est8UiNHGM4nf677kO/Xw5T1e9dsIzExYo4IqpOSYjyfVFQgIXBtRFj3WvnE7fbvK42UDconf76/DzkfIXKEL9x70DA5Ily8R8oREfNJiHUfOOcI+GBmtHziCrgmRssRKjn5UL6Olk8C1n1M80mIHBE23sPkiJD5JPCMIVQ+CdyfpKYGnUeEW/c+rxeugDnVyichzhiCxiFgLePP85Nw51M11712PgmXg8LkiDrnk+TkkOeQQeWr57yiwn8+Fa6s/zmltPJJdY5wu93wHTjgj9Fa1Fj3WvlE4xwysKwv0nu1mk0qFeYENQRbtmzB3LlzUVlZicGDB6Nnz56GG5JCcXExth/TL+zz6YNOQPsXXvD/vK53n7Ab27Sjj0aHN/7r/3lD/wHw/vFHyLKNDj8cee+/5/9500knw7NjR8iyyV06o/Mnn/h/3vzXv6Jy0+aQZZNat0aXL+f5fy449zyU//RTyLIJTZui61fL/D//cvHfUfbttyHLulJT0f2H7wEAHo8HK887Dxnr1ocsCwA91q31//+2665HyWefhS3b7fsV/uDdcdvtKJo1K2zZ/GVLkZidDQDYed99+OOtt8OW7fzFF0hu2wYAsOvhR7D31VfDlu308UdIyc8HAPz+1NPY/cwzYcu2ffstNO7dGwCw55VX8Nsjj4Yt2/7115He7xgAwN5p07Dr/gfCv+7zz6Hx4MEAgH0zZqLwjjvClm3z7yeQOXw4AKD4f//D9utvCFu21YMPosnZZwEAShYswLYrrwpbtuVddyJ79GgAQOnyb7B1zJiwZVtMvBnNLr0UAHDgxx+x5bzzw5bNmTABzf9xDQCgYuNG/Hza6WHLZo8bh5a3TAQAVG7bjs2nnBK2bNMLRyH37rsBAFV792LjgIFhy2adeSZaT5kM4GBCX9/nqLBlGw8bhrZP/hvAwXjfdMSRYcs6OUe4mzbFuttuxYgRI5CUlGQ4RwDA1iuuQOnCRSHLAs7OER3fexepRxwBoOHliH3z5qFwwjVhyzo5RzQ+/XSsGDgAI0aMQILHYzhHAMDa7j3ClnVyjjC7jwBk5Igd90xC0TvvhC3r5ByR++ijWOStwogRI3Bg3jzuI2DdPgJgjqimvnJEp+Vf438LFmDEiBH4/a67uY8A32s4OUe0fvUVzJ49GyNGjEDBCYOYI8D3Gk7PER6PB/NeeAEdng4/Zk7OEWnHH48OL73o/zme9hGHrV+HoqIiZGZmhqxfjeEvo5w/fz569uyJK664Av/4xz/Qu3dvvPnmm0arEx0M/+rhYNH9+/fD6O8rlFJa5c1h5WvLRkF/fJVSqKgI/ynmUOWdhc5YSYx32Vi60k2Mr1IKVRE+CVGrvJmOCUZpJngz41se4a8inI6VS91svFvaKeFYna+VUvBUhf8Us9MpLy+39Pqmm0+08lsDQM9GL37Nxns872es3s8ppeCJ8FcRIWpY1pf6QCefmH2/c0Dj03jOi3Vr93/avVEKPseNsXH2l5Zavz/xhP8Uc63yDssnFRUa+xOb4j1e0T0vBAJiXqO8pC+iBDQ+0X3cccchJycHzz33HBo1aoQ777wTM2fOxI4wJ/xSKS4uRm6TJthRWIjMgD+X8xPm1iUejwefff45hg0diiSDty7xer3YtHkzunTujAQDty7xl+/SBUkGb13i9fmweds25OfnIyEhIeqfAaiUFGzcuBH5+flweTyG/mTA4/FgzocfYtiQIYfcw5QFAE9ZGTZt2HDQ2+CtBoLGysCtS0KVj3argcA6iQZuXVI958NPOw3Jf85dtFuX+BITsennn5Gfnw+3z2foVgNerxcb1q5Flw4dQo5XYFkAqKqowMa1a8OPb4hbl4Qd3zC3LgkV79FuXRI0vgZuNVBdPr9bdySmNopY1l/H5cLmX345OL5ud9Rbl6iEBGzcuBFdunSBO8KfTAWue4/HgzmzZgWv9TBlAcBTUhJybAGEzREh5yPKrUuC6hi4dUnYfBIhR3g8Hv8noJKSkvTySVWVoVuXeL1ebFi9Gl3y8sLHe8C69xw4gE3r18cmn4TJESHjXSefGLh1iT/eDzsMidVrI8qtBnwJCdhUUKCfT9atQ5f27cOPb8C6rzxwAP/75JOw8R4qR4Qd3zA5ImS+jnKrAbP5pEu3bkgyeKuBKqUw54svMGLECCQmJka9dYlKTDwU7xH+rDIwR3i9Xmz48cew8Vtz3Wvlkz/Xfcj5iHLrkqCYN3DrksA2kgzeusTr9WLz9u2H9ifRbjWgkU+q173X68WGNWvQpWNHQ/mksrQU/5s9O3y8h1j3uvkkZLxHuXVJ2HwSIUd4vV5s2roVXbt3R0JCQtR8UuVyYc7nnx+Md5fL0K0GdPNJVWUlNq5ZEz5fh8gRhvJJwLo3k0+C4t3ArUvM5BMvgM1btx6K9yi3LjGcTwLWvW4+8R04AE9lZe33L0DYHGEon9RY9zXrRLt1Sdh8EiFH6OaTqsREzJkz5+Bf7Chl6NYlhvJJwLqvOlCOjevXhY93nXwSJkdEzSch1n1gvCcbvHVJrXwS5VYDPrcbm7ZsObg/USp2+SRgLWvlkz/Xfcj362HK+r1rzkeUWw0E1TFw6xJ/+a5dkWTw1iVa+cTthjchwf+J7oRIv6ypmU9++gldOnUKPR8hcoS3qir0HiVMjggX75FyRMR8EmLdB855isFbl3i9Xmzatg1du3Y9OL5RbkfiS07Gpk2bDuZrr9fQrUtink9C5Iiw8R4mR4TMJ1FuXRK0PzF46xKv14tNv/yCrj166OcTwNCtSzweD2Z/8gmGn3RS2POpoHzi8WDj6tVa+SRc/IbLEXXOJwZuXeKf81NPRUrg+/tI+UQpbP71V8P5xN2oEbxeLzZu3IjObdsiwcCtS7TziclblxSXlKBpbq6hT3Qbvkf3Tz/9hGXLlqFVq1YAgEceeQQvvPAC9uzZg2bNmhl9GREcUAru1NSgAQxHdRm3x3Pw/kxpaXAbOOwF/ry3WKNGB+vUmPDAia5VvsZzocoG1gkqG7DBDYU3oHy0skHtJCVFdA/qQ0pKWO9aZZOTgeTkiGNVsywQeWyBP5N29f2bqh0C6gTeayhUWeDQnAfdQy9M2cA2/GUD3vxFw5WYaGi8qssaHV9XYiJciYmGxteVkACXwXgPLFtN0PgGjpnbXatsYHlXclLUsoF1/GVdrohlgUPx7nK5DK13fztR1nog7rQ04/H+Zx8MxXuNdR+zfBJh3btrbG608knAhTkarurxNRDv7uRkS/JJ4FqOGu/R8omBHOGP9zC/aAqF6Xzy5xsDo/nEaLxXr3vdfBI1X4dY92bziTtg7KPlCFdAvOvkE6D29T4SRuO3+nUNx3v1AZyJfBIp5kOt+8A2opUNrBNUNkqOMJ1PqvcnRuI9Odl4vP+5lnXzSZ33JwZzhPJ6tfJJULz/uTcwglY+SUgwvj/RyScB695MPgkX7+HWvZl8UiveJeST1FS4DeZ4rXxSY91H3J/o5JMI6143nwTGe+D7h2jo5ZMk4/FuVT4Jse4D4z1wnWvlkyg5Imh/IiGf/Lnujbxf18onIdZ9uDpR80mNmI207rXzSWC86+STlBStfGIkfoFD6z7m+STEug+c82hlg9oIuEd3tBwROB+S8omheK/5PRqa+STs/iTCuldeb3Du0cknIc4YwuJ2G36/7nK7tfOJoXwdsO5jmU+A0GvZP+cW5pOgsqmphuIX0MwnGueQgWXdGn8VbvjWJcXFxcjJyfH/nJaWhtTUVBQVFRlujBBCCCGEEEIIIYQQQgiJNYY/0Q0An332GbIC/yTE58O8efPwU8CNxE8/PfxN3uMNl8uF5OTkoN8YxrK8XW3oItWD7rLcpY6VLnbNR7y6M97pblUbukj1oLssd651eXGii1QPustylzpWZohXd6kedJflLnWsdJG6P3GKu1Pi3Uwdu65VOmgddI8J8Q2oV1xxhf//XS5X0J/ixTtutxudOnWyrLxdbegi1YPustyljpUuds1HvLoz3uluVRu6SPWguyx3rnV5caKLVA+6y3KXOlZmiFd3qR50l+Uudax0kbo/cYq7U+LdTB27rlU6GL51ic/ni/qPh9zBKKWwb98+rW/01SlvVxu6SPWguyx3qWOli13zEa/ujHe6W9WGLlI96C7LnWtdXpzoItWD7rLcpY6VGeLVXaoH3WW5Sx0rXaTuT5zi7pR4N1PHrmuVDoYPuok+Pp8PO3fuhC/CN4rWpbxdbegi1YPustyljpUuds1HvLoz3uluVRu6SPWguyx3rnV5caKLVA+6y3KXOlZmiFd3qR50l+Uudax0kbo/cYq7U+LdTB27rlU6GL51yX/+85+Qj2dlZaFr167o379/zDpFCCGEEEIIIYQQQgghhBjF8EH3E088EfLxffv2oaioCAMGDMBHH32E7OzsmHWOEEIIIYQQQgghhBBCCImG4VuXFBQUhPz3xx9/YNOmTfD5fLjzzjut7GuDw+VyIT09XevbSnXK29WGLlI96C7LXepY6WLXfMSrO+Od7la1oYtUD7rLcudalxcnukj1oLssd6ljZYZ4dZfqQXdZ7lLHShep+xOnuDsl3s3UsetapYPhT3RHolOnTpgyZQrGjRsXi5dzDG63G+3atbOsvF1t6CLVg+6y3KWOlS52zUe8ujPe6W5VG7pI9aC7LHeudXlxootUD7rLcpc6VmaIV3epHnSX5S51rHSRuj9xirtT4t1MHbuuVTrE7Mso27dvj507d8bq5RyBz+fD7t27tW7irlPerjZ0kepBd1nuUsdKF7vmI17dGe90t6oNXaR60F2WO9e6vDjRRaoH3WW5Sx0rM8Sru1QPustylzpWukjdnzjF3SnxbqaOXdcqHWJ20P3jjz+iQ4cOsXo5R6CUwu7du6GUsqS8XW3oItWD7rLcpY6VLnbNR7y6M97pblUbukj1oLssd651eXGii1QPustylzpWZohXd6kedJflLnWsdJG6P3GKu1Pi3Uwdu65VOhi+dUlxcXHIx4uKirBixQrcdNNNGDNmTMw6RgghhBBCCCGEEEIIIYQYwfBBd5MmTcLeXNzlcmH8+PG47bbbYtYxQgghhBBCCCGEEEIIIcQIhg+658+fH/LxzMxM5OfnIyMjI2adcgoulwtZWVla31aqU96uNnSR6kF3We5Sx0oXu+YjXt0Z73S3qg1dpHrQXZY717q8ONFFqgfdZblLHSszxKu7VA+6y3KXOla6SN2fOMXdKfFupo5d1yodDB90Dxo0KGqZn376CYcffnidOuQk3G43WrVqZVl5u9rQRaoH3WW5Sx0rXeyaj3h1Z7zT3ao2dJHqQXdZ7lzr8uJEF6kedJflLnWszBCv7lI96C7LXepY6SJ1f+IUd6fEu5k6dl2rdKjzl1GWlJTgxRdfxDHHHINevXrFok+OwefzobCwUOvbSnXK29WGLlI96C7LXepY6WLXfMSrO+Od7la1oYtUD7rLcudalxcnukj1oLssd6ljZYZ4dZfqQXdZ7lLHShep+xOnuDsl3s3UsetapYPpg+5FixZhzJgxaNWqFR599FGcdNJJ+Prrr2PZtwaPUgpFRUVa31aqU96uNnSR6kF3We5Sx0oXu+YjXt0Z73S3qg1dpHrQXZY717q8ONFFqgfdZblLHSszxKu7VA+6y3KXOla6SN2fOMXdKfFupo5d1yodDN+6BAB27tyJqVOn4pVXXkFxcTHOP/98VFRUYNasWTjssMOs6iMhhBBCCCGEEEIIIYQQEhbDn+g+7bTT0K1bN6xatQr//ve/sWPHDjz11FNW9o0QQgghhBBCCCGEEEIIiYrhT3TPmTMH1157La666irk5+db2SfH4HK5kJOTo/VtpTrl7WpDF6kedJflLnWsdLFrPuLVnfFOd6va0EWqB91luXOty4sTXaR60F2Wu9SxMkO8ukv1oLssd6ljpYvU/YlT3J0S72bq2HWt0sHwQfeSJUvwyiuv4KijjkKPHj1w8cUX429/+5uVfWvwuN1u5OTkWFberjZ0kepBd1nuUsdKF7vmI17dGe90t6oNXaR60F2WO9e6vDjRRaoH3WW5Sx0rM8Sru1QPustylzpWukjdnzjF3SnxbqaOXdcqHQzfuuTYY4/FSy+9hMLCQlxxxRWYPn06WrduDZ/Ph7lz56KkpMTKfjZIfD4ffv31V61vK9Upb1cbukj1oLssd6ljpYtd8xGv7ox3ulvVhi5SPeguy51rXV6c6CLVg+6y3KWOlRni1V2qB91luUsdK12k7k+c4u6UeDdTx65rlQ6GD7qrSU9Px7hx47BkyRL8+OOPuOmmmzBlyhS0aNECp59+uhV9bLAopVBaWqr1baU65e1qQxepHnSX5S51rHSxaz7i1Z3xTner2tBFqgfdZblzrcuLE12ketBdlrvUsTJDvLpL9aC7LHepY6WL1P2JU9ydEu9m6th1rdJB+6A7kG7duuHhhx/Gtm3b8Pbbb8eqT4QQQgghhBBCCCGEEEKIYep00F1NQkICzjzzTHz00UexeDlCCCGEEEIIIYQQQgghxDAxOegmoXG73cjNzYXbbWyYdcvb1YYuUj3oLstd6ljpYtd8xKs7453uVrWhi1QPusty51qXFye6SPWguyx3qWNlhnh1l+pBd1nuUsdKF6n7E6e4OyXezdSx61qlQ2J9d8DJuFwuNGnSxLLydrWhi1QPuuvV0UWih0Rvu+o4xZ3xbn0dXSS6S/Q2U8cpc26mjlPcudaNl7erDV2ketBdr44uEj3s8DbTjlPcpXrQXa+OLhI9JHrbVccp7k6JdzN17LpW6SDnyN2B+Hw+/Pzzz1rfVqpT3q42dJHqQXdZ7lLHShe75iNe3RnvdLeqDV2ketBdljvXurw40UWqB91luUsdKzPEq7tUD7rLcpc6VrpI3Z84xd0p8W6mjl3XKh140G0hSilUVlZqfVupTnm72tBFqgfdZblLHStd7JqPeHVnvNPdqjZ0kepBd1nuXOvy4kQXqR50l+UudazMEK/uUj3oLstd6ljpInV/4hR3p8S7mTp2Xat04EE3IYQQQgghhBBCCCGEkAYND7oJIYQQQgghhBBCCCGENGh40G0hbrcbbdu21fq2Up3ydrWhi1QPustylzpWutg1H/Hqzninu1Vt6CLVg+6y3LnW5cWJLlI96C7LXepYmSFe3aV60F2Wu9Sx0kXq/sQp7k6JdzN17LpW6ZBY3x1wMi6XCxkZGZaVt6sNXaR60F2Wu9Sx0sWu+YhXd8Y73a1qQxepHnSX5c61Li9OdJHqQXdZ7lLHygzx6i7Vg+6y3KWOlS5S9ydOcXdKvJupY9e1Sgc5R+4OxOv1YsOGDfB6vZaUt6sNXaR60F2Wu9Sx0sWu+YhXd8Y73a1qQxepHnSX5c61Li9OdJHqQXdZ7lLHygzx6i7Vg+6y3KWOlS5S9ydOcXdKvJupY9e1SgcedFuMz+eztLxdbegi1YPu1iLRQ6K3XXWc4s54t76O1W1IjRNdpHrQ3VqkesSru0RvM3WcMudm6jjFXepYmSFe3aV60N1aJHpI9LarjlPcnRLvZurYda0yCg+6CSGEEEIIIYQQQgghhDRoeNBNCCGEEEIIIYQQQgghpEHDg24LcbvdyMvL0/q2Up3ydrWhi1QPustylzpWutg1H/Hqzninu1Vt6CLVg+6y3LnW5cWJLlI96C7LXepYmSFe3aV60F2Wu9Sx0kXq/sQp7k6JdzN17LpW6SCnJw4lMTHR0vJ2taGLVA+6W4tED4nedtVxijvj3fo6VrchNU50kepBd2uR6hGv7hK9zdRxypybqeMUd6ljZYZ4dZfqQXdrkegh0duuOk5xd0q8m6lj17XKKDzothCfz4eNGzcavjG7bnm72tBFqgfdZblLHStd7JqPeHVnvNPdqjZ0kepBd1nuXOvy4kQXqR50l+UudazMEK/uUj3oLstd6ljpInV/4hR3p8S7mTp2Xat04EE3IYQQQgghhBBCCCGEkAYND7oJIYQQQgghhBBCCCGENGh40E0IIYQQQgghhBBCCCGkQcODbgtxu93Iz8/X+rZSnfJ2taGLVA+6y3KXOla62DUf8erOeKe7VW3oItWD7rLcudblxYkuUj3oLstd6liZIV7dpXrQXZa71LHSRer+xCnuTol3M3XsulbpIKcnDqWqqsrS8na1oYtUD7pbi0QPid521XGKO+Pd+jpWtyE1TnSR6kF3a5HqEa/uEr3N1HHKnJup4xR3qWNlhnh1l+pBd2uR6CHR2646TnF3SrybqWPXtcooPOi2EJ/Ph4KCAq1vK9Upb1cbukj1oLssd6ljpYtd8xGv7ox3ulvVhi5SPeguy51rXV6c6CLVg+6y3KWOlRni1V2qB91luUsdK12k7k+c4u6UeDdTx65rlQ486CaEEEIIIYQQQgghhBDSoOFBNyGEEEIIIYQQQgghhJAGDQ+6LUb3huxmbuBuRxu6SPWgu7VI9JDobVcdp7gz3q2vY3UbUuNEF6kedLcWqR7x6i7R20wdp8y5mTpOcZc6VmaIV3epHnS3FokeEr3tquMUd6fEu5k6kr6IEgAS67sDTiYhIQFdu3a1rLxdbegi1YPustyljpUuds1HvLoz3uluVRu6SPWguyx3rnV5caKLVA+6y3KXOlZmiFd3qR50l+Uudax0kbo/cYq7U+LdTB27rlU6yDp2dxhKKezfvx9KKUvK29WGLlI96C7LXepY6WLXfMSrO+Od7la1oYtUD7rLcudalxcnukj1oLssd6ljZYZ4dZfqQXdZ7lLHShep+xOnuDsl3s3UsetapUO9fqJ78uTJmDFjBtatW4fU1FQMGDAADz30ELp16xax3nvvvYe77roLW7ZsQX5+Ph566CGMGDHCkj76KitRumwZShYvRu6PP+L3VavQ+PjjkT5gANzJyZHr+nzYtm0b8vPzkZCQEL0tjfLV/dq/ZAn2FRSgSV4eMo47Lmq/zLSh667rbaaOHWNlBmnudamjiyQPO+a8osqLpZt2Y+H631BQuAd5rZphULcWGNglBymJoftmpo7fyaC7mTZ013pdxlfSWrcjv9s1VnbEvNnx1emTHdc2/xpZtwv/t9GN79VaDOreMuo6ZH6Xk69165iZc91catda1+2X2XjX7ZeZ8jp16hInVu5j7chZdaljlLrsHay8JvjrasaJtOu6nWOlg1Ou67rYEe9mPCTu5czUkbrWJc+htL2c1Pd6ZpG2P6lLv3SR+v7Faur1oHvhwoWYMGECjj76aFRVVeGOO+7A0KFDsWbNGqSnp4ess2zZMowaNQqTJ0/GX//6V7z11ls488wz8f333+Pwww+Paf98lZXY8+JLKP36ayiXC65KDyo2bETl+g0o/2k1ml1+WcwPSnX7Bbcb8PlQsWEjKtatj1m/pLrrYsdYEVnYMecVVV48v2Azlm7aA5dLQVUprNtZgrWF+/HjtiJcObhzrY2ymTp29Et3rUtdU7r9siPH2TVWdl8TdMfXaJ/qY+16vMC6XfuxdmdpzNYhMY4dcWJmznVzqV1rXbdfTon3usZJQ8/xVlPXvYNV1wRdpM65xLGyq18S14gd8W4GqW1IjF8za13q+ErEKR52wLGSS73euuR///sfxo4di549e6JXr16YOnUqtm7dihUrVoSt8+STT2L48OGYOHEievTogfvvvx99+vTB008/HfP+lS5bhtKvv0ZSy5ZI7tAB3sxMJHfogKSWLVH69dcoXbYs5m2a6Reys2PeL6nuutgxVkQWdsz50k27sXTTHuRmNUJeTjqapSUiLycduVmNsHTzHizdtDsmdezol+5al7qmdPtlR46za6zq45qgO75G+mT32u3YLB1ZyUDHZrFdh8Q4dsSJmTnXzaV2rXXdfjkl3mMRJw05x1tNLPYOVlwTdJE65xLHyq5+SVwjdsS7GaS2ITF+zax1qeMrEad42AHHSi6ivoyyqKgIAJCdnR22zFdffYUbb7wx6LFhw4Zh1qxZIctXVFSgoqLC/3NxcTEAwOPxwOPxROxPyeLFUC4XkJoKn88H4ODH8t2pqVAuF0oWL0ajgQPD1vf5fEhISEBVVZW/fiSMlq/ZL5fLdfC/Bvpltg0dd11vM3XsGKvq+IgWJ3XxMFPHjjbscLfKoy5zDhhzX7huF1wuhdQkN5RPwe1yQfkO/uyCwsJ1u3B85+w619F1N9OG7lqv6/hKWet25He7xsqOPFfX8TXSJzuubYFrJHDejaxDp+R3QD/HS8rXunXMzLluLrVrrev2qy7xrtMvs+WN1olFnFS3Fct9rB05q651rNrT2HFN0HWXel23e6zi7bqu625HvJvxkLiXM1NH6lqXPoeS9nJS3+sF0pD3sXXpl5POp8yg4+1SQu4Y7vP5cPrpp2Pfvn1YsmRJ2HLJycl4/fXXMWrUKP9jzz77LO69917s2rWrVvlJkybh3nvvrfX4W2+9hbS0tIh9yp02Da5KD7yZmbWeSyguhkpOws7RoyO+hhXY0S+p7ro4xYMYx445f22DGx4vkBXiL5GKKoGkBOCSrr4617GjX7rjJXVNSfSwa6wkupjpk9S1S6zDjjixI1/btdZ1++WUeJeaT6ReD3Vxyt5BahsSx8qufklcI3bEuxmktiExfqXGosR4N4NTPOyAY2UvZWVluPDCC1FUVITMEGMeiJhPdE+YMAE//fRTxENuM9x+++1BnwAvLi5Gu3btMHTo0KiD8/uqVajYsBHJ7dvD5zt4g/W2bdvC7Xaj8pdfkNI1H30ifAmmUgrFxcXIzMyEy+WK2lej5QP7BShUVnqQnJwEwBW1X2ba0HXX9TZTx46x8ng8mDt3LoYMGYKkpCRLPMzUsaMNO9yt8qjLnAPG3L9Xa7Fu1360a5Zeqw3vnlJ0b5mBESN61LmOrruZNnTXel3HV8patyO/2zVWduS5uoyv0T7ZcW0LXCM+nw/bt21Dmz/nPdo6dEp+B/RzvKR8rVvHzJzr5lK71rpuv+oS7zr9MlveaJ26xolV+1g7clZd61i1p7HjmqDrLvW6bvdYxdt1Xdfdjng34yFxL2emjtS1Ln0OJe3lpL7XC6Qh72Pr0i8nnU+ZofruHEYQcdB9zTXX4JNPPsGiRYvQtm3biGVzc3NrfXJ7165dyM3NDVk+JSUFKSkptR5PSkqKGhyNjz8eles3AAcOwJ2aCgBwu93AgQNwKYXGxx8f8TW8Xi92796Npk2bGvr2UaPlA/vlSktDeXk5UlJSoMrKovbLTBu67rreZurYMVbVGIkVsx5m6tjRRjVWulvlEYs5ByK7D+reEmt3luKAx4e0ZPefbSSjrNIHBRcGdW9Zq66ZOrruZtrQXet1HV8pa92O/G7XWNmR5+oyvkb7ZMe1LXCNpCYd/JoSt9uNA57o69Bp+R0wnuMl5WvdOmbmXDeX2rXWdftVl3jX6ZfZ8kbr1DVOrNrH2pGz6lqnmljvaey4Jui6S72u2z1W1cTLdV3X3Y54N+MhcS9npo7UtS59DiXt5aS+1wtFQ9zH1rVfgDPOp8xg1Bmo54NupRT+8Y9/YObMmViwYAHy8vKi1unfvz/mzZuH66+/3v/Y3Llz0b9//5j3L33AAJT/tNr/jb4JJSWo/OUXuJRC+rHHIn3AgJi3qdsvuF2AT6Fy3x+AL3b9kuquix1jRWRhx5wP7JKDH7cVYenmPXAD8Hmq8IenDD4AAzs3w8AuOTGpY0e/dNe61DWl2y87cpxdY2X3NUF3fI32ye6164LC/krAu6cUCq6YrUNiHDvixMyc6+ZSu9a6br+cEu91jZOGnuOtpq57B6uuCbpInXOJY2VXvySuETvi3QxS25AYv2bWutTxlYhTPOyAYyWXej3onjBhAt566y18+OGHaNy4MXbu3AkAyMrKQuqfv537+9//jjZt2mDy5MkAgOuuuw6DBg3CY489hpEjR2L69On47rvv8OKLL8a8f+7kZDS7/DI0OrznwRvN//gjUrrmo/HxxyN9wAC4k0Pc3MsGAvu1f8kSHCgoQEpeHjKOOy5m/ZLqrosdY0VkYcecpyQm4MrBnXFE2ywsXP8bCgorkJebgUHdWmBglxykJNb+TaaZOnb0S3etS11Tuv2yI8fZNVZ2XxN0x9don2xfu+t24f+K96B7ywwM6t4yZuuQGMeOODEz57q51K61rtsvp8R7XeOkoed4q6nr3sGqa4IuUudc4ljZ1S+Ja8SOeDeD1DYkxq+ZtS51fCXiFA874FgJRtUjAEL+e+211/xlBg0apMaMGRNU791331Vdu3ZVycnJqmfPnurTTz813GZRUZECoIqKirT6WllZqWbNmqUqKysN1/F6vWrr1q3K6/VaUt6uNnTdpXro1rFjzs3UcYq71LGSGO9m6jjFnfFOd6vaiNd4Vyp+3Z0S72bqOMWd8U53IzDe6W5VGxLHiu9ZGe9WtUF3WXHipLVuBp2z3Hq/dUk0FixYUOux8847D+edd54FPYotbrcb7dq1s6y8XW3oItWD7rLcpY6VLnbNR7y6M97pblUbukj1oLssd651eXGii1QPustylzpWZohXd6kedJflLnWsdJG6P3GKu1Pi3Uwdu65VOrjruwNOxufzYffu3fD5fJaUt6sNXaR60F2Wu9Sx0sWu+YhXd8Y73a1qQxepHnSX5c61Li9OdJHqQXdZ7lLHygzx6i7Vg+6y3KWOlS5S9ydOcXdKvJupY9e1SgcedFuIUgq7d+829Ml1M+XtakMXqR50l+Uudax0sWs+4tWd8U53q9rQRaoH3WW5c63LixNdpHrQXZa71LEyQ7y6S/Wguyx3qWOli9T9iVPcnRLvZurYda3SgQfdhBBCCCGEEEIIIYQQQho0POgmhBBCCCGEEEIIIYQQ0qDhQbeFuFwuZGVlweVyWVLerjZ0kepBd1nuUsdKF7vmI17dGe90t6oNXaR60F2WO9e6vDjRRaoH3WW5Sx0rM8Sru1QPustylzpWukjdnzjF3SnxbqaOXdcqHRLruwNOxu12o1WrVpaVt6sNXaR60F2Wu9Sx0sWu+YhXd8Y73a1qQxepHnSX5c61Li9OdJHqQXdZ7lLHygzx6i7Vg+6y3KWOlS5S9ydOcXdKvJupY9e1Sgd+ottCfD4fCgsLtb6tVKe8XW3oItWD7rLcpY6VLnbNR7y6M97pblUbukj1oLssd651eXGii1QPustylzpWZohXd6kedJflLnWsdJG6P3GKu1Pi3Uwdu65VOvCg20KUUigqKtL6tlKd8na1oYtUD7rLcpc6VrrYNR/x6s54p7tVbegi1YPusty51uXFiS5SPeguy13qWJkhXt2letBdlrvUsdJF6v7EKe5OiXczdey6VunAg25CCCGEEEIIIYQQQgghDZq4u0d39W8ZiouLtep5PB6UlZWhuLgYSUlJhup4vV7s378fxcXFSEhIiHl5u9rQdZfqoVvHjjk3U8cp7lLHSmK8m6njFHfGO90Z77GvE6/uTol3M3Wc4s54pzvjPTJ0Z7xb0YaZOk5xlzpWEuPdTB2nuDsl3s3UMdOGGarPcI18cjzuDrpLSkoAAO3atavnnhBCCCGEEEIIIYQQQgiJRklJCbKysiKWcSlJN1KxAZ/Phx07dqBx48ZwuVyG6xUXF6Ndu3b49ddfkZmZabje0UcfjW+//day8na0YcZdooduHbvm3Ewdp7hLHCup8W6mjlPcGe90t6J8vMY7EL/uTop33TpOcme80z0ajHe6M97rv192tMF4lxfvZuo4xd0p8W6mjpk2dFFKoaSkBK1bt4bbHfku3HH3iW632422bduarp+ZmakVVAkJCZaWt6sNQM9dqoeZOlbPuZk6TnGXOlaAvHg3U8cp7ox3ulvVBhC/8Q7Er7sT4t1sHSe4M97pbhTGO92taEPiWAF8z8p4t6YNusuKE8A5a90M0T7JXQ2/jNJiJkyYYGl5u9rQRaoH3a1FoodEb7vqOMWd8W59HavbkBonukj1oLu1SPWIV3eJ3mbqOGXOzdRxirvUsTJDvLpL9aC7tUj0kOhtVx2nuDsl3s3UsetaZZS4u3WJWYqLi5GVlYWioiJbflMhiXh1j1dvgO50jy/3ePUG6E73+HKPV2+A7nSPL/d49QboHo/u8eoN0J3u8eUer95m4Ce6DZKSkoJ77rkHKSkp9d0V24lX93j1BuhO9/hyj1dvgO50jy/3ePUG6E73+HKPV2+A7vHoHq/eAN3pHl/u8eptBn6imxBCCCGEEEIIIYQQQkiDhp/oJoQQQgghhBBCCCGEENKg4UE3IYQQQgghhBBCCCGEkAYND7oJIYQQQgghhBBCCCGENGh40E0IIYQQQgghhBBCCCGkQcODbgM888wz6NixIxo1aoR+/frhm2++qe8uWc6kSZPgcrmC/nXv3r2+u2UJixYtwmmnnYbWrVvD5XJh1qxZQc8rpXD33XejVatWSE1NxSmnnIKNGzfWT2djTDT3sWPH1oqD4cOH109nY8jkyZNx9NFHo3HjxmjRogXOPPNMrF+/PqhMeXk5JkyYgGbNmiEjIwPnnHMOdu3aVU89jh1G3AcPHlxr3q+88sp66nHseO6553DkkUciMzMTmZmZ6N+/P+bMmeN/3qlzHs3bqfMdiilTpsDlcuH666/3P+bUea9JKHenzn20PYxT5zyat1Pnu5rt27fjoosuQrNmzZCamoojjjgC3333nf95J+/nork7dT/XsWPHWl4ulwsTJkwA4Ny1Hs3byWvd6/XirrvuQl5eHlJTU9G5c2fcf//9UEr5yzh1rRtxd+paLykpwfXXX48OHTogNTUVAwYMwLfffut/3qlzDkR3d8qcx+JMZu/evRg9ejQyMzPRpEkTXHrppdi/f7+NFuaIhXuo68KUKVNstJAFD7qj8M477+DGG2/EPffcg++//x69evXCsGHD8Ntvv9V31yynZ8+eKCws9P9bsmRJfXfJEkpLS9GrVy8888wzIZ9/+OGH8Z///AfPP/88li9fjvT0dAwbNgzl5eU29zT2RHMHgOHDhwfFwdtvv21jD61h4cKFmDBhAr7++mvMnTsXHo8HQ4cORWlpqb/MDTfcgI8//hjvvfceFi5ciB07duDss8+ux17HBiPuAHDZZZcFzfvDDz9cTz2OHW3btsWUKVOwYsUKfPfddzjppJNwxhlnYPXq1QCcO+fRvAFnzndNvv32W7zwwgs48sgjgx536rwHEs4dcO7cR9rDOHnOo+3dnDrff/zxBwYOHIikpCTMmTMHa9aswWOPPYamTZv6yzh1P2fEHXDmfu7bb78Ncpo7dy4A4LzzzgPg3LUezRtw7lp/6KGH8Nxzz+Hpp5/G2rVr8dBDD+Hhhx/GU0895S/j1LVuxB1w5lofP3485s6dizfeeAM//vgjhg4dilNOOQXbt28H4Nw5B6K7A86Y81icyYwePRqrV6/G3Llz8cknn2DRokW4/PLL7VIwTazOo+67776gOPjHP/5hR/dlokhEjjnmGDVhwgT/z16vV7Vu3VpNnjy5HntlPffcc4/q1atXfXfDdgComTNn+n/2+XwqNzdXPfLII/7H9u3bp1JSUtTbb79dDz20jpruSik1ZswYdcYZZ9RLf+zkt99+UwDUwoULlVIH5zgpKUm99957/jJr165VANRXX31VX920hJruSik1aNAgdd1119Vfp2ykadOm6uWXX46rOVfqkLdS8THfJSUlKj8/X82dOzfINx7mPZy7Us6d+0h7GCfPebS9m1PnWymlbr31VnXccceFfd7J+7lo7krFz37uuuuuU507d1Y+n8/Ra70mgd5KOXutjxw5Uo0bNy7osbPPPluNHj1aKeXstR7NXSlnrvWysjKVkJCgPvnkk6DH+/Tpo/75z386es6juSvlzDk3cyazZs0aBUB9++23/jJz5sxRLpdLbd++3ba+1xWz51EdOnRQTzzxhI09lQ0/0R2ByspKrFixAqeccor/MbfbjVNOOQVfffVVPfbMHjZu3IjWrVujU6dOGD16NLZu3VrfXbKdgoIC7Ny5MygGsrKy0K9fv7iIAQBYsGABWrRogW7duuGqq67Cnj176rtLMaeoqAgAkJ2dDQBYsWIFPB5P0Lx3794d7du3d9y813SvZtq0acjJycHhhx+O22+/HWVlZfXRPcvwer2YPn06SktL0b9//7iZ85re1Th9vidMmICRI0cGzS8QH2s9nHs1Tp37cHsYp895tL2bU+f7o48+Qt++fXHeeeehRYsW6N27N1566SX/807ez0Vzr8bp+7nKykq8+eabGDduHFwul+PXejU1vatx6lofMGAA5s2bhw0bNgAA/u///g9LlizBqaeeCsDZaz2aezVOW+tVVVXwer1o1KhR0OOpqalYsmSJo+c8mns1TpvzmhiZ46+++gpNmjRB3759/WVOOeUUuN1uLF++3PY+xwqd+J4yZQqaNWuG3r1745FHHkFVVZXd3RVDYn13QDK7d++G1+tFy5Ytgx5v2bIl1q1bV0+9sod+/fph6tSp6NatGwoLC3Hvvffi+OOPx08//YTGjRvXd/dsY+fOnQAQMgaqn3Myw4cPx9lnn428vDxs3rwZd9xxB0499VR89dVXSEhIqO/uxQSfz4frr78eAwcOxOGHHw7g4LwnJyejSZMmQWWdNu+h3AHgwgsvRIcOHdC6dWusWrUKt956K9avX48ZM2bUY29jw48//oj+/fujvLwcGRkZmDlzJg477DCsXLnS0XMezhtw9nwDwPTp0/H9998H3c+wGqev9UjugHPnPtIexslzHm3v5tT5BoCff/4Zzz33HG688Ubccccd+Pbbb3HttdciOTkZY8aMcfR+Lpo7EB/7uVmzZmHfvn0YO3YsAOfn92pqegPOze0AcNttt6G4uBjdu3dHQkICvF4v/vWvf2H06NEAnP3eLZo74My13rhxY/Tv3x/3338/evTogZYtW+Ltt9/GV199hS5dujh6zqO5A86c85oYmeOdO3eiRYsWQc8nJiYiOzu7QceB0fi+9tpr0adPH2RnZ2PZsmW4/fbbUVhYiMcff9zW/kqBB90kJIG/GT7yyCPRr18/dOjQAe+++y4uvfTSeuwZsZO//e1v/v8/4ogjcOSRR6Jz585YsGABTj755HrsWeyYMGECfvrpJ8fegz4S4dwD72V2xBFHoFWrVjj55JOxefNmdO7c2e5uxpRu3bph5cqVKCoqwvvvv48xY8Zg4cKF9d0tywnnfdhhhzl6vn/99Vdcd911mDt3bq1PwzgdI+5OnftIe5jU1NR67Jm1RNu7OXW+gYO/uO3bty8efPBBAEDv3r3x008/4fnnn/cf9joVI+7xsJ975ZVXcOqpp6J169b13RVbCeXt5LX+7rvvYtq0aXjrrbfQs2dPrFy5Etdffz1at27t+LVuxN2pa/2NN97AuHHj0KZNGyQkJKBPnz4YNWoUVqxYUd9ds5xo7k6dc6LHjTfe6P//I488EsnJybjiiiswefJkpKSk1GPP6gfeuiQCOTk5SEhIqPXt3Lt27UJubm499ap+aNKkCbp27YpNmzbVd1dspXqeGQMH6dSpE3JychwTB9dccw0++eQTzJ8/H23btvU/npubi8rKSuzbty+ovJPmPZx7KPr16wcAjpj35ORkdOnSBUcddRQmT56MXr164cknn3T8nIfzDoWT5nvFihX47bff0KdPHyQmJiIxMRELFy7Ef/7zHyQmJqJly5aOnfdo7l6vt1YdJ819IIF7GKev9UCi7d2cNN+tWrXy/5VKNT169PDfusXJ+7lo7qFw2n7ul19+wRdffIHx48f7H4uHtR7KOxROWusTJ07Ebbfdhr/97W844ogjcPHFF+OGG27A5MmTATh7rUdzD4VT1nrnzp2xcOFC7N+/H7/++iu++eYbeDwedOrUydFzDkR2D4VT5jwQI3Ocm5uL3377Lej5qqoq7N27t0HHgdn47tevH6qqqrBlyxYruycWHnRHIDk5GUcddRTmzZvnf8zn82HevHlB9zaNB/bv34/NmzejVatW9d0VW8nLy0Nubm5QDBQXF2P58uVxFwMAsG3bNuzZs6fBx4FSCtdccw1mzpyJL7/8Enl5eUHPH3XUUUhKSgqa9/Xr12Pr1q0Nft6juYdi5cqVANDg5z0UPp8PFRUVjp7zUFR7h8JJ833yySfjxx9/xMqVK/3/+vbti9GjR/v/36nzHs091J+zOmnuAwncw8TTWo+2d3PSfA8cOBDr168PemzDhg3o0KEDAGfv56K5h8Ip+7lqXnvtNbRo0QIjR470PxYPaz2UdyictNbLysrgdgcfYSQkJMDn8wFw9lqP5h4Kp6319PR0tGrVCn/88Qc+++wznHHGGY6e80BCuYfCaXMOGFvX/fv3x759+4I+5f/ll1/C5/P5f9nXEDEb3ytXroTb7a51O5e4ob6/DVM606dPVykpKWrq1KlqzZo16vLLL1dNmjRRO3furO+uWcpNN92kFixYoAoKCtTSpUvVKaeconJyctRvv/1W312LOSUlJeqHH35QP/zwgwKgHn/8cfXDDz+oX375RSml1JQpU1STJk3Uhx9+qFatWqXOOOMMlZeXpw4cOFDPPa87kdxLSkrUzTffrL766itVUFCgvvjiC9WnTx+Vn5+vysvL67vrdeKqq65SWVlZasGCBaqwsND/r6yszF/myiuvVO3bt1dffvml+u6771T//v1V//7967HXsSGa+6ZNm9R9992nvvvuO1VQUKA+/PBD1alTJ3XCCSfUc8/rzm233aYWLlyoCgoK1KpVq9Rtt92mXC6X+vzzz5VSzp3zSN5Onu9wDBo0SF133XX+n50676EIdHfy3Efbwzh1ziN5O3m+lVLqm2++UYmJiepf//qX2rhxo5o2bZpKS0tTb775pr+MU/dz0dydvJ9TSimv16vat2+vbr311lrPOXWtKxXe2+lrfcyYMapNmzbqk08+UQUFBWrGjBkqJydH3XLLLf4yTl3r0dydvNb/97//qTlz5qiff/5Zff7556pXr16qX79+qrKyUinl3DlXKrK7k+Y8Fmcyw4cPV71791bLly9XS5YsUfn5+WrUqFH1pWSYurovW7ZMPfHEE2rlypVq8+bN6s0331TNmzdXf//73+tTq17hQbcBnnrqKdW+fXuVnJysjjnmGPX111/Xd5cs54ILLlCtWrVSycnJqk2bNuqCCy5QmzZtqu9uWcL8+fMVgFr/xowZo5RSyufzqbvuuku1bNlSpaSkqJNPPlmtX7++fjsdIyK5l5WVqaFDh6rmzZurpKQk1aFDB3XZZZc54pc8oZwBqNdee81f5sCBA+rqq69WTZs2VWlpaeqss85ShYWF9dfpGBHNfevWreqEE05Q2dnZKiUlRXXp0kVNnDhRFRUV1W/HY8C4ceNUhw4dVHJysmrevLk6+eST/YfcSjl3ziN5O3m+w1HzoNup8x6KQHcnz320PYxT5zySt5Pnu5qPP/5YHX744SolJUV1795dvfjii0HPO3k/F8ndyfs5pZT67LPPFICQc+nUta5UeG+nr/Xi4mJ13XXXqfbt26tGjRqpTp06qX/+85+qoqLCX8apaz2au5PX+jvvvKM6deqkkpOTVW5urpowYYLat2+f/3mnzrlSkd2dNOexOJPZs2ePGjVqlMrIyFCZmZnqkksuUSUlJfVgo0dd3VesWKH69eunsrKyVKNGjVSPHj3Ugw8+2OB+2RFLXEopZeUnxgkhhBBCCCGEEEIIIYQQK+E9ugkhhBBCCCGEEEIIIYQ0aHjQTQghhBBCCCGEEEIIIaRBw4NuQgghhBBCCCGEEEIIIQ0aHnQTQgghhBBCCCGEEEIIadDwoJsQQgghhBBCCCGEEEJIg4YH3YQQQgghhBBCCCGEEEIaNDzoJoQQQgghhBBCCCGEENKg4UE3IYQQQgghDQyXy4VZs2aZrr9gwQK4XC7s27evTv0YO3YszjzzzDq9BiGEEEIIIbGAB92EEEIIIYTU4Pfff8dVV12F9u3bIyUlBbm5uRg2bBiWLl1a312LCQMGDEBhYSGysrLquyuEEEIIIYTEhMT67gAhhBBCCCHSOOecc1BZWYnXX38dnTp1wq5duzBv3jzs2bOnvrsWE5KTk5Gbm1vf3SCEEEIIISRm8BPdhBBCCCGEBLBv3z4sXrwYDz30EE488UR06NABxxxzDG6//Xacfvrp/nKPP/44jjjiCKSnp6Ndu3a4+uqrsX//fv/zU6dORZMmTfDJJ5+gW7duSEtLw7nnnouysjK8/vrr6NixI5o2bYprr70WXq/XX69jx464//77MWrUKKSnp6NNmzZ45plnIvb5119/xfnnn48mTZogOzsbZ5xxBrZs2RK2fM1bl1T39bPPPkOPHj2QkZGB4cOHo7Cw0F/H6/XixhtvRJMmTdCsWTPccsstUEoFva7P58PkyZORl5eH1NRU9OrVC++//z4AQCmFU045BcOGDfPX27t3L9q2bYu777478qQQQgghhBASBR50E0IIIYQQEkBGRgYyMjIwa9YsVFRUhC3ndrvxn//8B6tXr8brr7+OL7/8ErfccktQmbKyMvznP//B9OnT8b///Q8LFizAWWedhdmzZ2P27Nl444038MILL/gPg6t55JFH0KtXL/zwww+47bbbcN1112Hu3Lkh++HxeDBs2DA0btwYixcvxtKlS/0H1ZWVlYa9y8rK8Oijj+KNN97AokWLsHXrVtx8883+5x977DFMnToVr776KpYsWYK9e/di5syZQa8xefJk/Pe//8Xzzz+P1atX44YbbsBFF12EhQsXwuVy4fXXX8e3336L//znPwCAK6+8Em3atOFBNyGEEEIIqTMuVfNjGATAwU+seDye+u4GIYQQYork5GS43fx9NiFm+eCDD3DZZZfhwIED6NOnDwYNGoS//e1vOPLII8PWef/993HllVdi9+7dAA5+SvqSSy7Bpk2b0LlzZwAHD3bfeOMN7Nq1CxkZGQCA4cOHo2PHjnj++ecBHPxEd48ePTBnzhz/a//tb39DcXExZs+eDeDgl1HOnDkTZ555Jt5880088MADWLt2LVwuFwCgsrISTZo0waxZszB06NBafV2wYAFOPPFE/PHHH2jSpEnIvj777LO47777sHPnTgBA69atccMNN2DixIkAgKqqKuTl5eGoo47y/1IgOzsbX3zxBfr37+9va/z48SgrK8Nbb70FAHjvvffw97//Hddffz2eeuop/PDDD8jPz9edIkIIIYQQQoLgPbproJTCzp076/wN9IQQQkh94na7kZeXh+Tk5PruCiENknPOOQcjR47E4sWL8fXXX2POnDl4+OGH8fLLL2Ps2LEAgC+++AKTJ0/GunXrUFxcjKqqKpSXl6OsrAxpaWkAgLS0NP/BMQC0bNkSHTt29B9yVz/222+/BbUfeFBc/fO///3vkH39v//7P2zatAmNGzcOery8vBybN2827Fyzr61atfL3q6ioCIWFhejXr5//+cTERPTt29d/G5JNmzahrKwMQ4YMCXrdyspK9O7d2//zeeedh5kzZ2LKlCl47rnneMhNCCGEEEJiAg+6a1B9yN2iRQukpaX5PxVDCCGENBR8Ph927NiBwsJCtG/fntcyQkzSqFEjDBkyBEOGDMFdd92F8ePH45577sHYsWOxZcsW/PWvf8VVV12Ff/3rX8jOzsaSJUtw6aWXorKy0n/QnZSUFPSaLpcr5GM+n890P/fv34+jjjoK06ZNq/Vc8+bNDb9OqH7p/PFn9f3JP/30U7Rp0ybouZSUFP//l5WVYcWKFUhISMDGjRsNvz4hhBBCCCGR4EF3AF6v13/I3axZs/ruDiGEEGKa5s2bY8eOHaiqqqp1eEUIMcdhhx2GWbNmAQBWrFgBn8+Hxx57zH+boHfffTdmbX399de1fu7Ro0fIsn369ME777yDFi1aIDMzM2Z9CCQrKwutWrXC8uXLccIJJwA4eOuSFStWoE+fPgAOjk9KSgq2bt2KQYMGhX2tm266CW63G3PmzMGIESMwcuRInHTSSZb0mxBCCCGExA886A6g+p7c1Z/AIYQQQhoq1bcs8Xq9POgmRJM9e/bgvPPOw7hx43DkkUeicePG+O677/Dwww/jjDPOAAB06dIFHo8HTz31FE477TQsXbrUf4/tWLB06VI8/PDDOPPMMzF37ly89957+PTTT0OWHT16NB555BGcccYZuO+++9C2bVv88ssvmDFjBm655Ra0bds2Jn267rrrMGXKFOTn56N79+54/PHHg27317hxY9x888244YYb4PP5cNxxx6GoqAhLly5FZmYmxowZg08//RSvvvoqvvrqK/Tp0wcTJ07EmDFjsGrVKjRt2jQm/SSEEEIIIfEJv6UqBPwTb0IIIQ0dXssIMU9GRgb69euHJ554AieccAIOP/xw3HXXXbjsssvw9NNPAwB69eqFxx9/HA899BAOP/xwTJs2DZMnT45ZH2666SZ899136N27Nx544AE8/vjjGDZsWMiyaWlpWLRoEdq3b4+zzz4bPXr0wKWXXory8vKYfsL7pptuwsUXX4wxY8agf//+aNy4Mc4666ygMvfffz/uuusuTJ48GT169MDw4cPx6aefIi8vD7///jsuvfRSTJo0yf8p8HvvvRctW7bElVdeGbN+EkIIIYSQ+MSldG6853DKy8tRUFCAvLw8NGrUqL67QwghhJiG1zRCGi4dO3bE9ddfj+uvv76+u0IIIYQQQkiDgZ/oJoZZsGABXC5X0J+oRqNjx47497//bVmfCIlHuBYJIYQQQgghhBBCguFBt0MYO3YsXC5XyD/7nDBhAlwuF8aOHWt/xwyybds2JCcn4/DDD6/vroimoc9zPNBQ52jSpElwuVz+f1lZWTj++OOxcOHC+u6aSBrqPBNCCCGEEEIIIU6FB90Ool27dpg+fToOHDjgf6y8vBxvvfUW2rdvX489i87UqVNx/vnno7i4GMuXL6/v7oimIc9zvNBQ56hnz54oLCxEYWEhvvrqK+Tn5+Ovf/0rioqK6rtrImmo80wIkc+WLVt42xJCCCGEEEI04UG3BVRUefHlul2496PVmDDte9z70Wp8uW4XKqq8lrbbp08ftGvXDjNmzPA/NmPGDLRv3x69e/cO7mNFBa699lq0aNECjRo1wnHHHYdvv/02qMzs2bPRtWtXpKam4sQTT8SWLVtqtblkyRIcf/zxSE1NRbt27XDttdeitLRUq99KKbz22mu4+OKLceGFF+KVV17Rqh9vGJ1nn8+HyZMnIy8vD6mpqejVqxfef/99//NerxeXXnqp//lu3brhySefDGpr7NixOPPMM/Hoo4+iVatWaNasGSZMmACPx2O9aAzwVVaiZMEC7PzXg9h2/Q3Y+a8HUbJgAXyVlZa221DXYmJiInJzc5Gbm4vDDjsM9913H/bv348NGzZovU68wLVICCGEEEIIIYTIgQfdMaaiyovnF2zG8wt+xtqdJSj3eLF2ZwmeX/Aznl+w2fLD7nHjxuG1117z//zqq6/ikksuqVXulltuwQcffIDXX38d33//Pbp06YJhw4Zh7969AIBff/0VZ599Nk477TSsXLkS48ePx2233Rb0Gps3b8bw4cNxzjnnYNWqVXjnnXewZMkSXHPNNVp9nj9/PsrKynDKKafgoosuwvTp07UP6GJFWWVV2H/lHm/My5rFyDxPnjwZ//3vf/H8889j9erVuOGGG3DRRRf5b0Xh8/nQtm1bvPfee1izZg3uvvtu3HHHHXj33XeDXmf+/PnYvHkz5s+fj9dffx1Tp07F1KlTTffdLnyVldjz4kvY8/IrqFi/Hqq8HBXr12PPy69gz4svWX7Y3RDXYiAVFRV47bXX0KRJE3Tr1s3065jFV1YW/l9FhfGy5eWGypqFa5EQQgghhBBCCJGBSyml6rsTUigvL0dBQQHy8vLQqFEjU6/x5bpdeH7Bz8jNaoT0lET/46UVVdhZXI4rB3XCSd1bxqrLfsaOHYt9+/bhpZdeQrt27bB+/XoAQPfu3fHrr79i/PjxaNKkCaZOnYrS0lI0bdoUU6dOxYUXXggA8Hg86NixI66//npMnDgRd9xxBz788EOsXr3a38Ztt92Ghx56CH/88QeaNGmC8ePHIyEhAS+88IK/zJIlSzBo0CCUlpaiUaNG/teM9Oe3o0ePRosWLfDEE08AAP7yl7/g+uuvr5f723a87dOwz53YrTleu+QY/8897vofDnhC/+KiX1423rmiv//nPvfPxd7S2gerW6aM1Oqf0Xl+4YUXkJ2djS+++AL9+x/qx/jx41FWVoa33nor5Otfc8012Llzp//TpmPHjsWCBQuwefNmJCQkAADOP/98uN1uTJ8+XavvdlOyYAH2vPwKklq2hDs93f+4r7QUnl270Gz8pWg8eHDM222oa3HSpEm4//77kZqaCgAoKytD48aN8c4772D48OExH6dorO3eI+xz6YNOQPsA13W9+0AF3D4kkLSjj0aHN/7r/3lD/wHw/vFHrXI91q3V6l9DWIuxuKYRQgghhBBCCCENhcToRYgOizfshtvtCjrkBoD0lES4XQeft+Kgu5rmzZtj5MiRmDp1KpRSGDlyJHJycoLKbN68GR6PBwMHDvQ/lpSUhGOOOQZr1x487Fm7di369esXVC/wkAYA/u///g+rVq3CtGnT/I8ppeDz+VBQUIAePcIfVFWzb98+zJgxA0uWLPE/dtFFF+GVV17hF7lFINo8b9q0CWVlZRgyZEhQvcrKyqBbKjzzzDN49dVXsXXrVhw4cACVlZX4y1/+ElSnZ8+e/oM1AGjVqhV+/PFHa8RiSOnSZXC53UGH3ADgTk+Hy+1G6dJllhx0V9PQ1iIAdOvWDR999BEAoKSkBO+88w7OO+88zJ8/H3379jUuH0dwLRJCCCGEEEIIITLgQXeM+a2kAunJCSGfS09OxG8lFSGfiyXjxo3z37LgmWeesayd/fv344orrsC1115b6zmjX8T21ltvoby8POggr/qAbsOGDejatWvM+muENfcNC/uc2+UK+nnFXacYLrvk1hPr1rEQRJrn/fv3AwA+/fRTtGnTJui5lJQUAMD06dNx880347HHHkP//v3RuHFjPPLII7W+DDQpKSnoZ5fLBZ/PF1MXK6j6/Xe409JCPudOS0PV779b3oeGtBYBIDk5GV26dPH/3Lt3b8yaNQv//ve/8eabb8akr0bp9v2K8E8mBOfYrkuXhCkIwB18h64u876oS7dCwrVICCGEEEIIIYTUPzzojjEtGqdg7c6SkM+VVlahfXbog7dYMnz4cFRWVsLlcmHYsNoHt507d0ZycjKWLl2KDh06ADh4u4Rvv/3Wf1uDHj16+D/ZWc3XX38d9HOfPn2wZs2aoIMxXV555RXcdNNNtT69ffXVV+PVV1/FlClTTL+2GdKSjS8Jq8oaJdI8H3bYYUhJScHWrVsxaNCgkPWXLl2KAQMG4Oqrr/Y/tnnz5pj3s75IbN4cFX/eTqImvrIypLRrZ3kfGtJaDEdCQgIOhLktiJWE+yWFnWWNwrVICCGEEEIIIYTUPzzojjHHd83B6h3FKK2oqnWPbp86+LzVJCQk+G97kJBQ+9Pl6enpuOqqqzBx4kRkZ2ejffv2ePjhh1FWVoZLL70UAHDllVfisccew8SJEzF+/HisWLGi1pee3XrrrTj22GNxzTXXYPz48UhPT8eaNWswd+5cPP3001H7uXLlSnz//feYNm0aunfvHvTcqFGjcN999+GBBx5AYiLDNBSR5rlx48a4+eabccMNN8Dn8+G4445DUVERli5diszMTIwZMwb5+fn473//i88++wx5eXl444038O233yIvL68+dGJO+sABKF+7Fr7S0lr36FY+H9IHDrC8Dw1lLVZTVVWFnTt3Ajh065I1a9bg1ltvNTkC8QHXIiGEEEIIIYQQUv/wBDHGDOySgx+3FWHp5j1wuw7erqS08uAh98DOzTCwi/UH3QCQmZkZ8fkpU6bA5/Ph4osvRklJCfr27YvPPvsMTZs2BXDwdgcffPABbrjhBjz11FM45phj8OCDD2LcuHH+1zjyyCOxcOFC/POf/8Txxx8PpRQ6d+6MCy64wFAfX3nlFRx22GG1DrkB4KyzzsI111yD2bNn4/TTT9cwjy8izfP999+P5s2bY/Lkyfj555/RpEkT9OnTB3fccQcA4IorrsAPP/yACy64AC6XC6NGjcLVV1+NOXPm2NV9S0kfMADlP61G6ddfH7xXd1oafGVlBw+5jz0W6QOsP+gGGsZarGb16tVo1aoVACAtLQ2dO3fGc889h7///e+a1vEH1yIhhBBCCCGEEFK/uJRSqr47IYXy8nIUFBQgLy8PjRo1Mv06FVVeLN20G4s37MZvJRVo0TgFx3fNwcAuOUhJDH3/bkJI7PFVVqJ02TKULl2Gqt9/R2Lz5kgfOADpAwbAnZxc390jxFJidU0jhBBCCKkvxo4diy5duuDOO++sl/ZPPfVUjB07VvsDJIFs2bIFXbp0QVVVVZ3707FjR7z55ps47rjj6vxadpCRkYENGzagdevWpl9j6tSpePPNN/HFF7H/rh1yiMGDB2P8+PG46KKLbG130qRJ2LZtG15++WVb23U6CxYswPjx47Fp06b67ortuKMXIbqkJCbgpO4tcc/pPfHM6D645/SeOKl7Sx5yE2Iz7uRkNB48GLn/vANt//0Ecv95BxoPHsxDbkIIIYQQQmJIx44dkZaWhoyMDLRu3RrXXnstvF5vfXcrJJMmTULPnj3hdrtr3RKwJnPmzNE+5B47diweeOCBOvTQPhYsWKD1PT/r16/HaaedhubNmyMnJwdnn302duzYEbb8/v37tQ+5O3bsiCVLInzZfANBNw7WrFmDoUOHomnTpujYsWPEslu2bIHL5UJGRob/37Rp0+rYY3twuVzYtm1bfXfDcQwePBhvvvlmfXdDBDzoJoQQQgghhBBCSJ34/PPPsX//fixevBgffPABXnnllfruUki6dOmCxx9/vMF8KloSRUVFOPvss7FhwwZs374dbdu2xdixY+u7W/VGLH+Zk5SUhL/97W948sknDZVPSEjA/v37/f9Gjx4ds76QYGLx1xgNoU2nwINuQgghhBBCCCGExITOnTtj4MCBWLlypf+xf/zjH2jdujWaNGmCoUOHYuvWrf7nXC4XnnvuOeTl5SEnJweTJ08O+bq7du3CkUceiWeffRYA8K9//QutWrVCZmYmjjjiCKxZs8ZQ/y666CIMGzYMaWlpUcsGfkry66+/Ru/evZGZmYk2bdrgiSeeqFX+9ddfx7Rp03D//fcjIyMDV155pf+5l156Ca1atUJubi5ef/11/+MHDhzANddcg9atW6Nt27aYMmVKxD4tW7YMXbt2RbNmzXDzzTfD5/P5n3vmmWeQn5+PnJwcjBkzBqWlpQCADRs24LjjjkNmZiZatmyJiRMnwuv14tRTT8XPP//s/1RwNI455hhccsklaNq0KVJSUnDNNdfgq6++Cls+8NO7r776Kjp06IDGjRujW7duWLBgQa3y48ePx9atWzF06NCgTyn7fD5cddVVyMzMxGGHHYbvv//eX2fr1q0YOXIkmjVrhh49euB///tfyL7885//9H9Hzo4dO+ByufDf//4XwMFf0gwcOBDAwdv/TZgwAbm5uWjfvj3uu+8+/xhPmjQJo0aNwjnnnIOMjAx8+eWXIb0ixUE48vPzMW7cOHTt2jVqWR1Gjx6NF198EcDB2HG5XFi0aBEA4MUXXww6IN+4cSP69u2LzMxMXHDBBaioqPA/9/7776Nnz57Izs7G6aefjt9++w3Aob8KuO+++5CdnY2OHTvis88+C9mXoUOHAgC6deuGjIwMLF68GMDBNXDeeeehcePG6NevHwoKCvx1fvzxR5xwwglo2rQpjjrqKHz33XchX/v333/HqaeeiiZNmiAnJwejRo3yP/fll1/6vfLz8/3t/vrrrxgxYgSaNm2Kww47DB9++KG/zuDBg3HXXXehb9++SE9Ph8fjwcKFC3HUUUehSZMmGDx4MDZv3uzv/6hRo5CdnY3s7Gwcf/zxIfv4xx9/YPjw4cjJyUHz5s1x+eWX+8e4ehzvuece5OTk4J577jGcG+6//34sXrwY48ePR0ZGBh588EH/c+HmZe/evbjwwgvRokULdOrUKSgnBeLz+XDttdciJycHTZo0wdFHH43du3cDAB588EF06NABmZmZ6N+/P1atWuWv17FjRzzyyCPo0aMHGjdujLvvvhvr169H3759kZWVVWtNhMtdplDEz4EDB9SaNWvUgQMH6rsrhBBCSJ3gNY0QQgghdtGhQwe1ePFipZRS69evV7m5uerRRx/1P//222+rffv2qbKyMnXJJZeoM844w/8cAHXuueeqkpIS9eOPP6qUlBS1adMmpZRSY8aMUffff7/atm2b6tGjh3rppZeUUkqtXbtWtW3bVhUWFiqfz6fWrl2rCgsLlVJKTZ48WY0cOTJqn4cNG6Zee+21iGUGDRqk3njjDaWUUv369VNvvvmmUkqpvXv3qu+//z5kneo+V1NQUKAAqGuvvVZVVFSozz77TKWnp6vi4mKllFJXX321GjVqlCopKVHbt29Xhx12mPr4449DvnaHDh3UX/7yF1VYWOgv+/LLLyullHr33XfV4YcfrrZs2aLKysrUqFGj1E033aSUUuqCCy5QDz74oPL5fGr//v1q+fLlSiml5s+frzp37hx1rMLx0ksvqX79+oV9HoD69ddf1f79+1Xjxo3Vhg0blFJKbdmyRf38889hHatjSSmlXnvtNZWYmKjeeustVVVVpf75z3+qE044QSmllNfrVUceeaR68sknlcfjUcuWLVM5OTlq586dtV53zpw56rjjjlNKKTV9+nSVl5enLrvsMqWUUnfeeae69dZblVJK3XHHHWrQoEFq79696pdfflH5+fn+OLnnnntUSkqK+uyzz5TX643oVTMOjPLVV1+pDh06RCxTHVOtWrVS7du3V9ddd50qLS0NWfa5555TF110kVJKqSlTpqi8vDz1r3/9Syml1EUXXaSee+45pdTBWO/evbvasmWL+uOPP9Rhhx2mXn31VaWUUsuXL1dt2rRRq1atUpWVlWrixInqnHPOUUodjKGEhAQ1ZcoU5fF41AsvvKDat28ftu/VMVHNPffco1JTU9WXX36pPB6Puvjii9Xf//53pZRSJSUlqnXr1ur9999XVVVVaubMmapdu3Yh39/ceuut6qqrrlIej0eVl5erpUuXKqWU2rx5s2rcuLH6+OOPVVVVlfrll1/Uxo0blVJKDRw4UN18882qvLxczZ8/X2VkZPifGzRokOrcubPauHGjOnDggNq6davKyclRixYtUlVVVeo///mP6tu3r3+MTzvtNFVWVqY8Ho9atGhRSPfdu3erjz76SJWXl6sdO3ao3r17qyeeeCJoHO+9915VWVmpysrKtHJDYK4yMi8jRoxQN910kyovL1dr165VrVq1Uv/3f/9X63XnzJmjjjrqKFVUVKSqqqrUihUrVElJiVJKqQ8++ED99ttvqrKyUt11112qV69e/nodOnRQgwYNUnv27FFr165VKSkpasiQIWrr1q2qsLBQtWzZUn355ZdKqci5yww86A6AhwKEEEKcAq9phBBCCLGLDh06qIyMDJWenq4AqLPPPjvsHmTdunWqWbNm/p8BqO+++87/89FHH61mzpyplDp4WDh+/HiVn5+vXn/9dX+ZjRs3qubNm/sPx8yge9B93HHHqUmTJqk9e/ZErBPuoHv37t3+x5o3b65++OEH5fP5VGpqqtq+fbv/uaeeekqNGTMm5Gt36NAhqM8vvfSSGjJkiN9n2rRp/ud+/PFH/4HpRRddpK644gq1Y8eOoNery0F39RzMmzcvbJnAg+7MzEw1c+ZMVV5eHvF1Qx10H3744f6fV69erbKyspRSBw+F8/Pzg+qfc845Iee1qKhIpaX9f3t3HxRV1ccB/LsvgC66CworyMsOb8aiplJZrBAkjaIwEaGg5HsKjEoIihqhmKDTOIpgE+KM02Dm4DhahqE1NUOOTaNoTaaVOE4IKVuzmuZCvHOePxjusLK7As9TPtT389fd5XfOPefcyxnmdy7nqkRLS4tYs2aNKC0tFXq9XgjRc517E4j+/v5SAk4IIcrKysSsWbOEED1J2d5jIYTdfv2ViW6z2Sy++eYb0dnZKW7evCkiIyPF2rVrrcZevXpVSnDGxsaK0tJSERMTI4ToGesrV64IIXrGoO/iVE5OjsjMzBRCCJGWliYlx4UQ4sGDB0KpVIqOjg5RXV0t1Gq16OrqEkII0dzcLACIe/fuWW2PtUR3XFyc9LmqqkpKmFZUVEj3d6+nnnpKVFdX96s3Ly9PvPzyy/0WUAoLC0VKSkq/+IaGBuHk5CT+/PNP6bsFCxaInTt3SuPReyxEzwJa78JILzc3N1FXVycOHjwoDAaDuHr1qtU+21JWVmaxYKBSqaT5bLBzg7VEt63rYjQahUqlEu3t7VL8+vXrRX5+fr96v/jiCzFhwgRx4cIF0d3dbbMvLS0tQiaTSUlwnU4nTpw4If18+vTpYs+ePdLnpKQkKclvb+4aCm5dYkXff/0hIiIajoQQj7sJRERE9C9y5swZmM1mnDx5EpcuXUJTU5P0sx07diAwMBBqtRrTp0/H3bt3LcqOGzdOOlapVBZlP/74Y6hUKouXQgYGBmLPnj3Izc3FuHHjsHLlSjx48OAv7B1w8OBB/PDDDwgMDER4eLjdLTseplAoMHbsWOlzbx9NJhNaWloQEhICFxcXuLi4IDc3F7/99pvNunx8fCyOjUYjgJ4tPNLS0qR6wsPDYTKZAAC7du1Ce3s7pk6dimnTpuHUqVOD7b6FxsZGzJo1CwUFBZg5c+Yj452dnVFRUYF9+/Zh3LhxmD9/vt2XWD7M1v3R0NCAuro6qc8uLi749NNPpTHpS61W44knnkBNTQ2++uorJCQkSH25ePGitHVJY2MjfH19pXI6nc6ird7e3v+zfg3VqFGjEBoaCoVCAZ1Oh7fffhsffvih1diQkBA0NTXh5s2buHz5MpYvX44rV66gvr4eZrMZEydOlGLtjfOOHTukMfbx8YFSqcSvv/4KAHB3d4dcLpfKAbD4HX4Ue+c9e/asxfX96aefrI5xTk4OfH19ERkZieDgYOkdAbdu3YKfn1+/+MbGRri7u2PkyJHSd/audUNDAw4fPmzRlubmZty+fRuLFy9GdHQ0EhISoNPpbG6/ZDabsWTJEnh7e0OtViM7O9tiLvTw8IBSqQSAIc0ND7N1XRoaGtDa2gp3d3ep7gMHDkjXs6/o6Gikp6cjNTUVnp6e2LBhAzo6OgD0bMc0ceJEaDQaeHh4QAhh0R+tVisdjxw5st/nvtfZ1tw1FMohl/wHcnR0hFwul254R0dHyGSyx90sIiKiQRFCwGQyQSaTwcHB4XE3h4iIiP4lZDIZ4uPjUVlZicLCQhQXF+Ps2bMoLS1FdXU1goKCcP36dQQHBw+4zoyMDNTW1iI5ORnHjx+XEkGLFy/G4sWLcefOHSxYsABFRUXYtm3bX9Sznn2Fjx07hs7OTpSVlWHhwoW4efNmv7jB5BDc3Nzg5OSEn3/+GWPGjBlQmV9++cXi2NPTEwDg5eWFwsJCvPLKK/3KeHp64r333oMQApWVlUhKSsK9e/eGlO+4c+cOXnzxRaSmpiItLW3A5ebOnYu5c+eiqakJ6enpyM3NRXl5eb+4wbTJy8sLer3eYm9geyIiInDq1Cm0tLTAw8MD4eHhKC4uhr+/P1xdXQEA48ePR0NDAwICAgD0JOHGjx9vs322+vV35pLkcrnNh1xkMhnCw8Oxf/9+BAcHY8SIEQgJCcG7774Lg8EwoHZ6eXmhoKAA2dnZ/X5248aN/7r99s47e/ZsVFZWPjJWrVajpKQEJSUlOH/+PGbOnIkXXngBPj4+VvfvHz9+PEwmE1pbWzFixAgAPdd68uTJUkzfsfHy8sKqVauwb98+q+ffvn07tm/fjmvXriEqKgphYWGIioqyiCkqKoLJZMJ3330HNzc3HDhwABUVFVbPN9i5YbC/N6NGjRrwHJCVlYWsrCxpT/NJkyYhKioK69atw9mzZxEaGoq2tjY4OzsP6WEre3PXUDDR3YdcLoefnx+MRuPfsgpHRET0V5HJZPD29oZCoXjcTSEiIqJ/mQ0bNuCZZ55BXl4ezGYzHBwc4ObmhubmZhQWFg6qLplMhvLyciQmJmLZsmU4fPgwrl+/DqPRCIPBAJVKBScnpwH/zdPR0YGuri50d3ejo6MDra2t0kNv9hw5cgQxMTEYO3YsRo8ebfN8Wq3WagLcGrlcjqVLl2L9+vXYu3cv1Go1amtrYTabMX36dKtl3nnnHcyZMwfd3d0oLi7GunXrAAArVqzAzp07MWXKFAQEBMBoNOLy5cuIiYnB8ePHYTAYpBeCymQyyGQyaLVamEwmNDc3w9nZGQBQXl6Obdu2We3DgwcPMHv2bMTFxWHz5s0D6iPQ8yLRixcvIjo6Gk5OTlCpVOjq6rIa2zt+4eHhj6z32WefRXd3N/bv34/XXnsNAHDhwgXodDqLp7J7RUREYMWKFZg3bx4A4Pnnn8fq1auxaNEiKSY5ORkFBQWYOnUqmpqaUFRUhE2bNg26X9bug6ioKERFRVldkBFCoK2tDe3t7RBCoLW1FXK5HI6Ojv1ia2pq4OrqisDAQBiNRrzxxht46aWXbI5TREQEtm/fjg0bNkj93rVrF/Ly8myW6Wv58uVYtGgRoqOjMWXKFPz+++84d+4c4uPjB1S+r95x6fu0tC2999nJkycRFxcnvRAyLCwMGo3GIraqqgp6vR5+fn7QaDSQyWRQKBRYuHAhpk6ditOnTyMmJga3b99Ge3s7AgICEBoaivz8fBQUFOD8+fM4deoU3nrrLattSUlJgcFgwPz58zFjxgw0Nzfjs88+w7x581BdXQ2tVgu9Xg+1Wg2lUml1fjCbzVCpVNBoNKivr0dpaam0wPKwwc4Ng5l3vLy8EBYWhry8PLz55ptwdHTE999/Ly2C9HXp0iUIITBt2jSMHj0aDg4OUCgUaGpqglwuh7u7Ozo7O5Gfnz+gc1tjb+4aCia6H+Lo6AhfX190dnbanHiJiIj+3/X+EUJERET0d9Pr9YiMjERJSQny8/MxY8YM6HQ6uLm5YePGjfjggw8GVZ9SqcSxY8cQGxuLNWvWID09HTk5Obh27RqcnJwwa9YsZGVlAQB27tyJc+fO4cyZM1brWrVqFQ4dOgQA+Pzzz5Gamorq6up+T18+7PTp08jMzERbWxsmTJiA999/32pcbyLVxcUFKSkp2Lhxo9169+7di9zcXEyePBlmsxlBQUF2FwOSkpIQERGBu3fvYsmSJVi+fDkAYOHChbh//z5iY2PR2NgIDw8PpKenIyYmBjU1NcjIyIDZbIavry8qKirg5OQEvV6P+Ph4+Pj4oLu7G/fv38etW7ekbTwe9tFHH+Hbb79FbW0tSktLpe8ftU1Fd3c3du3ahZSUFCgUChgMBhw8eNBq7KZNm/D6669j7dq1FuewRqlUoqqqCpmZmdi6dSuEEHj66adRVlZmNT4iIgJms1lKoj/8GQC2bNmC7OxsBAcHw8HBAStXrsTSpUsH3a+H74PS0lK7Y1tfX2+xxcbIkSMRGRmJL7/8EgAwceJE5Obm4tVXX8WNGzeQm5sLk8kEV1dXJCQk2Nwuw1a/t2zZMqDFBAAwGAzYvXs3lixZgrq6OowZMwZJSUlDSnRv3boViYmJaGtrwyeffGI3VqPRoKqqCllZWVixYgUcHBwwY8YMhIWF9Yu9fv06Vq9ejbt370Kr1aK4uBg6nQ4AcOLECeTk5CA5OVn674aAgAAcPXoUqamp0Gq18PT0xKFDhxAUFGS1LX5+fjh69Kg07zg7O2PmzJmYN28ejEYjUlNTYTQaodFokJ6ejoiIiH51ZGZmIjk5Ga6urggODkZCQoJ0fa0ZzNyQkZGBZcuWYffu3di8eTOee+45u2N75MgRZGdnw9/fH+3t7Zg0aRL27t3bL+6PP/7AunXrUFdXB2dnZyQlJUn3e1paGp588kk4Oztjy5YtVhdlBsLe3NXQ0ICQkBD8+OOPVhevrJEJbuJJRERERERERPSvN2fOHBQVFUGv1z/upvyjGI1GJCYm4uuvv37cTSH6R2Oim4iIiIiIiIiIiIiGNfubUBERERERERERERER/Z9jopuIiIiIiIiIiIiIhjUmuomIiIiIiIiIiIhoWGOim4iIiIiIiIiIiIiGNSa6iYiIiIiIiIiIiGhYY6KbiIiIiIiIiIiIiIY1JrqJiIiIiIiIiIiIaFhjopuIiIiIiIiIiIiIhjUmuomIiIiIiIiIiIhoWGOim4iIiIiIiIiIiIiGNSa6iYiIiIiIiIiIiGhY+w/q7UuwJ5aijwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MIN_ABS_DIFF = 0.05\n", + "scores = np.stack([modela, modelb], axis=1)\n", + "ranks = stats.rankdata(-scores, method=\"average\", axis=1)\n", + "abs_diff = np.abs(np.diff(scores, axis=1)).flatten()\n", + "ranks[abs_diff < MIN_ABS_DIFF, :] = 1.5\n", + "ranksa, ranksb = ranks[:, 0], ranks[:, 1]\n", + "\n", + "num_samples = ranks.shape[0]\n", + "indexes = np.arange(num_samples)\n", + "\n", + "fig, ax = plt.subplots(figsize=(18, 2.5))\n", + "\n", + "# plot sample index vs score and their mean\n", + "ax.scatter(indexes, ranksa, s=30, color=\"tab:blue\", marker=\"o\", label=\"Model A\", zorder=3, alpha=0.6)\n", + "ax.axhline(ranksa.mean(), color=\"tab:blue\", linestyle=\"--\", label=\"Mean\", zorder=3)\n", + "ax.scatter(indexes, ranksb, s=30, color=\"tab:red\", marker=\"o\", label=\"Model B\", zorder=3, alpha=0.6)\n", + "ax.axhline(ranksb.mean(), color=\"tab:red\", linestyle=\"--\", label=\"Mean\", zorder=3)\n", + "\n", + "# configure the x-axis\n", + "ax.set_xlabel(\"Sample index\")\n", + "ax.set_xlim(0 - (eps := 0.01 * num_samples), num_samples + eps)\n", + "ax.xaxis.set_major_locator(IndexLocator(5, 0))\n", + "ax.xaxis.set_minor_locator(IndexLocator(1, 0))\n", + "\n", + "# configure the y-axis\n", + "ax.set_ylabel(\"AUPIMO Rank\")\n", + "ax.set_ylim(1 - 0.1, 2 + 0.1)\n", + "ax.yaxis.set_major_locator(FixedLocator([1, 1.5, 2]))\n", + "ax.invert_yaxis()\n", + "\n", + "# configure the grid, legend, etc\n", + "ax.grid(axis=\"both\", which=\"major\", linestyle=\"-\")\n", + "ax.grid(axis=\"x\", which=\"minor\", linestyle=\"--\", alpha=0.5)\n", + "ax.legend(ncol=4, loc=\"upper left\", bbox_to_anchor=(0, -0.15))\n", + "ax.set_title(\"AUPIMO scores ranks\")\n", + "\n", + "fig.text(\n", + " 0.9,\n", + " -0.1,\n", + " \"Ranks: 1 is the best, 2 is the worst, 1.5 when the scores are the same.\",\n", + " ha=\"right\",\n", + " va=\"top\",\n", + " fontsize=\"small\",\n", + ")\n", + "\n", + "fig # noqa: B018, RUF100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The advantage of A over B is clearer now.\n", + "\n", + "Most of cases where B was better were within the difference margin of 5%.\n", + "\n", + "The average ranks also got more distant.\n", + "\n", + "Could it be by chance or can we be confident that model A is better than model B?\n", + "\n", + "> **Wilcoxon signed rank test**\n", + "> \n", + "> - null hypothesis: `average(rankA) == average(rankB)` \n", + "> - alternative hypothesis: `average(rankA) != average(rankB)`\n", + "> \n", + "> See [`scipy.stats.wilcoxon`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.wilcoxon.html#scipy.stats.wilcoxon) and [\"Wilcoxon signed-rank test\" in Wikipedia](https://en.wikipedia.org/wiki/Wilcoxon_signed-rank_test).\n", + ">\n", + "> Confidence Level (reminder): *higher* confidence level *more confident* that `average(rankA) > average(rankB)`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test_result=WilcoxonResult(statistic=1823.0, pvalue=0.0002876893285960681)\n", + "confidence=100.0%\n" + ] + } + ], + "source": [ + "MIN_ABS_DIFF = 0.05\n", + "differences = modela - modelb\n", + "differences[abs_diff < MIN_ABS_DIFF] = 0.0\n", + "test_result = stats.wilcoxon(differences, zero_method=\"zsplit\")\n", + "confidence = 1.0 - float(test_result.pvalue)\n", + "print(f\"{test_result=}\")\n", + "print(f\"{confidence=:.1%}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We got such a high confidence that we can say for sure that these differences are not due to chance.\n", + "\n", + "So we can say that model A is _consistently_ better than model B -- even though some counter examples exist as we saw in the image by image comparison." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cite Us\n", + "\n", + "AUPIMO was developed during [Google Summer of Code 2023 (GSoC 2023)](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd) with the `anomalib` team from Intel's OpenVINO Toolkit.\n", + "\n", + "arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n", + "\n", + "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n", + "\n", + "```bibtex\n", + "@misc{bertoldo2024aupimo,\n", + " author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n", + " title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n", + " year={2024},\n", + " url={https://arxiv.org/abs/2401.01984}, \n", + "}\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Utils\n", + "\n", + "Some utility functions to expand what this notebook shows." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Save AUPIMO scores\n", + "\n", + "At the begin of the notebook we defined a function `load_aupimo_result_from_json_dict()` that deserializes `AUPIMOResult` objects.\n", + "\n", + "Let's define the opposite operator so you can save and publish your AUPIMO scores." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "payload.keys()=dict_keys(['fpr_lower_bound', 'fpr_upper_bound', 'num_thresholds', 'thresh_lower_bound', 'thresh_upper_bound', 'aupimos'])\n" + ] + } + ], + "source": [ + "def save_aupimo_result_to_json_dict(\n", + " aupimo_result: AUPIMOResult,\n", + " paths: list[str | Path] | None = None,\n", + ") -> dict[str, str | float | int | list[str]]:\n", + " \"\"\"Convert the AUPIMOResult dataclass to a JSON payload.\"\"\"\n", + " payload = {\n", + " \"fpr_lower_bound\": aupimo_result.fpr_lower_bound,\n", + " \"fpr_upper_bound\": aupimo_result.fpr_upper_bound,\n", + " \"num_thresholds\": aupimo_result.num_thresholds,\n", + " \"thresh_lower_bound\": aupimo_result.thresh_lower_bound,\n", + " \"thresh_upper_bound\": aupimo_result.thresh_upper_bound,\n", + " \"aupimos\": aupimo_result.aupimos.tolist(),\n", + " }\n", + " if paths is not None:\n", + " if len(paths) != aupimo_result.aupimos.shape[0]:\n", + " msg = (\n", + " \"Invalid paths. It must have the same length as the AUPIMO scores. \"\n", + " f\"Got {len(paths)} paths and {aupimo_result.aupimos.shape[0]} scores.\"\n", + " )\n", + " raise ValueError(msg)\n", + " # make sure the paths are strings, not pathlib.Path objects\n", + " payload[\"paths\"] = [str(p) for p in paths]\n", + " return payload\n", + "\n", + "\n", + "payload = save_aupimo_result_to_json_dict(aupimo_result_model_a)\n", + "print(f\"{payload.keys()=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "payload.keys()=dict_keys(['fpr_lower_bound', 'fpr_upper_bound', 'num_thresholds', 'thresh_lower_bound', 'thresh_upper_bound', 'aupimos'])\n" + ] + } + ], + "source": [ + "payload = save_aupimo_result_to_json_dict(aupimo_result_model_a)\n", + "print(f\"{payload.keys()=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "payload.keys()=dict_keys(['fpr_lower_bound', 'fpr_upper_bound', 'num_thresholds', 'thresh_lower_bound', 'thresh_upper_bound', 'aupimos', 'paths'])\n" + ] + } + ], + "source": [ + "# you can optionally save the paths to the images\n", + "# where the AUPIMO scores were computed from\n", + "payload = save_aupimo_result_to_json_dict(aupimo_result_model_a, paths)\n", + "print(f\"{payload.keys()=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8,0K\t/tmp/tmpsuauy_de/aupimo_result.json\n" + ] + } + ], + "source": [ + "# let's check that it can be saved to a file and loaded back\n", + "\n", + "from tempfile import TemporaryDirectory\n", + "\n", + "with TemporaryDirectory() as tmpdir:\n", + " cache_dir = Path(tmpdir)\n", + "\n", + " with (cache_dir / \"aupimo_result.json\").open(\"w\") as file:\n", + " json.dump(payload, file)\n", + "\n", + " !du -sh {cache_dir / \"aupimo_result.json\"}\n", + "\n", + " with (cache_dir / \"aupimo_result.json\").open(\"r\") as file:\n", + " payload_reloaded = json.load(file)\n", + "\n", + "aupimo_result_reloaded = load_aupimo_result_from_json_dict(payload_reloaded)\n", + "assert torch.allclose(aupimo_result_model_a.aupimos, aupimo_result_reloaded.aupimos, equal_nan=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pairwise statistical tests (multiple models)\n", + "\n", + "What if you have multiple models to compare?\n", + "\n", + "Here we define a functions that will return all the pairwise comparisons between the models." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import itertools\n", + "from typing import Any, Literal\n", + "\n", + "import numpy as np\n", + "from numpy import ndarray\n", + "from scipy import stats\n", + "from torch import Tensor\n", + "\n", + "\n", + "def _validate_models(models: dict[str, Tensor | ndarray]) -> dict[str, ndarray]:\n", + " \"\"\"Make sure the input `models` is valid and convert all the dict's values to `ndarray`.\n", + "\n", + " Args:\n", + " models (dict[str, Tensor | ndarray]): {\"model name\": sequence of shape (num_images,)}.\n", + " Validations:\n", + " - keys are strings (model names)\n", + " - there are at least two models\n", + " - values are sequences of floats in [0, 1] or `nan`\n", + " - all sequences have the same shape\n", + " - all `nan` values are at the positions\n", + " Returns:\n", + " dict[str, ndarray]: {\"model name\": array (num_images,)}.\n", + " \"\"\"\n", + " if not isinstance(models, dict):\n", + " msg = f\"Expected argument `models` to be a dict, but got {type(models)}.\"\n", + " raise TypeError(msg)\n", + "\n", + " if len(models) < 2:\n", + " msg = \"Expected argument `models` to have at least one key, but got none.\"\n", + " raise ValueError(msg)\n", + "\n", + " ref_num_samples = None\n", + " ref_nans = None\n", + " for key in models:\n", + " if not isinstance(key, str):\n", + " msg = f\"Expected argument `models` to have all keys of type str. Found {type(key)}.\"\n", + " raise TypeError(msg)\n", + "\n", + " value = models[key]\n", + "\n", + " if not isinstance(value, Tensor | ndarray):\n", + " msg = (\n", + " \"Expected argument `models` to have all values of type Tensor or ndarray. \"\n", + " f\"Found {type(value)} on {key=}.\"\n", + " )\n", + " raise TypeError(msg)\n", + "\n", + " if isinstance(value, Tensor):\n", + " models[key] = value = value.numpy()\n", + "\n", + " if not np.issubdtype(value.dtype, np.floating):\n", + " msg = f\"Expected argument `models` to have all values of floating type. Found {value.dtype} on {key=}.\"\n", + " raise ValueError(msg)\n", + "\n", + " if value.ndim != 1:\n", + " msg = f\"Expected argument `models` to have all values of 1D arrays. Found {value.ndim} on {key=}.\"\n", + " raise ValueError(msg)\n", + "\n", + " if ref_num_samples is None:\n", + " ref_num_samples = num_samples = value.shape[0]\n", + " ref_nans = nans = np.isnan(value)\n", + "\n", + " if num_samples != ref_num_samples:\n", + " msg = \"Argument `models` has inconsistent number of samples.\"\n", + " raise ValueError(msg)\n", + "\n", + " if (nans != ref_nans).any():\n", + " msg = \"Argument `models` has inconsistent `nan` values (in different positions).\"\n", + " raise ValueError(msg)\n", + "\n", + " if (value[~nans] < 0).any() or (value[~nans] > 1).any():\n", + " msg = (\n", + " \"Expected argument `models` to have all sequences of floats \\\\in [0, 1]. \"\n", + " f\"Key {key} has values outside this range.\"\n", + " )\n", + " raise ValueError(msg)\n", + "\n", + " return models\n", + "\n", + "\n", + "def test_pairwise(\n", + " models: dict[str, Tensor | ndarray],\n", + " *,\n", + " test: Literal[\"ttest_rel\", \"wilcoxon\"],\n", + " min_abs_diff: float | None = None,\n", + ") -> list[dict[str, Any]]:\n", + " \"\"\"Compare all pairs of models using statistical tests.\n", + "\n", + " Scores are assumed to be *higher is better*.\n", + "\n", + " General hypothesis in the tests:\n", + " - Null hypothesis: two models are equivalent on average.\n", + " - Alternative hypothesis: one model is better than the other (two-sided test).\n", + "\n", + " Args:\n", + " models (dict[str, Tensor | ndarray]): {\"model name\": sequence of shape (num_images,)}.\n", + " test (Literal[\"ttest_rel\", \"wilcoxon\"]): The statistical test to use.\n", + " - \"ttest_rel\": Paired Student's t-test (parametric).\n", + " - \"wilcoxon\": Wilcoxon signed-rank test (non-parametric).\n", + " min_abs_diff (float | None): Minimum absolute difference to consider in the Wilcoxon test. If `None`, all\n", + " differences are considered. Default is `None`. Ignored in the t-test.\n", + " \"\"\"\n", + " models = _validate_models(models)\n", + " if test not in {\"ttest_rel\", \"wilcoxon\"}:\n", + " msg = f\"Expected argument `test` to be 'ttest_rel' or 'wilcoxon', but got '{test}'.\"\n", + " raise ValueError(msg)\n", + " # remove nan values\n", + " models = {k: v[~np.isnan(v)] for k, v in models.items()}\n", + " models_names = sorted(models.keys())\n", + " num_models = len(models)\n", + " comparisons = list(itertools.combinations(range(num_models), 2))\n", + "\n", + " # for each comparison, compute the test and confidence (1 - p-value)\n", + " test_results = []\n", + " for modela_idx, modelb_idx in comparisons: # indices of the sorted model names\n", + " modela = models_names[modela_idx]\n", + " modelb = models_names[modelb_idx]\n", + " modela_scores = models[modela]\n", + " modelb_scores = models[modelb]\n", + " if test == \"ttest_rel\":\n", + " test_result = stats.ttest_rel(modela_scores, modelb_scores, alternative=\"two-sided\")\n", + " else: # test == \"wilcoxon\"\n", + " differences = modela_scores - modelb_scores\n", + " if min_abs_diff is not None:\n", + " differences[np.abs(differences) < min_abs_diff] = 0.0\n", + " # extreme case\n", + " if (differences == 0).all():\n", + " test_result = stats._morestats.WilcoxonResult(np.nan, 1.0) # noqa: SLF001\n", + " else:\n", + " test_result = stats.wilcoxon(differences, zero_method=\"zsplit\", alternative=\"two-sided\")\n", + " test_results.append({\n", + " \"modela\": modela,\n", + " \"modelb\": modelb,\n", + " \"confidence\": 1 - test_result.pvalue,\n", + " \"pvalue\": test_result.pvalue,\n", + " \"statistic\": test_result.statistic,\n", + " })\n", + "\n", + " return test_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first test it with the same two models we used before." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
modelamodelbconfidencepvaluestatistic
0AB0.9950.0052.872
\n", + "
" + ], + "text/plain": [ + " modela modelb confidence pvalue statistic\n", + "0 A B 0.995 0.005 2.872" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# parametric test\n", + "pd.DataFrame.from_records(test_pairwise({\"A\": modela, \"B\": modelb}, test=\"ttest_rel\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
modelamodelbconfidencepvaluestatistic
0AB0.9980.0021965.500
\n", + "
" + ], + "text/plain": [ + " modela modelb confidence pvalue statistic\n", + "0 A B 0.998 0.002 1965.500" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# non-parametric test\n", + "pd.DataFrame.from_records(test_pairwise({\"A\": modela, \"B\": modelb}, test=\"wilcoxon\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
modelamodelbconfidencepvaluestatistic
0AB1.0000.0001823.000
\n", + "
" + ], + "text/plain": [ + " modela modelb confidence pvalue statistic\n", + "0 A B 1.000 0.000 1823.000" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# non-parametric test with a minimum absolute difference\n", + "pd.DataFrame.from_records(test_pairwise({\"A\": modela, \"B\": modelb}, test=\"wilcoxon\", min_abs_diff=0.05))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's get the best models from the benchmark in our paper and compare them two by two.\n", + "\n", + "We'll look at the dataset `cashew` from `VisA`.\n", + "\n", + "> More details in the paper (see the last cell)." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 modelamodelbconfidencepvaluestatistic
0efficientad_wr101_s_extpatchcore_wr1010.9994020.0005981580.000000
1efficientad_wr101_s_extrd++_wr50_ext0.7736590.2263412193.500000
2efficientad_wr101_s_extsimplenet_wr50_ext1.0000000.000000690.500000
3efficientad_wr101_s_extuflow_ext0.9994470.0005531550.500000
4patchcore_wr101rd++_wr50_ext0.9999800.0000201333.000000
5patchcore_wr101simplenet_wr50_ext1.0000000.000000351.500000
6patchcore_wr101uflow_ext0.7318750.2681252213.000000
7rd++_wr50_extsimplenet_wr50_ext1.0000000.000000967.000000
8rd++_wr50_extuflow_ext0.9999450.0000551383.000000
9simplenet_wr50_extuflow_ext1.0000000.000000318.500000
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "models = {\n", + " model_name: get_benchmark_aupimo_scores(model_name, \"visa/cashew\", verbose=False)[1].aupimos.numpy()\n", + " for model_name in [\n", + " \"efficientad_wr101_s_ext\",\n", + " \"patchcore_wr101\",\n", + " \"rd++_wr50_ext\",\n", + " \"simplenet_wr50_ext\",\n", + " \"uflow_ext\",\n", + " ]\n", + "}\n", + "models = test_pairwise(models, test=\"wilcoxon\", min_abs_diff=0.1)\n", + "pd.DataFrame.from_records(models).style.background_gradient(cmap=\"jet\", vmin=0, vmax=1, subset=[\"confidence\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare to the benchmark (coming up)\n", + "\n", + "Compare your freshly trained models to the benchmark datasets in our paper." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO(jpcbertoldo): implement utility function to load and compare to the results from the benchmark # noqa: TD003" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cite Us\n", + "\n", + "AUPIMO was developed during [Google Summer of Code 2023 (GSoC 2023)](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd) with the `anomalib` team from Intel's OpenVINO Toolkit.\n", + "\n", + "arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n", + "\n", + "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n", + "\n", + "```bibtex\n", + "@misc{bertoldo2024aupimo,\n", + " author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n", + " title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n", + " year={2024},\n", + " url={https://arxiv.org/abs/2401.01984}, \n", + "}\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "anomalib-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/700_metrics/pimo_viz.svg b/notebooks/700_metrics/pimo_viz.svg new file mode 100644 index 0000000000..962c95f463 --- /dev/null +++ b/notebooks/700_metrics/pimo_viz.svg @@ -0,0 +1,619 @@ + + + +image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +PIMO + + + + + +i + + + + + +AUPIMO + + + + + +i + + +Recall(t) + + +Upper bound + + +Lower bound + + +FPR(t) + + +⇒ + +Recall(t) + +Upper bound + +Lower bound + +t [anomaly score threholds] + +Transparent(never detected as anomalous) + +RED(always detectedas anomalous) + +JET(AUPIMO range) + + diff --git a/notebooks/700_metrics/roc_pro_pimo.svg b/notebooks/700_metrics/roc_pro_pimo.svg new file mode 100644 index 0000000000..b580e89d17 --- /dev/null +++ b/notebooks/700_metrics/roc_pro_pimo.svg @@ -0,0 +1,690 @@ + + + +image/svg+xmlEach curve summarizesthe test set with di + + +ff + + +erent aggregations. + + +ROC + + +PRO + + +One per image! + + +AUROC + + +AUPRO + + +AUPIMO + + +PIMO + + +i + + +i + + +Recall + + diff --git a/notebooks/README.md b/notebooks/README.md index 36976a6855..de33e5b7e9 100644 --- a/notebooks/README.md +++ b/notebooks/README.md @@ -51,3 +51,13 @@ To install Python, Git and other required tools, [OpenVINO Notebooks](https://gi | ---------------------- | ------------------------------------------------------------------------------------------------------------- | ----- | | Dobot Dataset Creation | [501a_training](/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb) | | | Training | [501b_training](/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb) | | + +## 7. Metrics + +| Notebook | GitHub | Colab | +| ----------------------------------------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| AUPIMO basics | [701a_aupimo](/notebooks/700_metrics/701a_aupimo.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701a_aupimo.ipynb) | +| AUPIMO representative samples and visualization | [701b_aupimo_advanced_i](/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb) | +| PIMO curve and integration bounds | [701c_aupimo_advanced_ii](/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb) | +| (AU)PIMO of a random model | [701d_aupimo_advanced_iii](/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb) | +| AUPIMO load/save, statistical comparison | [701e_aupimo_advanced_iv](/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb) | diff --git a/pyproject.toml b/pyproject.toml index bbfd0fe1a3..e47f7e55d8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,7 @@ # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # SETUP CONFIGURATION. # [build-system] -requires = ["setuptools>=42", "wheel"] +requires = ["setuptools>=64.0.0", "wheel"] build-backend = "setuptools.build_meta" [project] @@ -34,6 +34,7 @@ dependencies = [ "jsonargparse[signatures]>=4.27.7", "docstring_parser", # CLI help-formatter "rich_argparse", # CLI help-formatter + "lightning-utilities", ] [project.optional-dependencies] @@ -46,7 +47,7 @@ core = [ "matplotlib>=3.4.3", "opencv-python>=4.5.3.56", "pandas>=1.1.0", - "timm<=1.0.7,>=1.0.7", + "timm", "lightning>=2.2", "torch>=2", "torchmetrics>=1.3.2", @@ -56,6 +57,7 @@ core = [ "open-clip-torch>=2.23.0,<2.26.1", ] openvino = ["openvino>=2024.0", "nncf>=2.10.0", "onnx>=1.16.0"] +vlm = ["ollama", "openai", "python-dotenv","transformers"] loggers = [ "comet-ml>=3.31.7", "gradio>=4", @@ -84,7 +86,7 @@ test = [ "coverage[toml]", "tox", ] -full = ["anomalib[core,openvino,loggers,notebooks]"] +full = ["anomalib[core,openvino,loggers,notebooks, vlm]"] dev = ["anomalib[full,docs,test]"] [project.scripts] @@ -96,6 +98,9 @@ version = { attr = "anomalib.__version__" } # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # RUFF CONFIGURATION # [tool.ruff] +# Enable preview features +preview = true + # Enable rules lint.select = [ "F", # Pyflakes (`F`) @@ -158,6 +163,30 @@ lint.ignore = [ "PLR0912", # Too many branches "PLR0915", # Too many statements + # NOTE: Disable the following rules for now. + "A004", # import is shadowing a Python built-in + "A005", # Module is shadowing a Python built-in + "B909", # Mutation to loop iterable during iteration + "PLC2701", # Private name import + "PLC0415", # import should be at the top of the file + "PLR0917", # Too many positional arguments + "E226", # Missing whitespace around arithmetic operator + "E266", # Too many leading `#` before block comment + + "F822", # Undefined name `` in `__all__` + + "PGH004", # Use specific rule codes when using 'ruff: noqa' + "PT001", # Use @pytest.fixture over @pytest.fixture() + "PLR6104", # Use `*=` to perform an augmented assignment directly + "PLR0914", # Too many local variables + "PLC0206", # Extracting value from dictionary without calling `.items()` + "PLC1901", # can be simplified + + "RUF021", # Parenthesize the `and` subexpression + "RUF022", # Apply an isort-style sorting to '__all__' + "S404", # `subprocess` module is possibly insecure + # End of disable rules + # flake8-annotations "ANN101", # Missing-type-self "ANN002", # Missing type annotation for *args @@ -225,6 +254,14 @@ max-complexity = 15 [tool.ruff.lint.pydocstyle] convention = "google" +[tool.ruff.lint.flake8-copyright] +notice-rgx = """ +# Copyright \\(C\\) (\\d{4}(-\\d{4})?) Intel Corporation +# SPDX-License-Identifier: Apache-2\\.0 +""" + +[tool.ruff.lint.per-file-ignores] +"notebooks/**/*" = ["CPY001"] # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # MYPY CONFIGURATION. # @@ -257,11 +294,15 @@ pythonpath = "src" # COVERAGE CONFIGURATION # [tool.coverage.report] exclude_lines = [ - "except ImportError", + "pragma: no cover", + "def __repr__", + "raise NotImplementedError", + "if TYPE_CHECKING:", + "@abstractmethod", + "pass", "raise ImportError", - "except ApiException", - "raise ApiException", "raise ValueError", + "except ImportError:", ] [tool.coverage.paths] diff --git a/src/anomalib/__init__.py b/src/anomalib/__init__.py index 1b7a30497c..206e9531a9 100644 --- a/src/anomalib/__init__.py +++ b/src/anomalib/__init__.py @@ -5,7 +5,7 @@ from enum import Enum -__version__ = "1.2.0dev" +__version__ = "2.0.0dev" class LearningType(str, Enum): diff --git a/src/anomalib/callbacks/checkpoint.py b/src/anomalib/callbacks/checkpoint.py index 8947124364..7d7b4bb7d5 100644 --- a/src/anomalib/callbacks/checkpoint.py +++ b/src/anomalib/callbacks/checkpoint.py @@ -35,10 +35,10 @@ def _should_skip_saving_checkpoint(self, trainer: Trainer) -> bool: Overrides the parent method to allow saving during both the ``FITTING`` and ``VALIDATING`` states, and to allow saving when the global step and last_global_step_saved are both 0 (only for zero-/few-shot models). """ - is_zero_or_few_shot = trainer.lightning_module.learning_type in [LearningType.ZERO_SHOT, LearningType.FEW_SHOT] + is_zero_or_few_shot = trainer.lightning_module.learning_type in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT} return ( bool(trainer.fast_dev_run) # disable checkpointing with fast_dev_run - or trainer.state.fn not in [TrainerFn.FITTING, TrainerFn.VALIDATING] # don't save anything during non-fit + or trainer.state.fn not in {TrainerFn.FITTING, TrainerFn.VALIDATING} # don't save anything during non-fit or trainer.sanity_checking # don't save anything during sanity check or (self._last_global_step_saved == trainer.global_step and not is_zero_or_few_shot) ) @@ -52,7 +52,7 @@ def _should_save_on_train_epoch_end(self, trainer: Trainer) -> bool: if self._save_on_train_epoch_end is not None: return self._save_on_train_epoch_end - if trainer.lightning_module.learning_type in [LearningType.ZERO_SHOT, LearningType.FEW_SHOT]: + if trainer.lightning_module.learning_type in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}: return False return super()._should_save_on_train_epoch_end(trainer) diff --git a/src/anomalib/callbacks/graph.py b/src/anomalib/callbacks/graph.py index e2f27e3a99..38864245f6 100644 --- a/src/anomalib/callbacks/graph.py +++ b/src/anomalib/callbacks/graph.py @@ -33,7 +33,8 @@ class GraphLogger(Callback): >>> engine = Engine(logger=logger, callbacks=callbacks) """ - def on_train_start(self, trainer: Trainer, pl_module: LightningModule) -> None: + @staticmethod + def on_train_start(trainer: Trainer, pl_module: LightningModule) -> None: """Log model graph to respective logger. Args: @@ -47,7 +48,8 @@ def on_train_start(self, trainer: Trainer, pl_module: LightningModule) -> None: logger.watch(pl_module, log_graph=True, log="all") break - def on_train_end(self, trainer: Trainer, pl_module: LightningModule) -> None: + @staticmethod + def on_train_end(trainer: Trainer, pl_module: LightningModule) -> None: """Unwatch model if configured for wandb and log it model graph in Tensorboard if specified. Args: diff --git a/src/anomalib/callbacks/metrics.py b/src/anomalib/callbacks/metrics.py index 081e43d2aa..e09e622d41 100644 --- a/src/anomalib/callbacks/metrics.py +++ b/src/anomalib/callbacks/metrics.py @@ -78,9 +78,8 @@ def setup( elif self.task == TaskType.CLASSIFICATION: pixel_metric_names = [] logger.warning( - "Cannot perform pixel-level evaluation when task type is classification. " - "Ignoring the following pixel-level metrics: %s", - self.pixel_metric_names, + "Cannot perform pixel-level evaluation when task type is {self.task.value}. " + f"Ignoring the following pixel-level metrics: {self.pixel_metric_names}", ) else: pixel_metric_names = ( @@ -98,11 +97,8 @@ def setup( pl_module.pixel_metrics = create_metric_collection(pixel_metric_names, "pixel_") self._set_threshold(pl_module) - def on_validation_epoch_start( - self, - trainer: Trainer, - pl_module: AnomalyModule, - ) -> None: + @staticmethod + def on_validation_epoch_start(trainer: Trainer, pl_module: AnomalyModule) -> None: del trainer # Unused argument. pl_module.image_metrics.reset() @@ -123,21 +119,14 @@ def on_validation_batch_end( self._outputs_to_device(outputs) self._update_metrics(pl_module.image_metrics, pl_module.pixel_metrics, outputs) - def on_validation_epoch_end( - self, - trainer: Trainer, - pl_module: AnomalyModule, - ) -> None: + def on_validation_epoch_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None: del trainer # Unused argument. self._set_threshold(pl_module) self._log_metrics(pl_module) - def on_test_epoch_start( - self, - trainer: Trainer, - pl_module: AnomalyModule, - ) -> None: + @staticmethod + def on_test_epoch_start(trainer: Trainer, pl_module: AnomalyModule) -> None: del trainer # Unused argument. pl_module.image_metrics.reset() @@ -158,16 +147,13 @@ def on_test_batch_end( self._outputs_to_device(outputs) self._update_metrics(pl_module.image_metrics, pl_module.pixel_metrics, outputs) - def on_test_epoch_end( - self, - trainer: Trainer, - pl_module: AnomalyModule, - ) -> None: + def on_test_epoch_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None: del trainer # Unused argument. self._log_metrics(pl_module) - def _set_threshold(self, pl_module: AnomalyModule) -> None: + @staticmethod + def _set_threshold(pl_module: AnomalyModule) -> None: pl_module.image_metrics.set_threshold(pl_module.image_threshold.value.item()) pl_module.pixel_metrics.set_threshold(pl_module.pixel_threshold.value.item()) diff --git a/src/anomalib/callbacks/nncf/utils.py b/src/anomalib/callbacks/nncf/utils.py index e221e2e16c..99f1db6aaa 100644 --- a/src/anomalib/callbacks/nncf/utils.py +++ b/src/anomalib/callbacks/nncf/utils.py @@ -40,7 +40,8 @@ def __next__(self) -> torch.Tensor: loaded_item = next(self._data_loader_iter) return loaded_item["image"] - def get_inputs(self, dataloader_output: dict[str, str | torch.Tensor]) -> tuple[tuple, dict]: + @staticmethod + def get_inputs(dataloader_output: dict[str, str | torch.Tensor]) -> tuple[tuple, dict]: """Get input to model. Returns: @@ -49,7 +50,8 @@ def get_inputs(self, dataloader_output: dict[str, str | torch.Tensor]) -> tuple[ """ return (dataloader_output,), {} - def get_target(self, _): # noqa: ANN001, ANN201 + @staticmethod + def get_target(_) -> None: # noqa: ANN001 """Return structure for ground truth in loss criterion based on dataloader output. This implementation does not do anything and is a placeholder. diff --git a/src/anomalib/callbacks/normalization/min_max_normalization.py b/src/anomalib/callbacks/normalization/min_max_normalization.py index cdd9760b42..ff0afc9232 100644 --- a/src/anomalib/callbacks/normalization/min_max_normalization.py +++ b/src/anomalib/callbacks/normalization/min_max_normalization.py @@ -23,7 +23,8 @@ class _MinMaxNormalizationCallback(NormalizationCallback): Note: This callback is set within the Engine. """ - def setup(self, trainer: Trainer, pl_module: AnomalyModule, stage: str | None = None) -> None: + @staticmethod + def setup(trainer: Trainer, pl_module: AnomalyModule, stage: str | None = None) -> None: """Add min_max metrics to normalization metrics.""" del trainer, stage # These variables are not used. @@ -48,7 +49,8 @@ def setup(self, trainer: Trainer, pl_module: AnomalyModule, stage: str | None = msg = f"Expected normalization_metric {name} to be of type MinMax, got {type(metric)}" raise TypeError(msg) - def on_test_start(self, trainer: Trainer, pl_module: AnomalyModule) -> None: + @staticmethod + def on_test_start(trainer: Trainer, pl_module: AnomalyModule) -> None: """Call when the test begins.""" del trainer # `trainer` variable is not used. @@ -56,15 +58,16 @@ def on_test_start(self, trainer: Trainer, pl_module: AnomalyModule) -> None: if metric is not None: metric.set_threshold(0.5) - def on_validation_epoch_start(self, trainer: Trainer, pl_module: AnomalyModule) -> None: + @staticmethod + def on_validation_epoch_start(trainer: Trainer, pl_module: AnomalyModule) -> None: """Call when the validation epoch begins.""" del trainer # `trainer` variable is not used. if hasattr(pl_module, "normalization_metrics"): pl_module.normalization_metrics.reset() + @staticmethod def on_validation_batch_end( - self, trainer: Trainer, pl_module: AnomalyModule, outputs: STEP_OUTPUT, diff --git a/src/anomalib/callbacks/thresholding.py b/src/anomalib/callbacks/thresholding.py index 1a4d12febd..14bae0331d 100644 --- a/src/anomalib/callbacks/thresholding.py +++ b/src/anomalib/callbacks/thresholding.py @@ -11,7 +11,7 @@ from lightning.pytorch.utilities.types import STEP_OUTPUT from omegaconf import DictConfig, ListConfig -from anomalib.metrics.threshold import BaseThreshold +from anomalib.metrics.threshold import Threshold from anomalib.models import AnomalyModule from anomalib.utils.types import THRESHOLD @@ -28,8 +28,8 @@ def __init__( ) -> None: super().__init__() self._initialize_thresholds(threshold) - self.image_threshold: BaseThreshold - self.pixel_threshold: BaseThreshold + self.image_threshold: Threshold + self.pixel_threshold: Threshold def setup(self, trainer: Trainer, pl_module: AnomalyModule, stage: str) -> None: del trainer, stage # Unused arguments. @@ -86,13 +86,13 @@ def _initialize_thresholds( # When only a single threshold class is passed. # This initializes image and pixel thresholds with the same class # >>> _initialize_thresholds(F1AdaptiveThreshold()) - if isinstance(threshold, BaseThreshold): + if isinstance(threshold, Threshold): self.image_threshold = threshold self.pixel_threshold = threshold.clone() # When a tuple of threshold classes are passed # >>> _initialize_thresholds((ManualThreshold(0.5), ManualThreshold(0.5))) - elif isinstance(threshold, tuple) and isinstance(threshold[0], BaseThreshold): + elif isinstance(threshold, tuple) and isinstance(threshold[0], Threshold): self.image_threshold = threshold[0] self.pixel_threshold = threshold[1] # When the passed threshold is not an instance of a Threshold class. @@ -133,7 +133,8 @@ def _load_from_config(self, threshold: DictConfig | str | ListConfig | list[dict msg = f"Invalid threshold config {threshold}" raise TypeError(msg) - def _get_threshold_from_config(self, threshold: DictConfig | str | dict[str, str | float]) -> BaseThreshold: + @staticmethod + def _get_threshold_from_config(threshold: DictConfig | str | dict[str, str | float]) -> Threshold: """Return the instantiated threshold object. Example: @@ -151,7 +152,7 @@ def _get_threshold_from_config(self, threshold: DictConfig | str | dict[str, str >>> __get_threshold_from_config(config) Returns: - (BaseThreshold): Instance of threshold object. + (Threshold): Instance of threshold object. """ if isinstance(threshold, str): threshold = DictConfig({"class_path": threshold}) @@ -170,7 +171,8 @@ def _get_threshold_from_config(self, threshold: DictConfig | str | dict[str, str class_ = getattr(module, class_path) return class_(**init_args) - def _reset(self, pl_module: AnomalyModule) -> None: + @staticmethod + def _reset(pl_module: AnomalyModule) -> None: pl_module.image_threshold.reset() pl_module.pixel_threshold.reset() @@ -182,14 +184,16 @@ def _outputs_to_cpu(self, output: STEP_OUTPUT) -> STEP_OUTPUT | dict[str, Any]: output = output.cpu() return output - def _update(self, pl_module: AnomalyModule, outputs: STEP_OUTPUT) -> None: + @staticmethod + def _update(pl_module: AnomalyModule, outputs: STEP_OUTPUT) -> None: pl_module.image_threshold.cpu() pl_module.image_threshold.update(outputs["pred_scores"], outputs["label"].int()) if "mask" in outputs and "anomaly_maps" in outputs: pl_module.pixel_threshold.cpu() pl_module.pixel_threshold.update(outputs["anomaly_maps"], outputs["mask"].int()) - def _compute(self, pl_module: AnomalyModule) -> None: + @staticmethod + def _compute(pl_module: AnomalyModule) -> None: pl_module.image_threshold.compute() if pl_module.pixel_threshold._update_called: # noqa: SLF001 pl_module.pixel_threshold.compute() diff --git a/src/anomalib/callbacks/timer.py b/src/anomalib/callbacks/timer.py index ee9658a9b0..3cbf516dc0 100644 --- a/src/anomalib/callbacks/timer.py +++ b/src/anomalib/callbacks/timer.py @@ -105,5 +105,5 @@ def on_test_end(self, trainer: Trainer, pl_module: LightningModule) -> None: else: test_data_loader = trainer.test_dataloaders[0] output += f"(batch_size={test_data_loader.batch_size})" - output += f" : {self.num_images/testing_time} FPS" + output += f" : {self.num_images / testing_time} FPS" logger.info(output) diff --git a/src/anomalib/callbacks/visualizer.py b/src/anomalib/callbacks/visualizer.py index c78c1f6ab8..41d56a7ebd 100644 --- a/src/anomalib/callbacks/visualizer.py +++ b/src/anomalib/callbacks/visualizer.py @@ -146,8 +146,8 @@ def on_predict_batch_end( def on_predict_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None: return self.on_test_end(trainer, pl_module) + @staticmethod def _add_to_logger( - self, result: GeneratorResult, module: AnomalyModule, trainer: Trainer, diff --git a/src/anomalib/cli/cli.py b/src/anomalib/cli/cli.py index cd95b18bda..323c700fa4 100644 --- a/src/anomalib/cli/cli.py +++ b/src/anomalib/cli/cli.py @@ -30,7 +30,7 @@ from anomalib.data import AnomalibDataModule from anomalib.engine import Engine - from anomalib.metrics.threshold import BaseThreshold + from anomalib.metrics.threshold import Threshold from anomalib.models import AnomalyModule from anomalib.utils.config import update_config @@ -64,7 +64,8 @@ def __init__(self, args: Sequence[str] | None = None, run: bool = True) -> None: if run: self._run_subcommand() - def init_parser(self, **kwargs) -> ArgumentParser: + @staticmethod + def init_parser(**kwargs) -> ArgumentParser: """Method that instantiates the argument parser.""" kwargs.setdefault("dump_header", [f"anomalib=={__version__}"]) parser = ArgumentParser(formatter_class=CustomHelpFormatter, **kwargs) @@ -139,7 +140,8 @@ def add_subcommands(self, **kwargs) -> None: self.subcommand_parsers[subcommand] = sub_parser parser_subcommands.add_subcommand(subcommand, sub_parser, help=value["description"]) - def add_arguments_to_parser(self, parser: ArgumentParser) -> None: + @staticmethod + def add_arguments_to_parser(parser: ArgumentParser) -> None: """Extend trainer's arguments to add engine arguments. .. note:: @@ -152,9 +154,9 @@ def add_arguments_to_parser(self, parser: ArgumentParser) -> None: parser.add_argument("--task", type=TaskType | str, default=TaskType.SEGMENTATION) parser.add_argument("--metrics.image", type=list[str] | str | None, default=["F1Score", "AUROC"]) parser.add_argument("--metrics.pixel", type=list[str] | str | None, default=None, required=False) - parser.add_argument("--metrics.threshold", type=BaseThreshold | str, default="F1AdaptiveThreshold") + parser.add_argument("--metrics.threshold", type=Threshold | str, default="F1AdaptiveThreshold") parser.add_argument("--logging.log_graph", type=bool, help="Log the model to the logger", default=False) - if hasattr(parser, "subcommand") and parser.subcommand not in ("export", "predict"): + if hasattr(parser, "subcommand") and parser.subcommand not in {"export", "predict"}: parser.link_arguments("task", "data.init_args.task") parser.add_argument( "--default_root_dir", @@ -278,7 +280,7 @@ def _set_install_subcommand(self, action_subcommand: _ActionSubCommands) -> None def before_instantiate_classes(self) -> None: """Modify the configuration to properly instantiate classes and sets up tiler.""" subcommand = self.config["subcommand"] - if subcommand in (*self.subcommands(), "train", "predict"): + if subcommand in {*self.subcommands(), "train", "predict"}: self.config[subcommand] = update_config(self.config[subcommand]) def instantiate_classes(self) -> None: @@ -288,7 +290,7 @@ def instantiate_classes(self) -> None: But for subcommands we do not want to instantiate any trainer specific classes such as datamodule, model, etc This is because the subcommand is responsible for instantiating and executing code based on the passed config """ - if self.config["subcommand"] in (*self.subcommands(), "predict"): # trainer commands + if self.config["subcommand"] in {*self.subcommands(), "predict"}: # trainer commands # since all classes are instantiated, the LightningCLI also creates an unused ``Trainer`` object. # the minor change here is that engine is instantiated instead of trainer self.config_init = self.parser.instantiate_classes(self.config) @@ -301,7 +303,7 @@ def instantiate_classes(self) -> None: else: self.config_init = self.parser.instantiate_classes(self.config) subcommand = self.config["subcommand"] - if subcommand in ("train", "export"): + if subcommand in {"train", "export"}: self.instantiate_engine() if "model" in self.config_init[subcommand]: self.model = self._get(self.config_init, "model") @@ -359,7 +361,7 @@ def _run_subcommand(self) -> None: install_kwargs = self.config.get("install", {}) anomalib_install(**install_kwargs) - elif self.config["subcommand"] in (*self.subcommands(), "train", "export", "predict"): + elif self.config["subcommand"] in {*self.subcommands(), "train", "export", "predict"}: fn = getattr(self.engine, self.subcommand) fn_kwargs = self._prepare_subcommand_kwargs(self.subcommand) fn(**fn_kwargs) @@ -399,8 +401,8 @@ def export(self) -> Callable: """Export the model using engine's export method.""" return self.engine.export + @staticmethod def _add_trainer_arguments_to_parser( - self, parser: ArgumentParser, add_optimizer: bool = False, add_scheduler: bool = False, @@ -427,7 +429,8 @@ def _add_trainer_arguments_to_parser( **scheduler_kwargs, ) - def _add_default_arguments_to_parser(self, parser: ArgumentParser) -> None: + @staticmethod + def _add_default_arguments_to_parser(parser: ArgumentParser) -> None: """Adds default arguments to the parser.""" parser.add_argument( "--seed_everything", diff --git a/src/anomalib/cli/install.py b/src/anomalib/cli/install.py index 31432be487..d114c8e168 100644 --- a/src/anomalib/cli/install.py +++ b/src/anomalib/cli/install.py @@ -54,12 +54,12 @@ def anomalib_install(option: str = "full", verbose: bool = False) -> int: # Parse requirements into torch and other requirements. # This is done to parse the correct version of torch (cpu/cuda). - torch_requirement, other_requirements = parse_requirements(requirements, skip_torch=option not in ("full", "core")) + torch_requirement, other_requirements = parse_requirements(requirements, skip_torch=option not in {"full", "core"}) # Get install args for torch to install it from a specific index-url install_args: list[str] = [] torch_install_args = [] - if option in ("full", "core") and torch_requirement is not None: + if option in {"full", "core"} and torch_requirement is not None: torch_install_args = get_torch_install_args(torch_requirement) # Combine torch and other requirements. diff --git a/src/anomalib/cli/pipelines.py b/src/anomalib/cli/pipelines.py index a76e57c298..ba6030491b 100644 --- a/src/anomalib/cli/pipelines.py +++ b/src/anomalib/cli/pipelines.py @@ -6,13 +6,13 @@ import logging from jsonargparse import Namespace +from lightning_utilities.core.imports import module_available from anomalib.cli.utils.help_formatter import get_short_docstring -from anomalib.utils.exceptions import try_import logger = logging.getLogger(__name__) -if try_import("anomalib.pipelines"): +if module_available("anomalib.pipelines"): from anomalib.pipelines import Benchmark from anomalib.pipelines.components.base import Pipeline diff --git a/src/anomalib/cli/utils/help_formatter.py b/src/anomalib/cli/utils/help_formatter.py index 892161d0cc..4535011b09 100644 --- a/src/anomalib/cli/utils/help_formatter.py +++ b/src/anomalib/cli/utils/help_formatter.py @@ -65,7 +65,7 @@ def get_verbosity_subcommand() -> dict: {'subcommand': 'train', 'help': True, 'verbosity': 1} """ arguments: dict = {"subcommand": None, "help": False, "verbosity": 2} - if len(sys.argv) >= 2 and sys.argv[1] not in ("--help", "-h"): + if len(sys.argv) >= 2 and sys.argv[1] not in {"--help", "-h"}: arguments["subcommand"] = sys.argv[1] if "--help" in sys.argv or "-h" in sys.argv: arguments["help"] = True @@ -252,7 +252,7 @@ def format_help(self) -> str: """ with self.console.capture() as capture: section = self._root_section - if self.subcommand in REQUIRED_ARGUMENTS and self.verbosity_level in (0, 1) and len(section.rich_items) > 1: + if self.subcommand in REQUIRED_ARGUMENTS and self.verbosity_level in {0, 1} and len(section.rich_items) > 1: contents = render_guide(self.subcommand) for content in contents: self.console.print(content) diff --git a/src/anomalib/cli/utils/installation.py b/src/anomalib/cli/utils/installation.py index de31ef7d61..01c2f9d288 100644 --- a/src/anomalib/cli/utils/installation.py +++ b/src/anomalib/cli/utils/installation.py @@ -134,7 +134,7 @@ def get_cuda_version() -> str | None: # Check $CUDA_HOME/version.json file. version_file = Path(cuda_home) / "version.json" if version_file.is_file(): - with Path(version_file).open() as file: + with Path(version_file).open(encoding="utf-8") as file: data = json.load(file) cuda_version = data.get("cuda", {}).get("version", None) if cuda_version is not None: @@ -319,7 +319,7 @@ def get_torch_install_args(requirement: str | Requirement) -> list[str]: ) install_args: list[str] = [] - if platform.system() in ("Linux", "Windows"): + if platform.system() in {"Linux", "Windows"}: # Get the hardware suffix (eg., +cpu, +cu116 and +cu118 etc.) hardware_suffix = get_hardware_suffix(with_available_torch_build=True, torch_version=version) @@ -339,7 +339,7 @@ def get_torch_install_args(requirement: str | Requirement) -> list[str]: torch_version, torchvision_requirement, ] - elif platform.system() in ("macos", "Darwin"): + elif platform.system() in {"macos", "Darwin"}: torch_version = str(requirement) install_args += [torch_version] else: diff --git a/src/anomalib/cli/utils/openvino.py b/src/anomalib/cli/utils/openvino.py index 65ac7b80db..50a894c304 100644 --- a/src/anomalib/cli/utils/openvino.py +++ b/src/anomalib/cli/utils/openvino.py @@ -6,13 +6,12 @@ import logging from jsonargparse import ArgumentParser - -from anomalib.utils.exceptions import try_import +from lightning_utilities.core.imports import module_available logger = logging.getLogger(__name__) -if try_import("openvino"): +if module_available("openvino"): from openvino.tools.ovc.cli_parser import get_common_cli_parser else: get_common_cli_parser = None @@ -25,7 +24,7 @@ def add_openvino_export_arguments(parser: ArgumentParser) -> None: ov_parser = get_common_cli_parser() # remove redundant keys from mo keys for arg in ov_parser._actions: # noqa: SLF001 - if arg.dest in ("help", "input_model", "output_dir"): + if arg.dest in {"help", "input_model", "output_dir"}: continue group.add_argument(f"--ov_args.{arg.dest}", type=arg.type, default=arg.default, help=arg.help) else: diff --git a/src/anomalib/data/__init__.py b/src/anomalib/data/__init__.py index e7eaf11156..0ad469ac69 100644 --- a/src/anomalib/data/__init__.py +++ b/src/anomalib/data/__init__.py @@ -14,7 +14,7 @@ from .base import AnomalibDataModule, AnomalibDataset from .depth import DepthDataFormat, Folder3D, MVTec3D -from .image import BTech, Folder, ImageDataFormat, Kolektor, MVTec, Visa +from .image import BTech, Datumaro, Folder, ImageDataFormat, Kolektor, MVTec, Visa from .predict import PredictDataset from .utils import LabelName from .video import Avenue, ShanghaiTech, UCSDped, VideoDataFormat @@ -70,6 +70,7 @@ def get_datamodule(config: DictConfig | ListConfig | dict) -> AnomalibDataModule "VideoDataFormat", "get_datamodule", "BTech", + "Datumaro", "Folder", "Folder3D", "PredictDataset", diff --git a/src/anomalib/data/base/datamodule.py b/src/anomalib/data/base/datamodule.py index cb95ca8171..a9197f6670 100644 --- a/src/anomalib/data/base/datamodule.py +++ b/src/anomalib/data/base/datamodule.py @@ -119,6 +119,8 @@ def __init__( self._is_setup = False # flag to track if setup has been called from the trainer + self.collate_fn = collate_fn + @property def name(self) -> str: """Name of the datamodule.""" @@ -224,6 +226,7 @@ def train_dataloader(self) -> TRAIN_DATALOADERS: shuffle=True, batch_size=self.train_batch_size, num_workers=self.num_workers, + collate_fn=self.collate_fn, ) def val_dataloader(self) -> EVAL_DATALOADERS: @@ -233,7 +236,7 @@ def val_dataloader(self) -> EVAL_DATALOADERS: shuffle=False, batch_size=self.eval_batch_size, num_workers=self.num_workers, - collate_fn=collate_fn, + collate_fn=self.collate_fn, ) def test_dataloader(self) -> EVAL_DATALOADERS: @@ -243,7 +246,7 @@ def test_dataloader(self) -> EVAL_DATALOADERS: shuffle=False, batch_size=self.eval_batch_size, num_workers=self.num_workers, - collate_fn=collate_fn, + collate_fn=self.collate_fn, ) def predict_dataloader(self) -> EVAL_DATALOADERS: diff --git a/src/anomalib/data/base/dataset.py b/src/anomalib/data/base/dataset.py index 7cfba278ac..f1d2ff3149 100644 --- a/src/anomalib/data/base/dataset.py +++ b/src/anomalib/data/base/dataset.py @@ -171,7 +171,7 @@ def __getitem__(self, index: int) -> dict[str, str | torch.Tensor]: if self.task == TaskType.CLASSIFICATION: item["image"] = self.transform(image) if self.transform else image - elif self.task in (TaskType.DETECTION, TaskType.SEGMENTATION): + elif self.task in {TaskType.DETECTION, TaskType.SEGMENTATION}: # Only Anomalous (1) images have masks in anomaly datasets # Therefore, create empty mask for Normal (0) images. mask = ( diff --git a/src/anomalib/data/base/depth.py b/src/anomalib/data/base/depth.py index dbd5377cb6..0ffe0b3a34 100644 --- a/src/anomalib/data/base/depth.py +++ b/src/anomalib/data/base/depth.py @@ -52,7 +52,7 @@ def __getitem__(self, index: int) -> dict[str, str | torch.Tensor]: item["image"], item["depth_image"] = ( self.transform(image, depth_image) if self.transform else (image, depth_image) ) - elif self.task in (TaskType.DETECTION, TaskType.SEGMENTATION): + elif self.task in {TaskType.DETECTION, TaskType.SEGMENTATION}: # Only Anomalous (1) images have masks in anomaly datasets # Therefore, create empty mask for Normal (0) images. mask = ( diff --git a/src/anomalib/data/depth/folder_3d.py b/src/anomalib/data/depth/folder_3d.py index 41a12fbf40..0fac137850 100644 --- a/src/anomalib/data/depth/folder_3d.py +++ b/src/anomalib/data/depth/folder_3d.py @@ -24,7 +24,7 @@ from anomalib.data.utils.path import _prepare_files_labels, validate_and_resolve_path -def make_folder3d_dataset( # noqa: C901 +def make_folder3d_dataset( normal_dir: str | Path, root: str | Path | None = None, abnormal_dir: str | Path | None = None, @@ -78,37 +78,28 @@ def make_folder3d_dataset( # noqa: C901 msg = "A folder location must be provided in normal_dir." raise ValueError(msg) - filenames = [] - labels = [] - dirs = {DirType.NORMAL: normal_dir} - - if abnormal_dir: - dirs[DirType.ABNORMAL] = abnormal_dir - - if normal_test_dir: - dirs[DirType.NORMAL_TEST] = normal_test_dir - - if normal_depth_dir: - dirs[DirType.NORMAL_DEPTH] = normal_depth_dir - - if abnormal_depth_dir: - dirs[DirType.ABNORMAL_DEPTH] = abnormal_depth_dir - - if normal_test_depth_dir: - dirs[DirType.NORMAL_TEST_DEPTH] = normal_test_depth_dir - - if mask_dir: - dirs[DirType.MASK] = mask_dir - - for dir_type, path in dirs.items(): - filename, label = _prepare_files_labels(path, dir_type, extensions) - filenames += filename - labels += label + dirs = { + DirType.NORMAL: normal_dir, + DirType.ABNORMAL: abnormal_dir, + DirType.NORMAL_TEST: normal_test_dir, + DirType.NORMAL_DEPTH: normal_depth_dir, + DirType.ABNORMAL_DEPTH: abnormal_depth_dir, + DirType.NORMAL_TEST_DEPTH: normal_test_depth_dir, + DirType.MASK: mask_dir, + } + + filenames: list[Path] = [] + labels: list[str] = [] + + for dir_type, dir_path in dirs.items(): + if dir_path is not None: + filename, label = _prepare_files_labels(dir_path, dir_type, extensions) + filenames += filename + labels += label samples = DataFrame({"image_path": filenames, "label": labels}) samples = samples.sort_values(by="image_path", ignore_index=True) - # Create label index for normal (0) and abnormal (1) images. samples.loc[ (samples.label == DirType.NORMAL) | (samples.label == DirType.NORMAL_TEST), "label_index", @@ -137,9 +128,12 @@ def make_folder3d_dataset( # noqa: C901 .all() ) if not mismatch: - msg = """Mismatch between anomalous images and depth images. Make sure the mask files - in 'xyz' folder follow the same naming convention as the anomalous images in the dataset - (e.g. image: '000.png', depth: '000.tiff').""" + msg = ( + "Mismatch between anomalous images and depth images. " + "Make sure the mask files in 'xyz' folder follow the same naming " + "convention as the anomalous images in the dataset" + "(e.g. image: '000.png', depth: '000.tiff')." + ) raise MisMatchError(msg) missing_depth_files = samples.depth_path.apply( @@ -159,7 +153,7 @@ def make_folder3d_dataset( # noqa: C901 samples["mask_path"] = samples["mask_path"].fillna("") samples = samples.astype({"mask_path": "str"}) - # make sure all the files exist + # Make sure all the files exist if not samples.mask_path.apply( lambda x: Path(x).exists() if x != "" else True, ).all(): @@ -168,7 +162,7 @@ def make_folder3d_dataset( # noqa: C901 else: samples["mask_path"] = "" - # remove all the rows with temporal image samples that have already been assigned + # Remove all the rows with temporal image samples that have already been assigned samples = samples.loc[ (samples.label == DirType.NORMAL) | (samples.label == DirType.ABNORMAL) | (samples.label == DirType.NORMAL_TEST) ] diff --git a/src/anomalib/data/image/__init__.py b/src/anomalib/data/image/__init__.py index 0bea0f07ad..147db09418 100644 --- a/src/anomalib/data/image/__init__.py +++ b/src/anomalib/data/image/__init__.py @@ -9,6 +9,7 @@ from enum import Enum from .btech import BTech +from .datumaro import Datumaro from .folder import Folder from .kolektor import Kolektor from .mvtec import MVTec @@ -18,13 +19,14 @@ class ImageDataFormat(str, Enum): """Supported Image Dataset Types.""" - MVTEC = "mvtec" - MVTEC_3D = "mvtec_3d" BTECH = "btech" - KOLEKTOR = "kolektor" + DATUMARO = "datumaro" FOLDER = "folder" FOLDER_3D = "folder_3d" + KOLEKTOR = "kolektor" + MVTEC = "mvtec" + MVTEC_3D = "mvtec_3d" VISA = "visa" -__all__ = ["BTech", "Folder", "Kolektor", "MVTec", "Visa"] +__all__ = ["BTech", "Datumaro", "Folder", "Kolektor", "MVTec", "Visa"] diff --git a/src/anomalib/data/image/btech.py b/src/anomalib/data/image/btech.py index 33bbd68c4c..9cceacf947 100644 --- a/src/anomalib/data/image/btech.py +++ b/src/anomalib/data/image/btech.py @@ -81,7 +81,7 @@ def make_btech_dataset(path: Path, split: str | Split | None = None) -> DataFram path = validate_path(path) samples_list = [ - (str(path),) + filename.parts[-3:] for filename in path.glob("**/*") if filename.suffix in (".bmp", ".png") + (str(path),) + filename.parts[-3:] for filename in path.glob("**/*") if filename.suffix in {".bmp", ".png"} ] if not samples_list: msg = f"Found 0 images in {path}" diff --git a/src/anomalib/data/image/datumaro.py b/src/anomalib/data/image/datumaro.py new file mode 100644 index 0000000000..b4836990ec --- /dev/null +++ b/src/anomalib/data/image/datumaro.py @@ -0,0 +1,226 @@ +"""Dataloader for Datumaro format. + +Note: This currently only works for annotations exported from Intel Geti™. +""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import json +from pathlib import Path + +import pandas as pd +from torchvision.transforms.v2 import Transform + +from anomalib import TaskType +from anomalib.data.base import AnomalibDataModule, AnomalibDataset +from anomalib.data.utils import LabelName, Split, TestSplitMode, ValSplitMode + + +def make_datumaro_dataset(root: str | Path, split: str | Split | None = None) -> pd.DataFrame: + """Make Datumaro Dataset. + + Assumes the following directory structure: + + dataset + ├── annotations + │ └── default.json + └── images + └── default + ├── image1.jpg + ├── image2.jpg + └── ... + + Args: + root (str | Path): Path to the dataset root directory. + split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST. + Defaults to ``None``. + + Examples: + >>> root = Path("path/to/dataset") + >>> samples = make_datumaro_dataset(root) + >>> samples.head() + image_path label label_index split mask_path + 0 path/to/dataset... Normal 0 Split.TRAIN + 1 path/to/dataset... Normal 0 Split.TRAIN + 2 path/to/dataset... Normal 0 Split.TRAIN + 3 path/to/dataset... Normal 0 Split.TRAIN + 4 path/to/dataset... Normal 0 Split.TRAIN + + + Returns: + DataFrame: an output dataframe containing samples for the requested split (ie., train or test). + """ + annotation_file = Path(root) / "annotations" / "default.json" + with annotation_file.open() as f: + annotations = json.load(f) + + categories = annotations["categories"] + categories = {idx: label["name"] for idx, label in enumerate(categories["label"]["labels"])} + + samples = [] + for item in annotations["items"]: + image_path = Path(root) / "images" / "default" / item["image"]["path"] + label_index = item["annotations"][0]["label_id"] + label = categories[label_index] + samples.append({ + "image_path": str(image_path), + "label": label, + "label_index": label_index, + "split": None, + "mask_path": "", # mask is provided in the annotation file and is not on disk. + }) + samples_df = pd.DataFrame( + samples, + columns=["image_path", "label", "label_index", "split", "mask_path"], + index=range(len(samples)), + ) + # Create test/train split + # By default assign all "Normal" samples to train and all "Anomalous" samples to test + samples_df.loc[samples_df["label_index"] == LabelName.NORMAL, "split"] = Split.TRAIN + samples_df.loc[samples_df["label_index"] == LabelName.ABNORMAL, "split"] = Split.TEST + + # Get the data frame for the split. + if split: + samples_df = samples_df[samples_df.split == split].reset_index(drop=True) + + return samples_df + + +class DatumaroDataset(AnomalibDataset): + """Datumaro dataset class. + + Args: + task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``. + root (str | Path): Path to the dataset root directory. + transform (Transform, optional): Transforms that should be applied to the input images. + Defaults to ``None``. + split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST + Defaults to ``None``. + + + Examples: + .. code-block:: python + + from anomalib.data.image.datumaro import DatumaroDataset + from torchvision.transforms.v2 import Resize + + dataset = DatumaroDataset(root=root, + task="classification", + transform=Resize((256, 256)), + ) + print(dataset[0].keys()) + # Output: dict_keys(['dm_format_version', 'infos', 'categories', 'items']) + + """ + + def __init__( + self, + task: TaskType, + root: str | Path, + transform: Transform | None = None, + split: str | Split | None = None, + ) -> None: + super().__init__(task, transform) + self.split = split + self.samples = make_datumaro_dataset(root, split) + + +class Datumaro(AnomalibDataModule): + """Datumaro datamodule. + + Args: + root (str | Path): Path to the dataset root directory. + train_batch_size (int): Batch size for training dataloader. + Defaults to ``32``. + eval_batch_size (int): Batch size for evaluation dataloader. + Defaults to ``32``. + num_workers (int): Number of workers for dataloaders. + Defaults to ``8``. + task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``. + Defaults to ``TaskType.CLASSIFICATION``. Currently only supports classification. + image_size (tuple[int, int], optional): Size to which input images should be resized. + Defaults to ``None``. + transform (Transform, optional): Transforms that should be applied to the input images. + Defaults to ``None``. + train_transform (Transform, optional): Transforms that should be applied to the input images during training. + Defaults to ``None``. + eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation. + Defaults to ``None``. + test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained. + Defaults to ``TestSplitMode.FROM_DIR``. + test_split_ratio (float): Fraction of images from the train set that will be reserved for testing. + Defaults to ``0.2``. + val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained. + Defaults to ``ValSplitMode.SAME_AS_TEST``. + val_split_ratio (float): Fraction of train or test images that will be reserved for validation. + Defaults to ``0.5``. + seed (int | None, optional): Seed which may be set to a fixed value for reproducibility. + Defualts to ``None``. + + Examples: + To create a Datumaro datamodule + + >>> from pathlib import Path + >>> from torchvision.transforms.v2 import Resize + >>> root = Path("path/to/dataset") + >>> datamodule = Datumaro(root, transform=Resize((256, 256))) + >>> datamodule.setup() + >>> i, data = next(enumerate(datamodule.train_dataloader())) + >>> data.keys() + dict_keys(['image_path', 'label', 'image']) + + >>> data["image"].shape + torch.Size([32, 3, 256, 256]) + """ + + def __init__( + self, + root: str | Path, + train_batch_size: int = 32, + eval_batch_size: int = 32, + num_workers: int = 8, + task: TaskType = TaskType.CLASSIFICATION, + image_size: tuple[int, int] | None = None, + transform: Transform | None = None, + train_transform: Transform | None = None, + eval_transform: Transform | None = None, + test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR, + test_split_ratio: float = 0.5, + val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST, + val_split_ratio: float = 0.5, + seed: int | None = None, + ) -> None: + if task != TaskType.CLASSIFICATION: + msg = "Datumaro dataloader currently only supports classification task." + raise ValueError(msg) + super().__init__( + train_batch_size=train_batch_size, + eval_batch_size=eval_batch_size, + num_workers=num_workers, + val_split_mode=val_split_mode, + val_split_ratio=val_split_ratio, + test_split_mode=test_split_mode, + test_split_ratio=test_split_ratio, + image_size=image_size, + transform=transform, + train_transform=train_transform, + eval_transform=eval_transform, + seed=seed, + ) + self.root = root + self.task = task + + def _setup(self, _stage: str | None = None) -> None: + self.train_data = DatumaroDataset( + task=self.task, + root=self.root, + transform=self.train_transform, + split=Split.TRAIN, + ) + self.test_data = DatumaroDataset( + task=self.task, + root=self.root, + transform=self.eval_transform, + split=Split.TEST, + ) diff --git a/src/anomalib/data/utils/download.py b/src/anomalib/data/utils/download.py index 93fd14cbe4..7df5da1403 100644 --- a/src/anomalib/data/utils/download.py +++ b/src/anomalib/data/utils/download.py @@ -299,7 +299,7 @@ def extract(file_name: Path, root: Path) -> None: zip_file.extract(file_info, root) # Safely extract tar files. - elif file_name.suffix in (".tar", ".gz", ".xz", ".tgz"): + elif file_name.suffix in {".tar", ".gz", ".xz", ".tgz"}: with tarfile.open(file_name) as tar_file: members = tar_file.getmembers() safe_members = [member for member in members if not is_file_potentially_dangerous(member.name)] diff --git a/src/anomalib/data/utils/path.py b/src/anomalib/data/utils/path.py index 9c3f56273b..7bc61b27fe 100644 --- a/src/anomalib/data/utils/path.py +++ b/src/anomalib/data/utils/path.py @@ -142,13 +142,20 @@ def contains_non_printable_characters(path: str | Path) -> bool: return not printable_pattern.match(str(path)) -def validate_path(path: str | Path, base_dir: str | Path | None = None, should_exist: bool = True) -> Path: +def validate_path( + path: str | Path, + base_dir: str | Path | None = None, + should_exist: bool = True, + extensions: tuple[str, ...] | None = None, +) -> Path: """Validate the path. Args: path (str | Path): Path to validate. base_dir (str | Path): Base directory to restrict file access. should_exist (bool): If True, do not raise an exception if the path does not exist. + extensions (tuple[str, ...] | None): Accepted extensions for the path. An exception is raised if the + path does not have one of the accepted extensions. If None, no check is performed. Defaults to None. Returns: Path: Validated path. @@ -213,6 +220,11 @@ def validate_path(path: str | Path, base_dir: str | Path | None = None, should_e msg = f"Read or execute permissions denied for the path: {path}" raise PermissionError(msg) + # Check if the path has one of the accepted extensions + if extensions is not None and path.suffix not in extensions: + msg = f"Path extension is not accepted. Accepted extensions: {extensions}. Path: {path}" + raise ValueError(msg) + return path diff --git a/src/anomalib/data/utils/tiler.py b/src/anomalib/data/utils/tiler.py index 6fd87223bf..2c1e949e45 100644 --- a/src/anomalib/data/utils/tiler.py +++ b/src/anomalib/data/utils/tiler.py @@ -162,11 +162,11 @@ def __init__( remove_border_count: int = 0, mode: ImageUpscaleMode = ImageUpscaleMode.PADDING, ) -> None: - self.tile_size_h, self.tile_size_w = self.__validate_size_type(tile_size) + self.tile_size_h, self.tile_size_w = self.validate_size_type(tile_size) self.random_tile_count = 4 if stride is not None: - self.stride_h, self.stride_w = self.__validate_size_type(stride) + self.stride_h, self.stride_w = self.validate_size_type(stride) self.remove_border_count = remove_border_count self.overlapping = not (self.stride_h == self.tile_size_h and self.stride_w == self.tile_size_w) @@ -181,7 +181,7 @@ def __init__( msg, ) - if self.mode not in (ImageUpscaleMode.PADDING, ImageUpscaleMode.INTERPOLATION): + if self.mode not in {ImageUpscaleMode.PADDING, ImageUpscaleMode.INTERPOLATION}: msg = f"Unknown tiling mode {self.mode}. Available modes are padding and interpolation" raise ValueError(msg) @@ -201,7 +201,15 @@ def __init__( self.num_patches_w: int @staticmethod - def __validate_size_type(parameter: int | Sequence) -> tuple[int, ...]: + def validate_size_type(parameter: int | Sequence) -> tuple[int, ...]: + """Validate size type and return tuple of form [tile_h, tile_w]. + + Args: + parameter (int | Sequence): input tile size parameter. + + Returns: + tuple[int, ...]: Validated tile size in tuple form. + """ if isinstance(parameter, int): output = (parameter, parameter) elif isinstance(parameter, Sequence): diff --git a/src/anomalib/data/video/shanghaitech.py b/src/anomalib/data/video/shanghaitech.py index 6c0055dd31..0a1b09bfe4 100644 --- a/src/anomalib/data/video/shanghaitech.py +++ b/src/anomalib/data/video/shanghaitech.py @@ -118,7 +118,8 @@ class ShanghaiTechTrainClipsIndexer(ClipsIndexer): clips indexer implementations are needed. """ - def get_mask(self, idx: int) -> torch.Tensor | None: + @staticmethod + def get_mask(idx: int) -> torch.Tensor | None: """No masks available for training set.""" del idx # Unused argument return None diff --git a/src/anomalib/deploy/inferencers/base_inferencer.py b/src/anomalib/deploy/inferencers/base_inferencer.py index 05f8d65ba0..b549b32a19 100644 --- a/src/anomalib/deploy/inferencers/base_inferencer.py +++ b/src/anomalib/deploy/inferencers/base_inferencer.py @@ -118,7 +118,7 @@ def _normalize( return anomaly_maps, float(pred_scores) - def _load_metadata(self, path: str | Path | dict | None = None) -> dict | DictConfig: + def _load_metadata(self, path: str | Path | dict | None = None) -> dict | DictConfig: # noqa: PLR6301 """Load the meta data from the given path. Args: diff --git a/src/anomalib/deploy/inferencers/openvino_inferencer.py b/src/anomalib/deploy/inferencers/openvino_inferencer.py index 7ed44a99da..b85df0536c 100644 --- a/src/anomalib/deploy/inferencers/openvino_inferencer.py +++ b/src/anomalib/deploy/inferencers/openvino_inferencer.py @@ -4,12 +4,12 @@ # SPDX-License-Identifier: Apache-2.0 import logging -from importlib.util import find_spec from pathlib import Path -from typing import TYPE_CHECKING, Any +from typing import Any import cv2 import numpy as np +from lightning_utilities.core.imports import module_available from omegaconf import DictConfig from PIL import Image @@ -21,14 +21,6 @@ logger = logging.getLogger("anomalib") -if find_spec("openvino") is not None: - import openvino as ov - - if TYPE_CHECKING: - from openvino import CompiledModel -else: - logger.warning("OpenVINO is not installed. Please install OpenVINO to use OpenVINOInferencer.") - class OpenVINOInferencer(Inferencer): """OpenVINO implementation for the inference. @@ -102,6 +94,10 @@ def __init__( task: str | None = None, config: dict | None = None, ) -> None: + if not module_available("openvino"): + msg = "OpenVINO is not installed. Please install OpenVINO to use OpenVINOInferencer." + raise ImportError(msg) + self.device = device self.config = config @@ -110,7 +106,7 @@ def __init__( self.task = TaskType(task) if task else TaskType(self.metadata["task"]) - def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any, "CompiledModel"]: + def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any, Any]: """Load the OpenVINO model. Args: @@ -121,13 +117,15 @@ def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any, [tuple[str, str, ExecutableNetwork]]: Input and Output blob names together with the Executable network. """ + import openvino as ov + core = ov.Core() # If tuple of bytes is passed if isinstance(path, tuple): model = core.read_model(model=path[0], weights=path[1]) else: path = path if isinstance(path, Path) else Path(path) - if path.suffix in (".bin", ".xml"): + if path.suffix in {".bin", ".xml"}: if path.suffix == ".bin": bin_path, xml_path = path, path.with_suffix(".xml") elif path.suffix == ".xml": @@ -150,7 +148,8 @@ def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any, return input_blob, output_blob, compile_model - def pre_process(self, image: np.ndarray) -> np.ndarray: + @staticmethod + def pre_process(image: np.ndarray) -> np.ndarray: """Pre-process the input image by applying transformations. Args: @@ -279,7 +278,7 @@ def post_process(self, predictions: np.ndarray, metadata: dict | DictConfig | No if task == TaskType.CLASSIFICATION: _, pred_score = self._normalize(pred_scores=pred_score, metadata=metadata) - elif task in (TaskType.SEGMENTATION, TaskType.DETECTION): + elif task in {TaskType.SEGMENTATION, TaskType.DETECTION}: if "pixel_threshold" in metadata: pred_mask = (anomaly_map >= metadata["pixel_threshold"]).astype(np.uint8) diff --git a/src/anomalib/deploy/inferencers/torch_inferencer.py b/src/anomalib/deploy/inferencers/torch_inferencer.py index 3b57eddc04..840063421c 100644 --- a/src/anomalib/deploy/inferencers/torch_inferencer.py +++ b/src/anomalib/deploy/inferencers/torch_inferencer.py @@ -80,7 +80,7 @@ def _get_device(device: str) -> torch.device: Returns: torch.device: Device to use for inference. """ - if device not in ("auto", "cpu", "cuda", "gpu"): + if device not in {"auto", "cpu", "cuda", "gpu"}: msg = f"Unknown device {device}" raise ValueError(msg) @@ -102,7 +102,7 @@ def _load_checkpoint(self, path: str | Path) -> dict: if isinstance(path, str): path = Path(path) - if path.suffix not in (".pt", ".pth"): + if path.suffix not in {".pt", ".pth"}: msg = f"Unknown torch checkpoint file format {path.suffix}. Make sure you save the Torch model." raise ValueError(msg) diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py index 8648cf30ae..b537819729 100644 --- a/src/anomalib/engine/engine.py +++ b/src/anomalib/engine/engine.py @@ -9,7 +9,7 @@ from typing import Any import torch -from lightning.pytorch.callbacks import Callback, RichModelSummary, RichProgressBar +from lightning.pytorch.callbacks import Callback from lightning.pytorch.loggers import Logger from lightning.pytorch.trainer import Trainer from lightning.pytorch.utilities.types import _EVALUATE_OUTPUT, _PREDICT_OUTPUT, EVAL_DATALOADERS, TRAIN_DATALOADERS @@ -32,7 +32,7 @@ from anomalib.utils.normalization import NormalizationMethod from anomalib.utils.path import create_versioned_dir from anomalib.utils.types import NORMALIZATION, THRESHOLD -from anomalib.utils.visualization import ImageVisualizer +from anomalib.utils.visualization import BaseVisualizer, ExplanationVisualizer, ImageVisualizer logger = logging.getLogger(__name__) @@ -322,7 +322,7 @@ def _setup_trainer(self, model: AnomalyModule) -> None: self._cache.update(model) # Setup anomalib callbacks to be used with the trainer - self._setup_anomalib_callbacks() + self._setup_anomalib_callbacks(model) # Temporarily set devices to 1 to avoid issues with multiple processes self._cache.args["devices"] = 1 @@ -405,9 +405,9 @@ def _setup_transform( if not getattr(dataloader.dataset, "transform", None): dataloader.dataset.transform = transform - def _setup_anomalib_callbacks(self) -> None: + def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None: """Set up callbacks for the trainer.""" - _callbacks: list[Callback] = [RichProgressBar(), RichModelSummary()] + _callbacks: list[Callback] = [] # Add ModelCheckpoint if it is not in the callbacks list. has_checkpoint_callback = any(isinstance(c, ModelCheckpoint) for c in self._cache.args["callbacks"]) @@ -432,9 +432,17 @@ def _setup_anomalib_callbacks(self) -> None: _callbacks.append(_ThresholdCallback(self.threshold)) _callbacks.append(_MetricsCallback(self.task, self.image_metric_names, self.pixel_metric_names)) + visualizer: BaseVisualizer + + # TODO(ashwinvaidya17): temporary # noqa: TD003 ignoring as visualizer is getting a complete overhaul + if model.__class__.__name__ == "VlmAd": + visualizer = ExplanationVisualizer() + else: + visualizer = ImageVisualizer(task=self.task, normalize=self.normalization == NormalizationMethod.NONE) + _callbacks.append( _VisualizationCallback( - visualizers=ImageVisualizer(task=self.task, normalize=self.normalization == NormalizationMethod.NONE), + visualizers=visualizer, save=True, root=self._cache.args["default_root_dir"] / "images", ), @@ -474,7 +482,7 @@ def _should_run_validation( bool: Whether it is needed to run a validation sequence. """ # validation before predict is only necessary for zero-/few-shot models - if model.learning_type not in [LearningType.ZERO_SHOT, LearningType.FEW_SHOT]: + if model.learning_type not in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}: return False # check if a checkpoint path is provided if ckpt_path is not None: @@ -534,7 +542,7 @@ def fit( self._setup_trainer(model) self._setup_dataset_task(train_dataloaders, val_dataloaders, datamodule) self._setup_transform(model, datamodule=datamodule, ckpt_path=ckpt_path) - if model.learning_type in [LearningType.ZERO_SHOT, LearningType.FEW_SHOT]: + if model.learning_type in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}: # if the model is zero-shot or few-shot, we only need to run validate for normalization and thresholding self.trainer.validate(model, val_dataloaders, datamodule=datamodule, ckpt_path=ckpt_path) else: @@ -856,7 +864,7 @@ def train( datamodule, ) self._setup_transform(model, datamodule=datamodule, ckpt_path=ckpt_path) - if model.learning_type in [LearningType.ZERO_SHOT, LearningType.FEW_SHOT]: + if model.learning_type in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}: # if the model is zero-shot or few-shot, we only need to run validate for normalization and thresholding self.trainer.validate(model, val_dataloaders, None, verbose=False, datamodule=datamodule) else: @@ -912,22 +920,22 @@ def export( CLI Usage: 1. To export as a torch ``.pt`` file you can run the following command. ```python - anomalib export --model Padim --export_mode torch --ckpt_path + anomalib export --model Padim --export_type torch --ckpt_path ``` 2. To export as an ONNX ``.onnx`` file you can run the following command. ```python - anomalib export --model Padim --export_mode onnx --ckpt_path \ + anomalib export --model Padim --export_type onnx --ckpt_path \ --input_size "[256,256]" ``` 3. To export as an OpenVINO ``.xml`` and ``.bin`` file you can run the following command. ```python - anomalib export --model Padim --export_mode openvino --ckpt_path \ - --input_size "[256,256] --compression_type "fp16" + anomalib export --model Padim --export_type openvino --ckpt_path \ + --input_size "[256,256] --compression_type FP16 ``` 4. You can also quantize OpenVINO model with the following. ```python - anomalib export --model Padim --export_mode openvino --ckpt_path \ - --input_size "[256,256]" --compression_type "int8_ptq" --data MVTec + anomalib export --model Padim --export_type openvino --ckpt_path \ + --input_size "[256,256]" --compression_type INT8_PTQ --data MVTec ``` """ export_type = ExportType(export_type) diff --git a/src/anomalib/loggers/mlflow.py b/src/anomalib/loggers/mlflow.py index f98723e6f4..f6ec089586 100644 --- a/src/anomalib/loggers/mlflow.py +++ b/src/anomalib/loggers/mlflow.py @@ -1,5 +1,8 @@ """MLFlow logger with add image interface.""" +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + import os from typing import Literal diff --git a/src/anomalib/loggers/wandb.py b/src/anomalib/loggers/wandb.py index 0a23c25192..ff41a0949e 100644 --- a/src/anomalib/loggers/wandb.py +++ b/src/anomalib/loggers/wandb.py @@ -9,13 +9,12 @@ from lightning.fabric.utilities.types import _PATH from lightning.pytorch.loggers.wandb import WandbLogger from lightning.pytorch.utilities import rank_zero_only +from lightning_utilities.core.imports import module_available from matplotlib.figure import Figure -from anomalib.utils.exceptions import try_import - from .base import ImageLoggerBase -if try_import("wandb"): +if module_available("wandb"): import wandb if TYPE_CHECKING: diff --git a/src/anomalib/metrics/__init__.py b/src/anomalib/metrics/__init__.py index 4c3eafa811..81bab3c93f 100644 --- a/src/anomalib/metrics/__init__.py +++ b/src/anomalib/metrics/__init__.py @@ -19,6 +19,7 @@ from .f1_max import F1Max from .f1_score import F1Score from .min_max import MinMax +from .pimo import AUPIMO, PIMO from .precision_recall_curve import BinaryPrecisionRecallCurve from .pro import PRO from .threshold import F1AdaptiveThreshold, ManualThreshold @@ -35,6 +36,8 @@ "ManualThreshold", "MinMax", "PRO", + "PIMO", + "AUPIMO", ] logger = logging.getLogger(__name__) diff --git a/src/anomalib/metrics/pimo/__init__.py b/src/anomalib/metrics/pimo/__init__.py new file mode 100644 index 0000000000..174f546e4d --- /dev/null +++ b/src/anomalib/metrics/pimo/__init__.py @@ -0,0 +1,23 @@ +"""Per-Image Metrics.""" + +# Original Code +# https://github.com/jpcbertoldo/aupimo +# +# Modified +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from .binary_classification_curve import ThresholdMethod +from .pimo import AUPIMO, PIMO, AUPIMOResult, PIMOResult + +__all__ = [ + # constants + "ThresholdMethod", + # result classes + "PIMOResult", + "AUPIMOResult", + # torchmetrics interfaces + "PIMO", + "AUPIMO", + "StatsOutliersPolicy", +] diff --git a/src/anomalib/metrics/pimo/_validate.py b/src/anomalib/metrics/pimo/_validate.py new file mode 100644 index 0000000000..f0ba7af4bf --- /dev/null +++ b/src/anomalib/metrics/pimo/_validate.py @@ -0,0 +1,427 @@ +"""Utils for validating arguments and results. + +TODO(jpcbertoldo): Move validations to a common place and reuse them across the codebase. +https://github.com/openvinotoolkit/anomalib/issues/2093 +""" + +# Original Code +# https://github.com/jpcbertoldo/aupimo +# +# Modified +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging + +import torch +from torch import Tensor + +from .utils import images_classes_from_masks + +logger = logging.getLogger(__name__) + + +def is_num_thresholds_gte2(num_thresholds: int) -> None: + """Validate the number of thresholds is a positive integer >= 2.""" + if not isinstance(num_thresholds, int): + msg = f"Expected the number of thresholds to be an integer, but got {type(num_thresholds)}" + raise TypeError(msg) + + if num_thresholds < 2: + msg = f"Expected the number of thresholds to be larger than 1, but got {num_thresholds}" + raise ValueError(msg) + + +def is_same_shape(*args) -> None: + """Works both for tensors and ndarrays.""" + assert len(args) > 0 + shapes = sorted({tuple(arg.shape) for arg in args}) + if len(shapes) > 1: + msg = f"Expected arguments to have the same shape, but got {shapes}" + raise ValueError(msg) + + +def is_rate(rate: float | int, zero_ok: bool, one_ok: bool) -> None: + """Validates a rate parameter. + + Args: + rate (float | int): The rate to be validated. + zero_ok (bool): Flag indicating if rate can be 0. + one_ok (bool): Flag indicating if rate can be 1. + """ + if not isinstance(rate, float | int): + msg = f"Expected rate to be a float or int, but got {type(rate)}." + raise TypeError(msg) + + if rate < 0.0 or rate > 1.0: + msg = f"Expected rate to be in [0, 1], but got {rate}." + raise ValueError(msg) + + if not zero_ok and rate == 0.0: + msg = "Rate cannot be 0." + raise ValueError(msg) + + if not one_ok and rate == 1.0: + msg = "Rate cannot be 1." + raise ValueError(msg) + + +def is_rate_range(bounds: tuple[float, float]) -> None: + """Validates the range of rates within the bounds. + + Args: + bounds (tuple[float, float]): The lower and upper bounds of the rates. + """ + if not isinstance(bounds, tuple): + msg = f"Expected the bounds to be a tuple, but got {type(bounds)}" + raise TypeError(msg) + + if len(bounds) != 2: + msg = f"Expected the bounds to be a tuple of length 2, but got {len(bounds)}" + raise ValueError(msg) + + lower, upper = bounds + is_rate(lower, zero_ok=False, one_ok=False) + is_rate(upper, zero_ok=False, one_ok=True) + + if lower >= upper: + msg = f"Expected the upper bound to be larger than the lower bound, but got {upper=} <= {lower=}" + raise ValueError(msg) + + +def is_valid_threshold(thresholds: Tensor) -> None: + """Validate that the thresholds are valid and monotonically increasing.""" + if not isinstance(thresholds, Tensor): + msg = f"Expected thresholds to be an Tensor, but got {type(thresholds)}" + raise TypeError(msg) + + if thresholds.ndim != 1: + msg = f"Expected thresholds to be 1D, but got {thresholds.ndim}" + raise ValueError(msg) + + if not thresholds.dtype.is_floating_point: + msg = f"Expected thresholds to be of float type, but got Tensor with dtype {thresholds.dtype}" + raise TypeError(msg) + + # make sure they are strictly increasing + if not torch.all(torch.diff(thresholds) > 0): + msg = "Expected thresholds to be strictly increasing, but it is not." + raise ValueError(msg) + + +def validate_threshold_bounds(threshold_bounds: tuple[float, float]) -> None: + if not isinstance(threshold_bounds, tuple): + msg = f"Expected threshold bounds to be a tuple, but got {type(threshold_bounds)}." + raise TypeError(msg) + + if len(threshold_bounds) != 2: + msg = f"Expected threshold bounds to be a tuple of length 2, but got {len(threshold_bounds)}." + raise ValueError(msg) + + lower, upper = threshold_bounds + + if not isinstance(lower, float): + msg = f"Expected lower threshold bound to be a float, but got {type(lower)}." + raise TypeError(msg) + + if not isinstance(upper, float): + msg = f"Expected upper threshold bound to be a float, but got {type(upper)}." + raise TypeError(msg) + + if upper <= lower: + msg = f"Expected the upper bound to be greater than the lower bound, but got {upper} <= {lower}." + raise ValueError(msg) + + +def is_anomaly_maps(anomaly_maps: Tensor) -> None: + if anomaly_maps.ndim != 3: + msg = f"Expected anomaly maps have 3 dimensions (N, H, W), but got {anomaly_maps.ndim} dimensions" + raise ValueError(msg) + + if not anomaly_maps.dtype.is_floating_point: + msg = ( + "Expected anomaly maps to be an floating Tensor with anomaly scores," + f" but got Tensor with dtype {anomaly_maps.dtype}" + ) + raise TypeError(msg) + + +def is_masks(masks: Tensor) -> None: + if masks.ndim != 3: + msg = f"Expected masks have 3 dimensions (N, H, W), but got {masks.ndim} dimensions" + raise ValueError(msg) + + if masks.dtype == torch.bool: + pass + elif masks.dtype.is_floating_point: + msg = ( + "Expected masks to be an integer or boolean Tensor with ground truth labels, " + f"but got Tensor with dtype {masks.dtype}" + ) + raise TypeError(msg) + else: + # assumes the type to be (signed or unsigned) integer + # this will change with the dataclass refactor + masks_unique_vals = torch.unique(masks) + if torch.any((masks_unique_vals != 0) & (masks_unique_vals != 1)): + msg = ( + "Expected masks to be a *binary* Tensor with ground truth labels, " + f"but got Tensor with unique values {sorted(masks_unique_vals)}" + ) + raise ValueError(msg) + + +def is_binclf_curves(binclf_curves: Tensor, valid_thresholds: Tensor | None) -> None: + if binclf_curves.ndim != 4: + msg = f"Expected binclf curves to be 4D, but got {binclf_curves.ndim}D" + raise ValueError(msg) + + if binclf_curves.shape[-2:] != (2, 2): + msg = f"Expected binclf curves to have shape (..., 2, 2), but got {binclf_curves.shape}" + raise ValueError(msg) + + if binclf_curves.dtype != torch.int64: + msg = f"Expected binclf curves to have dtype int64, but got {binclf_curves.dtype}." + raise TypeError(msg) + + if (binclf_curves < 0).any(): + msg = "Expected binclf curves to have non-negative values, but got negative values." + raise ValueError(msg) + + neg = binclf_curves[:, :, 0, :].sum(axis=-1) # (num_images, num_thresholds) + + if (neg != neg[:, :1]).any(): + msg = "Expected binclf curves to have the same number of negatives per image for every thresh." + raise ValueError(msg) + + pos = binclf_curves[:, :, 1, :].sum(axis=-1) # (num_images, num_thresholds) + + if (pos != pos[:, :1]).any(): + msg = "Expected binclf curves to have the same number of positives per image for every thresh." + raise ValueError(msg) + + if valid_thresholds is None: + return + + if binclf_curves.shape[1] != valid_thresholds.shape[0]: + msg = ( + "Expected the binclf curves to have as many confusion matrices as the thresholds sequence, " + f"but got {binclf_curves.shape[1]} and {valid_thresholds.shape[0]}" + ) + raise RuntimeError(msg) + + +def is_images_classes(images_classes: Tensor) -> None: + if images_classes.ndim != 1: + msg = f"Expected image classes to be 1D, but got {images_classes.ndim}D." + raise ValueError(msg) + + if images_classes.dtype == torch.bool: + pass + elif images_classes.dtype.is_floating_point: + msg = ( + "Expected image classes to be an integer or boolean Tensor with ground truth labels, " + f"but got Tensor with dtype {images_classes.dtype}" + ) + raise TypeError(msg) + else: + # assumes the type to be (signed or unsigned) integer + # this will change with the dataclass refactor + unique_vals = torch.unique(images_classes) + if torch.any((unique_vals != 0) & (unique_vals != 1)): + msg = ( + "Expected image classes to be a *binary* Tensor with ground truth labels, " + f"but got Tensor with unique values {sorted(unique_vals)}" + ) + raise ValueError(msg) + + +def is_rates(rates: Tensor, nan_allowed: bool) -> None: + if rates.ndim != 1: + msg = f"Expected rates to be 1D, but got {rates.ndim}D." + raise ValueError(msg) + + if not rates.dtype.is_floating_point: + msg = f"Expected rates to have dtype of float type, but got {rates.dtype}." + raise ValueError(msg) + + isnan_mask = torch.isnan(rates) + if nan_allowed: + # if they are all nan, then there is nothing to validate + if isnan_mask.all(): + return + valid_values = rates[~isnan_mask] + elif isnan_mask.any(): + msg = "Expected rates to not contain NaN values, but got NaN values." + raise ValueError(msg) + else: + valid_values = rates + + if (valid_values < 0).any(): + msg = "Expected rates to have values in the interval [0, 1], but got values < 0." + raise ValueError(msg) + + if (valid_values > 1).any(): + msg = "Expected rates to have values in the interval [0, 1], but got values > 1." + raise ValueError(msg) + + +def is_rate_curve(rate_curve: Tensor, nan_allowed: bool, decreasing: bool) -> None: + is_rates(rate_curve, nan_allowed=nan_allowed) + + diffs = torch.diff(rate_curve) + diffs_valid = diffs[~torch.isnan(diffs)] if nan_allowed else diffs + + if decreasing and (diffs_valid > 0).any(): + msg = "Expected rate curve to be monotonically decreasing, but got non-monotonically decreasing values." + raise ValueError(msg) + + if not decreasing and (diffs_valid < 0).any(): + msg = "Expected rate curve to be monotonically increasing, but got non-monotonically increasing values." + raise ValueError(msg) + + +def is_per_image_rate_curves(rate_curves: Tensor, nan_allowed: bool, decreasing: bool | None) -> None: + if rate_curves.ndim != 2: + msg = f"Expected per-image rate curves to be 2D, but got {rate_curves.ndim}D." + raise ValueError(msg) + + if not rate_curves.dtype.is_floating_point: + msg = f"Expected per-image rate curves to have dtype of float type, but got {rate_curves.dtype}." + raise ValueError(msg) + + isnan_mask = torch.isnan(rate_curves) + if nan_allowed: + # if they are all nan, then there is nothing to validate + if isnan_mask.all(): + return + valid_values = rate_curves[~isnan_mask] + elif isnan_mask.any(): + msg = "Expected per-image rate curves to not contain NaN values, but got NaN values." + raise ValueError(msg) + else: + valid_values = rate_curves + + if (valid_values < 0).any(): + msg = "Expected per-image rate curves to have values in the interval [0, 1], but got values < 0." + raise ValueError(msg) + + if (valid_values > 1).any(): + msg = "Expected per-image rate curves to have values in the interval [0, 1], but got values > 1." + raise ValueError(msg) + + if decreasing is None: + return + + diffs = torch.diff(rate_curves, axis=1) + diffs_valid = diffs[~torch.isnan(diffs)] if nan_allowed else diffs + + if decreasing and (diffs_valid > 0).any(): + msg = ( + "Expected per-image rate curves to be monotonically decreasing, " + "but got non-monotonically decreasing values." + ) + raise ValueError(msg) + + if not decreasing and (diffs_valid < 0).any(): + msg = ( + "Expected per-image rate curves to be monotonically increasing, " + "but got non-monotonically increasing values." + ) + raise ValueError(msg) + + +def is_scores_batch(scores_batch: torch.Tensor) -> None: + """scores_batch (torch.Tensor): floating (N, D).""" + if not isinstance(scores_batch, torch.Tensor): + msg = f"Expected `scores_batch` to be an torch.Tensor, but got {type(scores_batch)}" + raise TypeError(msg) + + if not scores_batch.dtype.is_floating_point: + msg = ( + "Expected `scores_batch` to be an floating torch.Tensor with anomaly scores_batch," + f" but got torch.Tensor with dtype {scores_batch.dtype}" + ) + raise TypeError(msg) + + if scores_batch.ndim != 2: + msg = f"Expected `scores_batch` to be 2D, but got {scores_batch.ndim}" + raise ValueError(msg) + + +def is_gts_batch(gts_batch: torch.Tensor) -> None: + """gts_batch (torch.Tensor): boolean (N, D).""" + if not isinstance(gts_batch, torch.Tensor): + msg = f"Expected `gts_batch` to be an torch.Tensor, but got {type(gts_batch)}" + raise TypeError(msg) + + if gts_batch.dtype != torch.bool: + msg = ( + "Expected `gts_batch` to be an boolean torch.Tensor with anomaly scores_batch," + f" but got torch.Tensor with dtype {gts_batch.dtype}" + ) + raise TypeError(msg) + + if gts_batch.ndim != 2: + msg = f"Expected `gts_batch` to be 2D, but got {gts_batch.ndim}" + raise ValueError(msg) + + +def has_at_least_one_anomalous_image(masks: torch.Tensor) -> None: + is_masks(masks) + image_classes = images_classes_from_masks(masks) + if (image_classes == 1).sum() == 0: + msg = "Expected at least one ANOMALOUS image, but found none." + raise ValueError(msg) + + +def has_at_least_one_normal_image(masks: torch.Tensor) -> None: + is_masks(masks) + image_classes = images_classes_from_masks(masks) + if (image_classes == 0).sum() == 0: + msg = "Expected at least one NORMAL image, but found none." + raise ValueError(msg) + + +def joint_validate_thresholds_shared_fpr(thresholds: torch.Tensor, shared_fpr: torch.Tensor) -> None: + if thresholds.shape[0] != shared_fpr.shape[0]: + msg = ( + "Expected `thresholds` and `shared_fpr` to have the same number of elements, " + f"but got {thresholds.shape[0]} != {shared_fpr.shape[0]}" + ) + raise ValueError(msg) + + +def is_per_image_tprs(per_image_tprs: torch.Tensor, image_classes: torch.Tensor) -> None: + is_images_classes(image_classes) + # general validations + is_per_image_rate_curves( + per_image_tprs, + nan_allowed=True, # normal images have NaN TPRs + decreasing=None, # not checked here + ) + + # specific to anomalous images + is_per_image_rate_curves( + per_image_tprs[image_classes == 1], + nan_allowed=False, + decreasing=True, + ) + + # specific to normal images + normal_images_tprs = per_image_tprs[image_classes == 0] + if not normal_images_tprs.isnan().all(): + msg = "Expected all normal images to have NaN TPRs, but some have non-NaN values." + raise ValueError(msg) + + +def is_per_image_scores(per_image_scores: torch.Tensor) -> None: + if per_image_scores.ndim != 1: + msg = f"Expected per-image scores to be 1D, but got {per_image_scores.ndim}D." + raise ValueError(msg) + + +def is_image_class(image_class: int) -> None: + if image_class not in {0, 1}: + msg = f"Expected image class to be either 0 for 'normal' or 1 for 'anomalous', but got {image_class}." + raise ValueError(msg) diff --git a/src/anomalib/metrics/pimo/binary_classification_curve.py b/src/anomalib/metrics/pimo/binary_classification_curve.py new file mode 100644 index 0000000000..1a80944041 --- /dev/null +++ b/src/anomalib/metrics/pimo/binary_classification_curve.py @@ -0,0 +1,334 @@ +"""Binary classification curve (numpy-only implementation). + +A binary classification (binclf) matrix (TP, FP, FN, TN) is evaluated at multiple thresholds. + +The thresholds are shared by all instances/images, but their binclf are computed independently for each instance/image. +""" + +# Original Code +# https://github.com/jpcbertoldo/aupimo +# +# Modified +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import itertools +import logging +from enum import Enum +from functools import partial + +import numpy as np +import torch + +from . import _validate + +logger = logging.getLogger(__name__) + + +class ThresholdMethod(Enum): + """Sequence of thresholds to use.""" + + GIVEN: str = "given" + MINMAX_LINSPACE: str = "minmax-linspace" + MEAN_FPR_OPTIMIZED: str = "mean-fpr-optimized" + + +def _binary_classification_curve(scores: np.ndarray, gts: np.ndarray, thresholds: np.ndarray) -> np.ndarray: + """One binary classification matrix at each threshold. + + In the case where the thresholds are given (i.e. not considering all possible thresholds based on the scores), + this weird-looking function is faster than the two options in `torchmetrics` on the CPU: + - `_binary_precision_recall_curve_update_vectorized` + - `_binary_precision_recall_curve_update_loop` + (both in module `torchmetrics.functional.classification.precision_recall_curve` in `torchmetrics==1.1.0`). + Note: VALIDATION IS NOT DONE HERE. Make sure to validate the arguments before calling this function. + + Args: + scores (np.ndarray): Anomaly scores (D,). + gts (np.ndarray): Binary (bool) ground truth of shape (D,). + thresholds (np.ndarray): Sequence of thresholds in ascending order (K,). + + Returns: + np.ndarray: Binary classification matrix curve (K, 2, 2) + Details: `anomalib.metrics.per_image.binclf_curve_numpy.binclf_multiple_curves`. + """ + num_th = len(thresholds) + + # POSITIVES + scores_positives = scores[gts] + # the sorting is very important for the algorithm to work and the speedup + scores_positives = np.sort(scores_positives) + # variable updated in the loop; start counting with lowest thresh ==> everything is predicted as positive + num_pos = current_count_tp = scores_positives.size + tps = np.empty((num_th,), dtype=np.int64) + + # NEGATIVES + # same thing but for the negative samples + scores_negatives = scores[~gts] + scores_negatives = np.sort(scores_negatives) + num_neg = current_count_fp = scores_negatives.size + fps = np.empty((num_th,), dtype=np.int64) + + def score_less_than_thresh(score: float, thresh: float) -> bool: + return score < thresh + + # it will progressively drop the scores that are below the current thresh + for thresh_idx, thresh in enumerate(thresholds): + # UPDATE POSITIVES + # < becasue it is the same as ~(>=) + num_drop = sum(1 for _ in itertools.takewhile(partial(score_less_than_thresh, thresh=thresh), scores_positives)) + scores_positives = scores_positives[num_drop:] + current_count_tp -= num_drop + tps[thresh_idx] = current_count_tp + + # UPDATE NEGATIVES + # same with the negatives + num_drop = sum(1 for _ in itertools.takewhile(partial(score_less_than_thresh, thresh=thresh), scores_negatives)) + scores_negatives = scores_negatives[num_drop:] + current_count_fp -= num_drop + fps[thresh_idx] = current_count_fp + + # deduce the rest of the matrix counts + fns = num_pos * np.ones((num_th,), dtype=np.int64) - tps + tns = num_neg * np.ones((num_th,), dtype=np.int64) - fps + + # sequence of dimensions is (thresholds, true class, predicted class) (see docstring) + return np.stack( + [ + np.stack([tns, fps], axis=-1), + np.stack([fns, tps], axis=-1), + ], + axis=-1, + ).transpose(0, 2, 1) + + +def binary_classification_curve( + scores_batch: torch.Tensor, + gts_batch: torch.Tensor, + thresholds: torch.Tensor, +) -> torch.Tensor: + """Returns a binary classification matrix at each threshold for each image in the batch. + + This is a wrapper around `_binary_classification_curve`. + Validation of the arguments is done here (not in the actual implementation functions). + + Note: predicted as positive condition is `score >= thresh`. + + Args: + scores_batch (torch.Tensor): Anomaly scores (N, D,). + gts_batch (torch.Tensor): Binary (bool) ground truth of shape (N, D,). + thresholds (torch.Tensor): Sequence of thresholds in ascending order (K,). + + Returns: + torch.Tensor: Binary classification matrix curves (N, K, 2, 2) + + The last two dimensions are the confusion matrix (ground truth, predictions) + So for each thresh it gives: + - `tp`: `[... , 1, 1]` + - `fp`: `[... , 0, 1]` + - `fn`: `[... , 1, 0]` + - `tn`: `[... , 0, 0]` + + `t` is for `true` and `f` is for `false`, `p` is for `positive` and `n` is for `negative`, so: + - `tp` stands for `true positive` + - `fp` stands for `false positive` + - `fn` stands for `false negative` + - `tn` stands for `true negative` + + The numbers in each confusion matrix are the counts (not the ratios). + + Counts are relative to each instance (i.e. from 0 to D, e.g. the total is the number of pixels in the image). + + Thresholds are shared across all instances, so all confusion matrices, for instance, + at position [:, 0, :, :] are relative to the 1st threshold in `thresholds`. + + Thresholds are sorted in ascending order. + """ + _validate.is_scores_batch(scores_batch) + _validate.is_gts_batch(gts_batch) + _validate.is_same_shape(scores_batch, gts_batch) + _validate.is_valid_threshold(thresholds) + # TODO(ashwinvaidya17): this is kept as numpy for now because it is much faster. + # TEMP-0 + result = np.vectorize(_binary_classification_curve, signature="(n),(n),(k)->(k,2,2)")( + scores_batch.detach().cpu().numpy(), + gts_batch.detach().cpu().numpy(), + thresholds.detach().cpu().numpy(), + ) + return torch.from_numpy(result).to(scores_batch.device) + + +def _get_linspaced_thresholds(anomaly_maps: torch.Tensor, num_thresholds: int) -> torch.Tensor: + """Get thresholds linearly spaced between the min and max of the anomaly maps.""" + _validate.is_num_thresholds_gte2(num_thresholds) + # this operation can be a bit expensive + thresh_low, thresh_high = thresh_bounds = (anomaly_maps.min().item(), anomaly_maps.max().item()) + try: + _validate.validate_threshold_bounds(thresh_bounds) + except ValueError as ex: + msg = f"Invalid threshold bounds computed from the given anomaly maps. Cause: {ex}" + raise ValueError(msg) from ex + return torch.linspace(thresh_low, thresh_high, num_thresholds, dtype=anomaly_maps.dtype) + + +def threshold_and_binary_classification_curve( + anomaly_maps: torch.Tensor, + masks: torch.Tensor, + threshold_choice: ThresholdMethod | str = ThresholdMethod.MINMAX_LINSPACE, + thresholds: torch.Tensor | None = None, + num_thresholds: int | None = None, +) -> tuple[torch.Tensor, torch.Tensor]: + """Return thresholds and binary classification matrix at each threshold for each image in the batch. + + Args: + anomaly_maps (torch.Tensor): Anomaly score maps of shape (N, H, W) + masks (torch.Tensor): Binary ground truth masks of shape (N, H, W) + threshold_choice (str, optional): Sequence of thresholds to use. Defaults to THRESH_SEQUENCE_MINMAX_LINSPACE. + thresholds (torch.Tensor, optional): Sequence of thresholds to use. + Only applicable when threshold_choice is THRESH_SEQUENCE_GIVEN. + num_thresholds (int, optional): Number of thresholds between the min and max of the anomaly maps. + Only applicable when threshold_choice is THRESH_SEQUENCE_MINMAX_LINSPACE. + + Returns: + tuple[torch.Tensor, torch.Tensor]: + [0] Thresholds of shape (K,) and dtype is the same as `anomaly_maps.dtype`. + + [1] Binary classification matrices of shape (N, K, 2, 2) + + N: number of images/instances + K: number of thresholds + + The last two dimensions are the confusion matrix (ground truth, predictions) + So for each thresh it gives: + - `tp`: `[... , 1, 1]` + - `fp`: `[... , 0, 1]` + - `fn`: `[... , 1, 0]` + - `tn`: `[... , 0, 0]` + + `t` is for `true` and `f` is for `false`, `p` is for `positive` and `n` is for `negative`, so: + - `tp` stands for `true positive` + - `fp` stands for `false positive` + - `fn` stands for `false negative` + - `tn` stands for `true negative` + + The numbers in each confusion matrix are the counts of pixels in the image (not the ratios). + + Thresholds are shared across all images, so all confusion matrices, for instance, + at position [:, 0, :, :] are relative to the 1st threshold in `thresholds`. + + Thresholds are sorted in ascending order. + """ + threshold_choice = ThresholdMethod(threshold_choice) + _validate.is_anomaly_maps(anomaly_maps) + _validate.is_masks(masks) + _validate.is_same_shape(anomaly_maps, masks) + + if threshold_choice == ThresholdMethod.GIVEN: + assert thresholds is not None + _validate.is_valid_threshold(thresholds) + if num_thresholds is not None: + logger.warning( + "Argument `num_thresholds` was given, " + f"but it is ignored because `thresholds_choice` is '{threshold_choice.value}'.", + ) + thresholds = thresholds.to(anomaly_maps.dtype) + + elif threshold_choice == ThresholdMethod.MINMAX_LINSPACE: + assert num_thresholds is not None + if thresholds is not None: + logger.warning( + "Argument `thresholds_given` was given, " + f"but it is ignored because `thresholds_choice` is '{threshold_choice.value}'.", + ) + # `num_thresholds` is validated in the function below + thresholds = _get_linspaced_thresholds(anomaly_maps, num_thresholds) + + elif threshold_choice == ThresholdMethod.MEAN_FPR_OPTIMIZED: + raise NotImplementedError(f"TODO implement {threshold_choice.value}") # noqa: EM102 + + else: + msg = ( + f"Expected `threshs_choice` to be from {list(ThresholdMethod.__members__)}," + f" but got '{threshold_choice.value}'" + ) + raise NotImplementedError(msg) + + # keep the batch dimension and flatten the rest + scores_batch = anomaly_maps.reshape(anomaly_maps.shape[0], -1) + gts_batch = masks.reshape(masks.shape[0], -1).to(bool) # make sure it is boolean + + binclf_curves = binary_classification_curve(scores_batch, gts_batch, thresholds) + + num_images = anomaly_maps.shape[0] + + try: + _validate.is_binclf_curves(binclf_curves, valid_thresholds=thresholds) + + # these two validations cannot be done in `_validate.binclf_curves` because it does not have access to the + # original shapes of `anomaly_maps` + if binclf_curves.shape[0] != num_images: + msg = ( + "Expected `binclf_curves` to have the same number of images as `anomaly_maps`, " + f"but got {binclf_curves.shape[0]} and {anomaly_maps.shape[0]}" + ) + raise RuntimeError(msg) + + except (TypeError, ValueError) as ex: + msg = f"Invalid `binclf_curves` was computed. Cause: {ex}" + raise RuntimeError(msg) from ex + + return thresholds, binclf_curves + + +def per_image_tpr(binclf_curves: torch.Tensor) -> torch.Tensor: + """True positive rates (TPR) for image for each thresh. + + TPR = TP / P = TP / (TP + FN) + + TP: true positives + FM: false negatives + P: positives (TP + FN) + + Args: + binclf_curves (torch.Tensor): Binary classification matrix curves (N, K, 2, 2). See `per_image_binclf_curve`. + + Returns: + torch.Tensor: shape (N, K), dtype float64 + N: number of images + K: number of thresholds + + Thresholds are sorted in ascending order, so TPR is in descending order. + """ + # shape: (num images, num thresholds) + tps = binclf_curves[..., 1, 1] + pos = binclf_curves[..., 1, :].sum(axis=2) # 2 was the 3 originally + + # tprs will be nan if pos == 0 (normal image), which is expected + return tps.to(torch.float64) / pos.to(torch.float64) + + +def per_image_fpr(binclf_curves: torch.Tensor) -> torch.Tensor: + """False positive rates (TPR) for image for each thresh. + + FPR = FP / N = FP / (FP + TN) + + FP: false positives + TN: true negatives + N: negatives (FP + TN) + + Args: + binclf_curves (torch.Tensor): Binary classification matrix curves (N, K, 2, 2). See `per_image_binclf_curve`. + + Returns: + torch.Tensor: shape (N, K), dtype float64 + N: number of images + K: number of thresholds + + Thresholds are sorted in ascending order, so FPR is in descending order. + """ + # shape: (num images, num thresholds) + fps = binclf_curves[..., 0, 1] + neg = binclf_curves[..., 0, :].sum(axis=2) # 2 was the 3 originally + + # it can be `nan` if an anomalous image is fully covered by the mask + return fps.to(torch.float64) / neg.to(torch.float64) diff --git a/src/anomalib/metrics/pimo/dataclasses.py b/src/anomalib/metrics/pimo/dataclasses.py new file mode 100644 index 0000000000..3eaa04cd12 --- /dev/null +++ b/src/anomalib/metrics/pimo/dataclasses.py @@ -0,0 +1,226 @@ +"""Dataclasses for PIMO metrics.""" + +# Based on the code: https://github.com/jpcbertoldo/aupimo +# +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from dataclasses import dataclass, field + +import torch + +from . import _validate, functional + + +@dataclass +class PIMOResult: + """Per-Image Overlap (PIMO, pronounced pee-mo) curve. + + This interface gathers the PIMO curve data and metadata and provides several utility methods. + + Notation: + - N: number of images + - K: number of thresholds + - FPR: False Positive Rate + - TPR: True Positive Rate + + Attributes: + thresholds (torch.Tensor): sequence of K (monotonically increasing) thresholds used to compute the PIMO curve + shared_fpr (torch.Tensor): K values of the shared FPR metric at the corresponding thresholds + per_image_tprs (torch.Tensor): for each of the N images, the K values of in-image TPR at the corresponding + thresholds + """ + + # data + thresholds: torch.Tensor = field(repr=False) # shape => (K,) + shared_fpr: torch.Tensor = field(repr=False) # shape => (K,) + per_image_tprs: torch.Tensor = field(repr=False) # shape => (N, K) + + @property + def num_threshsholds(self) -> int: + """Number of thresholds.""" + return self.thresholds.shape[0] + + @property + def num_images(self) -> int: + """Number of images.""" + return self.per_image_tprs.shape[0] + + @property + def image_classes(self) -> torch.Tensor: + """Image classes (0: normal, 1: anomalous). + + Deduced from the per-image TPRs. + If any TPR value is not NaN, the image is considered anomalous. + """ + return (~torch.isnan(self.per_image_tprs)).any(dim=1).to(torch.int32) + + def __post_init__(self) -> None: + """Validate the inputs for the result object are consistent.""" + try: + _validate.is_valid_threshold(self.thresholds) + _validate.is_rate_curve(self.shared_fpr, nan_allowed=False, decreasing=True) # is_shared_apr + _validate.is_per_image_tprs(self.per_image_tprs, self.image_classes) + + except (TypeError, ValueError) as ex: + msg = f"Invalid inputs for {self.__class__.__name__} object. Cause: {ex}." + raise TypeError(msg) from ex + + if self.thresholds.shape != self.shared_fpr.shape: + msg = ( + f"Invalid {self.__class__.__name__} object. Attributes have inconsistent shapes: " + f"{self.thresholds.shape=} != {self.shared_fpr.shape=}." + ) + raise TypeError(msg) + + if self.thresholds.shape[0] != self.per_image_tprs.shape[1]: + msg = ( + f"Invalid {self.__class__.__name__} object. Attributes have inconsistent shapes: " + f"{self.thresholds.shape[0]=} != {self.per_image_tprs.shape[1]=}." + ) + raise TypeError(msg) + + def thresh_at(self, fpr_level: float) -> tuple[int, float, float]: + """Return the threshold at the given shared FPR. + + See `anomalib.metrics.per_image.pimo_numpy.thresh_at_shared_fpr_level` for details. + + Args: + fpr_level (float): shared FPR level + + Returns: + tuple[int, float, float]: + [0] index of the threshold + [1] threshold + [2] the actual shared FPR value at the returned threshold + """ + return functional.thresh_at_shared_fpr_level( + self.thresholds, + self.shared_fpr, + fpr_level, + ) + + +@dataclass +class AUPIMOResult: + """Area Under the Per-Image Overlap (AUPIMO, pronounced a-u-pee-mo) curve. + + This interface gathers the AUPIMO data and metadata and provides several utility methods. + + Attributes: + fpr_lower_bound (float): [metadata] LOWER bound of the FPR integration range + fpr_upper_bound (float): [metadata] UPPER bound of the FPR integration range + num_thresholds (int): [metadata] number of thresholds used to effectively compute AUPIMO; + should not be confused with the number of thresholds used to compute the PIMO curve + thresh_lower_bound (float): LOWER threshold bound --> corresponds to the UPPER FPR bound + thresh_upper_bound (float): UPPER threshold bound --> corresponds to the LOWER FPR bound + aupimos (torch.Tensor): values of AUPIMO scores (1 per image) + """ + + # metadata + fpr_lower_bound: float + fpr_upper_bound: float + num_thresholds: int | None + + # data + thresh_lower_bound: float = field(repr=False) + thresh_upper_bound: float = field(repr=False) + aupimos: torch.Tensor = field(repr=False) # shape => (N,) + + @property + def num_images(self) -> int: + """Number of images.""" + return self.aupimos.shape[0] + + @property + def num_normal_images(self) -> int: + """Number of normal images.""" + return int((self.image_classes == 0).sum()) + + @property + def num_anomalous_images(self) -> int: + """Number of anomalous images.""" + return int((self.image_classes == 1).sum()) + + @property + def image_classes(self) -> torch.Tensor: + """Image classes (0: normal, 1: anomalous).""" + # if an instance has `nan` aupimo it's because it's a normal image + return self.aupimos.isnan().to(torch.int32) + + @property + def fpr_bounds(self) -> tuple[float, float]: + """Lower and upper bounds of the FPR integration range.""" + return self.fpr_lower_bound, self.fpr_upper_bound + + @property + def thresh_bounds(self) -> tuple[float, float]: + """Lower and upper bounds of the threshold integration range. + + Recall: they correspond to the FPR bounds in reverse order. + I.e.: + fpr_lower_bound --> thresh_upper_bound + fpr_upper_bound --> thresh_lower_bound + """ + return self.thresh_lower_bound, self.thresh_upper_bound + + def __post_init__(self) -> None: + """Validate the inputs for the result object are consistent.""" + try: + _validate.is_rate_range((self.fpr_lower_bound, self.fpr_upper_bound)) + # TODO(jpcbertoldo): warn when it's too low (use parameters from the numpy code) # noqa: TD003 + if self.num_thresholds is not None: + _validate.is_num_thresholds_gte2(self.num_thresholds) + _validate.is_rates(self.aupimos, nan_allowed=True) # validate is_aupimos + + _validate.validate_threshold_bounds((self.thresh_lower_bound, self.thresh_upper_bound)) + + except (TypeError, ValueError) as ex: + msg = f"Invalid inputs for {self.__class__.__name__} object. Cause: {ex}." + raise TypeError(msg) from ex + + @classmethod + def from_pimo_result( + cls: type["AUPIMOResult"], + pimo_result: PIMOResult, + fpr_bounds: tuple[float, float], + num_thresholds_auc: int, + aupimos: torch.Tensor, + ) -> "AUPIMOResult": + """Return an AUPIMO result object from a PIMO result object. + + Args: + pimo_result: PIMO result object + fpr_bounds: lower and upper bounds of the FPR integration range + num_thresholds_auc: number of thresholds used to effectively compute AUPIMO; + NOT the number of thresholds used to compute the PIMO curve! + aupimos: AUPIMO scores + """ + if pimo_result.per_image_tprs.shape[0] != aupimos.shape[0]: + msg = ( + f"Invalid {cls.__name__} object. Attributes have inconsistent shapes: " + f"there are {pimo_result.per_image_tprs.shape[0]} PIMO curves but {aupimos.shape[0]} AUPIMO scores." + ) + raise TypeError(msg) + + if not torch.isnan(aupimos[pimo_result.image_classes == 0]).all(): + msg = "Expected all normal images to have NaN AUPIMOs, but some have non-NaN values." + raise TypeError(msg) + + if torch.isnan(aupimos[pimo_result.image_classes == 1]).any(): + msg = "Expected all anomalous images to have valid AUPIMOs (not nan), but some have NaN values." + raise TypeError(msg) + + fpr_lower_bound, fpr_upper_bound = fpr_bounds + # recall: fpr upper/lower bounds are the same as the thresh lower/upper bounds + _, thresh_lower_bound, __ = pimo_result.thresh_at(fpr_upper_bound) + _, thresh_upper_bound, __ = pimo_result.thresh_at(fpr_lower_bound) + # `_` is the threshold's index, `__` is the actual fpr value + return cls( + fpr_lower_bound=fpr_lower_bound, + fpr_upper_bound=fpr_upper_bound, + num_thresholds=num_thresholds_auc, + thresh_lower_bound=float(thresh_lower_bound), + thresh_upper_bound=float(thresh_upper_bound), + aupimos=aupimos, + ) diff --git a/src/anomalib/metrics/pimo/functional.py b/src/anomalib/metrics/pimo/functional.py new file mode 100644 index 0000000000..7eac07b1bd --- /dev/null +++ b/src/anomalib/metrics/pimo/functional.py @@ -0,0 +1,355 @@ +"""Per-Image Overlap curve (PIMO, pronounced pee-mo) and its area under the curve (AUPIMO). + +Details: `anomalib.metrics.per_image.pimo`. +""" + +# Original Code +# https://github.com/jpcbertoldo/aupimo +# +# Modified +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging + +import numpy as np +import torch + +from . import _validate +from .binary_classification_curve import ( + ThresholdMethod, + _get_linspaced_thresholds, + per_image_fpr, + per_image_tpr, + threshold_and_binary_classification_curve, +) +from .utils import images_classes_from_masks + +logger = logging.getLogger(__name__) + + +def pimo_curves( + anomaly_maps: torch.Tensor, + masks: torch.Tensor, + num_thresholds: int, +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """Compute the Per-IMage Overlap (PIMO, pronounced pee-mo) curves. + + PIMO is a curve of True Positive Rate (TPR) values on each image across multiple anomaly score thresholds. + The anomaly score thresholds are indexed by a (cross-image shared) value of False Positive Rate (FPR) measure on + the normal images. + + Details: `anomalib.metrics.per_image.pimo`. + + Args' notation: + N: number of images + H: image height + W: image width + K: number of thresholds + + Args: + anomaly_maps: floating point anomaly score maps of shape (N, H, W) + masks: binary (bool or int) ground truth masks of shape (N, H, W) + num_thresholds: number of thresholds to compute (K) + + Returns: + tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + [0] thresholds of shape (K,) in ascending order + [1] shared FPR values of shape (K,) in descending order (indices correspond to the thresholds) + [2] per-image TPR curves of shape (N, K), axis 1 in descending order (indices correspond to the thresholds) + [3] image classes of shape (N,) with values 0 (normal) or 1 (anomalous) + """ + # validate the strings are valid + _validate.is_num_thresholds_gte2(num_thresholds) + _validate.is_anomaly_maps(anomaly_maps) + _validate.is_masks(masks) + _validate.is_same_shape(anomaly_maps, masks) + _validate.has_at_least_one_anomalous_image(masks) + _validate.has_at_least_one_normal_image(masks) + + image_classes = images_classes_from_masks(masks) + + # the thresholds are computed here so that they can be restrained to the normal images + # therefore getting a better resolution in terms of FPR quantization + # otherwise the function `binclf_curve_numpy.per_image_binclf_curve` would have the range of thresholds + # computed from all the images (normal + anomalous) + thresholds = _get_linspaced_thresholds( + anomaly_maps[image_classes == 0], + num_thresholds, + ) + + # N: number of images, K: number of thresholds + # shapes are (K,) and (N, K, 2, 2) + thresholds, binclf_curves = threshold_and_binary_classification_curve( + anomaly_maps=anomaly_maps, + masks=masks, + threshold_choice=ThresholdMethod.GIVEN.value, + thresholds=thresholds, + num_thresholds=None, + ) + + shared_fpr: torch.Tensor + # mean-per-image-fpr on normal images + # shape -> (N, K) + per_image_fprs_normals = per_image_fpr(binclf_curves[image_classes == 0]) + try: + _validate.is_per_image_rate_curves(per_image_fprs_normals, nan_allowed=False, decreasing=True) + except ValueError as ex: + msg = f"Cannot compute PIMO because the per-image FPR curves from normal images are invalid. Cause: {ex}" + raise RuntimeError(msg) from ex + + # shape -> (K,) + # this is the only shared FPR metric implemented so far, + # see note about shared FPR in Details: `anomalib.metrics.per_image.pimo`. + shared_fpr = per_image_fprs_normals.mean(axis=0) + + # shape -> (N, K) + per_image_tprs = per_image_tpr(binclf_curves) + + return thresholds, shared_fpr, per_image_tprs, image_classes + + +# =========================================== AUPIMO =========================================== + + +def aupimo_scores( + anomaly_maps: torch.Tensor, + masks: torch.Tensor, + num_thresholds: int = 300_000, + fpr_bounds: tuple[float, float] = (1e-5, 1e-4), + force: bool = False, +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, int]: + """Compute the PIMO curves and their Area Under the Curve (i.e. AUPIMO) scores. + + Scores are computed from the integration of the PIMO curves within the given FPR bounds, then normalized to [0, 1]. + It can be thought of as the average TPR of the PIMO curves within the given FPR bounds. + + Details: `anomalib.metrics.per_image.pimo`. + + Args' notation: + N: number of images + H: image height + W: image width + K: number of thresholds + + Args: + anomaly_maps: floating point anomaly score maps of shape (N, H, W) + masks: binary (bool or int) ground truth masks of shape (N, H, W) + num_thresholds: number of thresholds to compute (K) + fpr_bounds: lower and upper bounds of the FPR integration range + force: whether to force the computation despite bad conditions + + Returns: + tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + [0] thresholds of shape (K,) in ascending order + [1] shared FPR values of shape (K,) in descending order (indices correspond to the thresholds) + [2] per-image TPR curves of shape (N, K), axis 1 in descending order (indices correspond to the thresholds) + [3] image classes of shape (N,) with values 0 (normal) or 1 (anomalous) + [4] AUPIMO scores of shape (N,) in [0, 1] + [5] number of points used in the AUC integration + """ + _validate.is_rate_range(fpr_bounds) + + # other validations are done in the `pimo` function + thresholds, shared_fpr, per_image_tprs, image_classes = pimo_curves( + anomaly_maps=anomaly_maps, + masks=masks, + num_thresholds=num_thresholds, + ) + try: + _validate.is_valid_threshold(thresholds) + _validate.is_rate_curve(shared_fpr, nan_allowed=False, decreasing=True) + _validate.is_images_classes(image_classes) + _validate.is_per_image_rate_curves(per_image_tprs[image_classes == 1], nan_allowed=False, decreasing=True) + + except ValueError as ex: + msg = f"Cannot compute AUPIMO because the PIMO curves are invalid. Cause: {ex}" + raise RuntimeError(msg) from ex + + fpr_lower_bound, fpr_upper_bound = fpr_bounds + + # get the threshold indices where the fpr bounds are achieved + fpr_lower_bound_thresh_idx, _, fpr_lower_bound_defacto = thresh_at_shared_fpr_level( + thresholds, + shared_fpr, + fpr_lower_bound, + ) + fpr_upper_bound_thresh_idx, _, fpr_upper_bound_defacto = thresh_at_shared_fpr_level( + thresholds, + shared_fpr, + fpr_upper_bound, + ) + + if not torch.isclose( + fpr_lower_bound_defacto, + torch.tensor(fpr_lower_bound, dtype=fpr_lower_bound_defacto.dtype, device=fpr_lower_bound_defacto.device), + rtol=(rtol := 1e-2), + ): + logger.warning( + "The lower bound of the shared FPR integration range is not exactly achieved. " + f"Expected {fpr_lower_bound} but got {fpr_lower_bound_defacto}, which is not within {rtol=}.", + ) + + if not torch.isclose( + fpr_upper_bound_defacto, + torch.tensor(fpr_upper_bound, dtype=fpr_upper_bound_defacto.dtype, device=fpr_upper_bound_defacto.device), + rtol=rtol, + ): + logger.warning( + "The upper bound of the shared FPR integration range is not exactly achieved. " + f"Expected {fpr_upper_bound} but got {fpr_upper_bound_defacto}, which is not within {rtol=}.", + ) + + # reminder: fpr lower/upper bound is threshold upper/lower bound (reversed) + thresh_lower_bound_idx = fpr_upper_bound_thresh_idx + thresh_upper_bound_idx = fpr_lower_bound_thresh_idx + + # deal with edge cases + if thresh_lower_bound_idx >= thresh_upper_bound_idx: + msg = ( + "The thresholds corresponding to the given `fpr_bounds` are not valid because " + "they matched the same threshold or the are in the wrong order. " + f"FPR upper/lower = threshold lower/upper = {thresh_lower_bound_idx} and {thresh_upper_bound_idx}." + ) + raise RuntimeError(msg) + + # limit the curves to the integration range [lbound, ubound] + shared_fpr_bounded: torch.Tensor = shared_fpr[thresh_lower_bound_idx : (thresh_upper_bound_idx + 1)] + per_image_tprs_bounded: torch.Tensor = per_image_tprs[:, thresh_lower_bound_idx : (thresh_upper_bound_idx + 1)] + + # `shared_fpr` and `tprs` are in descending order; `flip()` reverts to ascending order + shared_fpr_bounded = torch.flip(shared_fpr_bounded, dims=[0]) + per_image_tprs_bounded = torch.flip(per_image_tprs_bounded, dims=[1]) + + # the log's base does not matter because it's a constant factor canceled by normalization factor + shared_fpr_bounded_log = torch.log(shared_fpr_bounded) + + # deal with edge cases + invalid_shared_fpr = ~torch.isfinite(shared_fpr_bounded_log) + + if invalid_shared_fpr.all(): + msg = ( + "Cannot compute AUPIMO because the shared fpr integration range is invalid). " + "Try increasing the number of thresholds." + ) + raise RuntimeError(msg) + + if invalid_shared_fpr.any(): + logger.warning( + "Some values in the shared fpr integration range are nan. " + "The AUPIMO will be computed without these values.", + ) + + # get rid of nan values by removing them from the integration range + shared_fpr_bounded_log = shared_fpr_bounded_log[~invalid_shared_fpr] + per_image_tprs_bounded = per_image_tprs_bounded[:, ~invalid_shared_fpr] + + num_points_integral = int(shared_fpr_bounded_log.shape[0]) + + if num_points_integral <= 30: + msg = ( + "Cannot compute AUPIMO because the shared fpr integration range doesn't have enough points. " + f"Found {num_points_integral} points in the integration range. " + "Try increasing `num_thresholds`." + ) + if not force: + raise RuntimeError(msg) + msg += " Computation was forced!" + logger.warning(msg) + + if num_points_integral < 300: + logger.warning( + "The AUPIMO may be inaccurate because the shared fpr integration range doesn't have enough points. " + f"Found {num_points_integral} points in the integration range. " + "Try increasing `num_thresholds`.", + ) + + aucs: torch.Tensor = torch.trapezoid(per_image_tprs_bounded, x=shared_fpr_bounded_log, axis=1) + + # normalize, then clip(0, 1) makes sure that the values are in [0, 1] in case of numerical errors + normalization_factor = aupimo_normalizing_factor(fpr_bounds) + aucs = (aucs / normalization_factor).clip(0, 1) + + return thresholds, shared_fpr, per_image_tprs, image_classes, aucs, num_points_integral + + +# =========================================== AUX =========================================== + + +def thresh_at_shared_fpr_level( + thresholds: torch.Tensor, + shared_fpr: torch.Tensor, + fpr_level: float, +) -> tuple[int, float, torch.Tensor]: + """Return the threshold and its index at the given shared FPR level. + + Three cases are possible: + - fpr_level == 0: the lowest threshold that achieves 0 FPR is returned + - fpr_level == 1: the highest threshold that achieves 1 FPR is returned + - 0 < fpr_level < 1: the threshold that achieves the closest (higher or lower) FPR to `fpr_level` is returned + + Args: + thresholds: thresholds at which the shared FPR was computed. + shared_fpr: shared FPR values. + fpr_level: shared FPR value at which to get the threshold. + + Returns: + tuple[int, float, float]: + [0] index of the threshold + [1] threshold + [2] the actual shared FPR value at the returned threshold + """ + _validate.is_valid_threshold(thresholds) + _validate.is_rate_curve(shared_fpr, nan_allowed=False, decreasing=True) + _validate.joint_validate_thresholds_shared_fpr(thresholds, shared_fpr) + _validate.is_rate(fpr_level, zero_ok=True, one_ok=True) + + shared_fpr_min, shared_fpr_max = shared_fpr.min(), shared_fpr.max() + + if fpr_level < shared_fpr_min: + msg = ( + "Invalid `fpr_level` because it's out of the range of `shared_fpr` = " + f"[{shared_fpr_min}, {shared_fpr_max}], and got {fpr_level}." + ) + raise ValueError(msg) + + if fpr_level > shared_fpr_max: + msg = ( + "Invalid `fpr_level` because it's out of the range of `shared_fpr` = " + f"[{shared_fpr_min}, {shared_fpr_max}], and got {fpr_level}." + ) + raise ValueError(msg) + + # fpr_level == 0 or 1 are special case + # because there may be multiple solutions, and the chosen should their MINIMUM/MAXIMUM respectively + if fpr_level == 0.0: + index = torch.min(torch.where(shared_fpr == fpr_level)[0]) + + elif fpr_level == 1.0: + index = torch.max(torch.where(shared_fpr == fpr_level)[0]) + + else: + index = torch.argmin(torch.abs(shared_fpr - fpr_level)) + + index = int(index) + fpr_level_defacto = shared_fpr[index] + thresh = thresholds[index] + return index, thresh, fpr_level_defacto + + +def aupimo_normalizing_factor(fpr_bounds: tuple[float, float]) -> float: + """Constant that normalizes the AUPIMO integral to 0-1 range. + + It is the maximum possible value from the integral in AUPIMO's definition. + It corresponds to assuming a constant function T_i: thresh --> 1. + + Args: + fpr_bounds: lower and upper bounds of the FPR integration range. + + Returns: + float: the normalization factor (>0). + """ + _validate.is_rate_range(fpr_bounds) + fpr_lower_bound, fpr_upper_bound = fpr_bounds + # the log's base must be the same as the one used in the integration! + return float(np.log(fpr_upper_bound / fpr_lower_bound)) diff --git a/src/anomalib/metrics/pimo/pimo.py b/src/anomalib/metrics/pimo/pimo.py new file mode 100644 index 0000000000..9703b60b59 --- /dev/null +++ b/src/anomalib/metrics/pimo/pimo.py @@ -0,0 +1,296 @@ +"""Per-Image Overlap curve (PIMO, pronounced pee-mo) and its area under the curve (AUPIMO). + +# PIMO + +PIMO is a curve of True Positive Rate (TPR) values on each image across multiple anomaly score thresholds. +The anomaly score thresholds are indexed by a (shared) valued of False Positive Rate (FPR) measure on the normal images. + +Each *anomalous* image has its own curve such that the X-axis is shared by all of them. + +At a given threshold: + X-axis: Shared FPR (may vary) + 1. Log of the Average of per-image FPR on normal images. + SEE NOTE BELOW. + Y-axis: per-image TP Rate (TPR), or "Overlap" between the ground truth and the predicted masks. + +*** Note about other shared FPR alternatives *** +The shared FPR metric can be made harder by using the cross-image max (or high-percentile) FPRs instead of the mean. +Rationale: this will further punish models that have exceptional FPs in normal images. +So far there is only one shared FPR metric implemented but others will be added in the future. + +# AUPIMO + +`AUPIMO` is the area under each `PIMO` curve with bounded integration range in terms of shared FPR. + +# Disclaimer + +This module implements torch interfaces to access the numpy code in `pimo_numpy.py`. +Tensors are converted to numpy arrays and then passed and validated in the numpy code. +The results are converted back to tensors and eventually wrapped in an dataclass object. + +Validations will preferably happen in ndarray so the numpy code can be reused without torch, +so often times the Tensor arguments will be converted to ndarray and then validated. +""" + +# Original Code +# https://github.com/jpcbertoldo/aupimo +# +# Modified +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging + +import torch +from torchmetrics import Metric + +from . import _validate, functional +from .dataclasses import AUPIMOResult, PIMOResult + +logger = logging.getLogger(__name__) + + +class PIMO(Metric): + """Per-IMage Overlap (PIMO, pronounced pee-mo) curves. + + This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code. + The tensors are converted to numpy arrays and then passed and validated in the numpy code. + The results are converted back to tensors and wrapped in an dataclass object. + + PIMO is a curve of True Positive Rate (TPR) values on each image across multiple anomaly score thresholds. + The anomaly score thresholds are indexed by a (cross-image shared) value of False Positive Rate (FPR) measure on + the normal images. + + Details: `anomalib.metrics.per_image.pimo`. + + Notation: + N: number of images + H: image height + W: image width + K: number of thresholds + + Attributes: + anomaly_maps: floating point anomaly score maps of shape (N, H, W) + masks: binary (bool or int) ground truth masks of shape (N, H, W) + + Args: + num_thresholds: number of thresholds to compute (K) + binclf_algorithm: algorithm to compute the binary classifier curve (see `binclf_curve_numpy.Algorithm`) + + Returns: + PIMOResult: PIMO curves dataclass object. See `PIMOResult` for details. + """ + + is_differentiable: bool = False + higher_is_better: bool | None = None + full_state_update: bool = False + + num_thresholds: int + binclf_algorithm: str + + anomaly_maps: list[torch.Tensor] + masks: list[torch.Tensor] + + @property + def _is_empty(self) -> bool: + """Return True if the metric has not been updated yet.""" + return len(self.anomaly_maps) == 0 + + @property + def num_images(self) -> int: + """Number of images.""" + return sum(am.shape[0] for am in self.anomaly_maps) + + @property + def image_classes(self) -> torch.Tensor: + """Image classes (0: normal, 1: anomalous).""" + return functional.images_classes_from_masks(self.masks) + + def __init__(self, num_thresholds: int) -> None: + """Per-Image Overlap (PIMO) curve. + + Args: + num_thresholds: number of thresholds used to compute the PIMO curve (K) + """ + super().__init__() + + logger.warning( + f"Metric `{self.__class__.__name__}` will save all targets and predictions in buffer." + " For large datasets this may lead to large memory footprint.", + ) + + # the options below are, redundantly, validated here to avoid reaching + # an error later in the execution + + _validate.is_num_thresholds_gte2(num_thresholds) + self.num_thresholds = num_thresholds + + self.add_state("anomaly_maps", default=[], dist_reduce_fx="cat") + self.add_state("masks", default=[], dist_reduce_fx="cat") + + def update(self, anomaly_maps: torch.Tensor, masks: torch.Tensor) -> None: + """Update lists of anomaly maps and masks. + + Args: + anomaly_maps (torch.Tensor): predictions of the model (ndim == 2, float) + masks (torch.Tensor): ground truth masks (ndim == 2, binary) + """ + _validate.is_anomaly_maps(anomaly_maps) + _validate.is_masks(masks) + _validate.is_same_shape(anomaly_maps, masks) + self.anomaly_maps.append(anomaly_maps) + self.masks.append(masks) + + def compute(self) -> PIMOResult: + """Compute the PIMO curves. + + Call the functional interface `pimo_curves()`, which is a wrapper around the numpy code. + + Returns: + PIMOResult: PIMO curves dataclass object. See `PIMOResult` for details. + """ + if self._is_empty: + msg = "No anomaly maps and masks have been added yet. Please call `update()` first." + raise RuntimeError(msg) + anomaly_maps = torch.concat(self.anomaly_maps, dim=0) + masks = torch.concat(self.masks, dim=0) + + thresholds, shared_fpr, per_image_tprs, _ = functional.pimo_curves( + anomaly_maps, + masks, + self.num_thresholds, + ) + return PIMOResult( + thresholds=thresholds, + shared_fpr=shared_fpr, + per_image_tprs=per_image_tprs, + ) + + +class AUPIMO(PIMO): + """Area Under the Per-Image Overlap (PIMO) curve. + + This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code. + The tensors are converted to numpy arrays and then passed and validated in the numpy code. + The results are converted back to tensors and wrapped in an dataclass object. + + Scores are computed from the integration of the PIMO curves within the given FPR bounds, then normalized to [0, 1]. + It can be thought of as the average TPR of the PIMO curves within the given FPR bounds. + + Details: `anomalib.metrics.per_image.pimo`. + + Notation: + N: number of images + H: image height + W: image width + K: number of thresholds + + Attributes: + anomaly_maps: floating point anomaly score maps of shape (N, H, W) + masks: binary (bool or int) ground truth masks of shape (N, H, W) + + Args: + num_thresholds: number of thresholds to compute (K) + fpr_bounds: lower and upper bounds of the FPR integration range + force: whether to force the computation despite bad conditions + + Returns: + tuple[PIMOResult, AUPIMOResult]: PIMO and AUPIMO results dataclass objects. See `PIMOResult` and `AUPIMOResult`. + """ + + fpr_bounds: tuple[float, float] + return_average: bool + force: bool + + @staticmethod + def normalizing_factor(fpr_bounds: tuple[float, float]) -> float: + """Constant that normalizes the AUPIMO integral to 0-1 range. + + It is the maximum possible value from the integral in AUPIMO's definition. + It corresponds to assuming a constant function T_i: thresh --> 1. + + Args: + fpr_bounds: lower and upper bounds of the FPR integration range. + + Returns: + float: the normalization factor (>0). + """ + return functional.aupimo_normalizing_factor(fpr_bounds) + + def __repr__(self) -> str: + """Show the metric name and its integration bounds.""" + lower, upper = self.fpr_bounds + return f"{self.__class__.__name__}([{lower:.2g}, {upper:.2g}])" + + def __init__( + self, + num_thresholds: int = 300_000, + fpr_bounds: tuple[float, float] = (1e-5, 1e-4), + return_average: bool = True, + force: bool = False, + ) -> None: + """Area Under the Per-Image Overlap (PIMO) curve. + + Args: + num_thresholds: [passed to parent `PIMO`] number of thresholds used to compute the PIMO curve + fpr_bounds: lower and upper bounds of the FPR integration range + return_average: if True, return the average AUPIMO score; if False, return all the individual AUPIMO scores + force: if True, force the computation of the AUPIMO scores even in bad conditions (e.g. few points) + """ + super().__init__(num_thresholds=num_thresholds) + + # other validations are done in PIMO.__init__() + + _validate.is_rate_range(fpr_bounds) + self.fpr_bounds = fpr_bounds + self.return_average = return_average + self.force = force + + def compute(self, force: bool | None = None) -> tuple[PIMOResult, AUPIMOResult]: # type: ignore[override] + """Compute the PIMO curves and their Area Under the curve (AUPIMO) scores. + + Call the functional interface `aupimo_scores()`, which is a wrapper around the numpy code. + + Args: + force: if given (not None), override the `force` attribute. + + Returns: + tuple[PIMOResult, AUPIMOResult]: PIMO curves and AUPIMO scores dataclass objects. + See `PIMOResult` and `AUPIMOResult` for details. + """ + if self._is_empty: + msg = "No anomaly maps and masks have been added yet. Please call `update()` first." + raise RuntimeError(msg) + anomaly_maps = torch.concat(self.anomaly_maps, dim=0) + masks = torch.concat(self.masks, dim=0) + force = force if force is not None else self.force + + # other validations are done in the numpy code + + thresholds, shared_fpr, per_image_tprs, _, aupimos, num_thresholds_auc = functional.aupimo_scores( + anomaly_maps, + masks, + self.num_thresholds, + fpr_bounds=self.fpr_bounds, + force=force, + ) + + pimo_result = PIMOResult( + thresholds=thresholds, + shared_fpr=shared_fpr, + per_image_tprs=per_image_tprs, + ) + aupimo_result = AUPIMOResult.from_pimo_result( + pimo_result, + fpr_bounds=self.fpr_bounds, + # not `num_thresholds`! + # `num_thresholds` is the number of thresholds used to compute the PIMO curve + # this is the number of thresholds used to compute the AUPIMO integral + num_thresholds_auc=num_thresholds_auc, + aupimos=aupimos, + ) + if self.return_average: + # normal images have NaN AUPIMO scores + is_nan = torch.isnan(aupimo_result.aupimos) + return aupimo_result.aupimos[~is_nan].mean() + return pimo_result, aupimo_result diff --git a/src/anomalib/metrics/pimo/utils.py b/src/anomalib/metrics/pimo/utils.py new file mode 100644 index 0000000000..f0cac45657 --- /dev/null +++ b/src/anomalib/metrics/pimo/utils.py @@ -0,0 +1,19 @@ +"""Torch-oriented interfaces for `utils.py`.""" + +# Original Code +# https://github.com/jpcbertoldo/aupimo +# +# Modified +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging + +import torch + +logger = logging.getLogger(__name__) + + +def images_classes_from_masks(masks: torch.Tensor) -> torch.Tensor: + """Deduce the image classes from the masks.""" + return (masks == 1).any(axis=(1, 2)).to(torch.int32) diff --git a/src/anomalib/metrics/threshold/__init__.py b/src/anomalib/metrics/threshold/__init__.py index 5cfa996cac..13d3bf3288 100644 --- a/src/anomalib/metrics/threshold/__init__.py +++ b/src/anomalib/metrics/threshold/__init__.py @@ -3,8 +3,8 @@ # Copyright (C) 2024 Intel Corporation # SPDX-License-Identifier: Apache-2.0 -from .base import BaseThreshold +from .base import BaseThreshold, Threshold from .f1_adaptive_threshold import F1AdaptiveThreshold from .manual_threshold import ManualThreshold -__all__ = ["BaseThreshold", "F1AdaptiveThreshold", "ManualThreshold"] +__all__ = ["BaseThreshold", "Threshold", "F1AdaptiveThreshold", "ManualThreshold"] diff --git a/src/anomalib/metrics/threshold/base.py b/src/anomalib/metrics/threshold/base.py index 6bee389b3c..eef57789cd 100644 --- a/src/anomalib/metrics/threshold/base.py +++ b/src/anomalib/metrics/threshold/base.py @@ -3,33 +3,53 @@ # Copyright (C) 2024 Intel Corporation # SPDX-License-Identifier: Apache-2.0 -from abc import ABC +import warnings import torch from torchmetrics import Metric -class BaseThreshold(Metric, ABC): - """Base class for thresholding metrics.""" +class Threshold(Metric): + """Base class for thresholding metrics. + + This class serves as the foundation for all threshold-based metrics in the system. + It inherits from torchmetrics.Metric and provides a common interface for + threshold computation and updates. + + Subclasses should implement the `compute` and `update` methods to define + specific threshold calculation logic. + """ def __init__(self, **kwargs) -> None: super().__init__(**kwargs) - def compute(self) -> torch.Tensor: + def compute(self) -> torch.Tensor: # noqa: PLR6301 """Compute the threshold. Returns: Value of the optimal threshold. """ - msg = "Subclass of BaseAnomalyScoreThreshold must implement the compute method" + msg = "Subclass of Threshold must implement the compute method" raise NotImplementedError(msg) - def update(self, *args, **kwargs) -> None: # noqa: ARG002 + def update(self, *args, **kwargs) -> None: # noqa: ARG002, PLR6301 """Update the metric state. Args: *args: Any positional arguments. **kwargs: Any keyword arguments. """ - msg = "Subclass of BaseAnomalyScoreThreshold must implement the update method" + msg = "Subclass of Threshold must implement the update method" raise NotImplementedError(msg) + + +class BaseThreshold(Threshold): + """Alias for Threshold class for backward compatibility.""" + + def __init__(self, **kwargs) -> None: + warnings.warn( + "BaseThreshold is deprecated and will be removed in a future version. Use Threshold instead.", + DeprecationWarning, + stacklevel=2, + ) + super().__init__(**kwargs) diff --git a/src/anomalib/metrics/threshold/f1_adaptive_threshold.py b/src/anomalib/metrics/threshold/f1_adaptive_threshold.py index 64b31a4dcc..cb2ba1cd19 100644 --- a/src/anomalib/metrics/threshold/f1_adaptive_threshold.py +++ b/src/anomalib/metrics/threshold/f1_adaptive_threshold.py @@ -9,12 +9,12 @@ from anomalib.metrics.precision_recall_curve import BinaryPrecisionRecallCurve -from .base import BaseThreshold +from .base import Threshold logger = logging.getLogger(__name__) -class F1AdaptiveThreshold(BinaryPrecisionRecallCurve, BaseThreshold): +class F1AdaptiveThreshold(BinaryPrecisionRecallCurve, Threshold): """Anomaly Score Threshold. This class computes/stores the threshold that determines the anomalous label diff --git a/src/anomalib/metrics/threshold/manual_threshold.py b/src/anomalib/metrics/threshold/manual_threshold.py index e10abaa154..e42860db01 100644 --- a/src/anomalib/metrics/threshold/manual_threshold.py +++ b/src/anomalib/metrics/threshold/manual_threshold.py @@ -5,10 +5,10 @@ import torch -from .base import BaseThreshold +from .base import Threshold -class ManualThreshold(BaseThreshold): +class ManualThreshold(Threshold): """Initialize Manual Threshold. Args: @@ -56,7 +56,8 @@ def compute(self) -> torch.Tensor: """ return self.value - def update(self, *args, **kwargs) -> None: + @staticmethod + def update(*args, **kwargs) -> None: """Do nothing. Args: diff --git a/src/anomalib/models/__init__.py b/src/anomalib/models/__init__.py index b4bb36a875..3b32c83367 100644 --- a/src/anomalib/models/__init__.py +++ b/src/anomalib/models/__init__.py @@ -30,6 +30,7 @@ Rkde, Stfpm, Uflow, + VlmAd, WinClip, ) from .video import AiVad @@ -57,8 +58,9 @@ class UnknownModelError(ModuleNotFoundError): "Rkde", "Stfpm", "Uflow", - "AiVad", + "VlmAd", "WinClip", + "AiVad", ] logger = logging.getLogger(__name__) diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py index 7e2d9479cf..ecd4c62d13 100644 --- a/src/anomalib/models/components/base/anomaly_module.py +++ b/src/anomalib/models/components/base/anomaly_module.py @@ -20,7 +20,7 @@ from anomalib import LearningType from anomalib.metrics import AnomalibMetricCollection -from anomalib.metrics.threshold import BaseThreshold +from anomalib.metrics.threshold import Threshold from .export_mixin import ExportMixin @@ -46,8 +46,8 @@ def __init__(self) -> None: self.loss: nn.Module self.callbacks: list[Callback] - self.image_threshold: BaseThreshold - self.pixel_threshold: BaseThreshold + self.image_threshold: Threshold + self.pixel_threshold: Threshold self.normalization_metrics: MetricCollection @@ -168,20 +168,19 @@ def load_state_dict(self, state_dict: OrderedDict[str, Any], strict: bool = True if "pixel_threshold_class" in state_dict: self.pixel_threshold = self._get_instance(state_dict, "pixel_threshold_class") - if "anomaly_maps_normalization_class" in state_dict: - self.anomaly_maps_normalization_metrics = self._get_instance(state_dict, "anomaly_maps_normalization_class") - if "box_scores_normalization_class" in state_dict: - self.box_scores_normalization_metrics = self._get_instance(state_dict, "box_scores_normalization_class") + # check only for pred score normalization metrics, because if this one is present, all others are too if "pred_scores_normalization_class" in state_dict: + self.box_scores_normalization_metrics = self._get_instance(state_dict, "box_scores_normalization_class") + self.anomaly_maps_normalization_metrics = self._get_instance(state_dict, "anomaly_maps_normalization_class") self.pred_scores_normalization_metrics = self._get_instance(state_dict, "pred_scores_normalization_class") - self.normalization_metrics = MetricCollection( - { - "anomaly_maps": self.anomaly_maps_normalization_metrics, - "box_scores": self.box_scores_normalization_metrics, - "pred_scores": self.pred_scores_normalization_metrics, - }, - ) + self.normalization_metrics = MetricCollection( + { + "anomaly_maps": self.anomaly_maps_normalization_metrics, + "box_scores": self.box_scores_normalization_metrics, + "pred_scores": self.pred_scores_normalization_metrics, + }, + ) # Used to load metrics if there is any related data in state_dict self._load_metrics(state_dict) @@ -215,7 +214,8 @@ def _add_metrics(self, name: str, state_dict: OrderedDict[str, torch.Tensor]) -> logger.info("Loading %s metrics from state dict", class_name) metrics.add_metrics(metrics_cls()) - def _get_instance(self, state_dict: OrderedDict[str, Any], dict_key: str) -> BaseThreshold: + @staticmethod + def _get_instance(state_dict: OrderedDict[str, Any], dict_key: str) -> Threshold: """Get the threshold class from the ``state_dict``.""" class_path = state_dict.pop(dict_key) module = importlib.import_module(".".join(class_path.split(".")[:-1])) @@ -240,7 +240,7 @@ def set_transform(self, transform: Transform) -> None: """Update the transform linked to the model instance.""" self._transform = transform - def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform: + def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform: # noqa: PLR6301 """Default transforms. The default transform is resize to 256x256 and normalize to ImageNet stats. Individual models can override @@ -266,6 +266,8 @@ def input_size(self) -> tuple[int, int] | None: The effective input size is the size of the input tensor after the transform has been applied. If the transform is not set, or if the transform does not change the shape of the input tensor, this method will return None. """ + if self._input_size: + return self._input_size transform = self.transform or self.configure_transforms() if transform is None: return None @@ -275,6 +277,10 @@ def input_size(self) -> tuple[int, int] | None: return None return output_shape[-2:] + def set_input_size(self, input_size: tuple[int, int]) -> None: + """Update the effective input size of the model.""" + self._input_size = input_size + def on_save_checkpoint(self, checkpoint: dict[str, Any]) -> None: """Called when saving the model to a checkpoint. @@ -339,7 +345,7 @@ def from_config( model_parser.add_argument("--task", type=TaskType | str, default=TaskType.SEGMENTATION) model_parser.add_argument("--metrics.image", type=list[str] | str | None, default=["F1Score", "AUROC"]) model_parser.add_argument("--metrics.pixel", type=list[str] | str | None, default=None, required=False) - model_parser.add_argument("--metrics.threshold", type=BaseThreshold | str, default="F1AdaptiveThreshold") + model_parser.add_argument("--metrics.threshold", type=Threshold | str, default="F1AdaptiveThreshold") model_parser.add_class_arguments(Trainer, "trainer", fail_untyped=False, instantiate=False, sub_configs=True) args = ["--config", str(config_path)] for key, value in kwargs.items(): diff --git a/src/anomalib/models/components/base/export_mixin.py b/src/anomalib/models/components/base/export_mixin.py index 561136f70b..327cb87e02 100644 --- a/src/anomalib/models/components/base/export_mixin.py +++ b/src/anomalib/models/components/base/export_mixin.py @@ -12,6 +12,7 @@ import numpy as np import torch +from lightning_utilities.core.imports import module_available from torch import nn from torchmetrics import Metric from torchvision.transforms.v2 import Transform @@ -20,7 +21,6 @@ from anomalib.data import AnomalibDataModule from anomalib.deploy.export import CompressionType, ExportType, InferenceModel from anomalib.metrics import create_metric_collection -from anomalib.utils.exceptions import try_import if TYPE_CHECKING: from importlib.util import find_spec @@ -142,7 +142,9 @@ def to_onnx( export_root = _create_export_root(export_root, ExportType.ONNX) input_shape = torch.zeros((1, 3, *input_size)) if input_size else torch.zeros((1, 3, 1, 1)) dynamic_axes = ( - None if input_size else {"input": {0: "batch_size", 2: "height", 3: "weight"}, "output": {0: "batch_size"}} + {"input": {0: "batch_size"}, "output": {0: "batch_size"}} + if input_size + else {"input": {0: "batch_size", 2: "height", 3: "weight"}, "output": {0: "batch_size"}} ) _write_metadata_to_json(self._get_metadata(task), export_root) onnx_path = export_root / "model.onnx" @@ -243,7 +245,7 @@ def to_openvino( ... task="segmentation", ... ) """ - if not try_import("openvino"): + if not module_available("openvino"): logger.exception("Could not find OpenVINO. Please check OpenVINO installation.") raise ModuleNotFoundError @@ -292,7 +294,7 @@ def _compress_ov_model( Returns: model (CompiledModel): Model in the OpenVINO format compressed with NNCF quantization. """ - if not try_import("nncf"): + if not module_available("nncf"): logger.exception("Could not find NCCF. Please check NNCF installation.") raise ModuleNotFoundError @@ -310,8 +312,8 @@ def _compress_ov_model( return model + @staticmethod def _post_training_quantization_ov( - self, model: "CompiledModel", datamodule: AnomalibDataModule | None = None, ) -> "CompiledModel": @@ -330,13 +332,14 @@ def _post_training_quantization_ov( if datamodule is None: msg = "Datamodule must be provided for OpenVINO INT8_PTQ compression" raise ValueError(msg) + datamodule.setup("fit") model_input = model.input(0) if model_input.partial_shape[0].is_static: datamodule.train_batch_size = model_input.shape[0] - dataloader = datamodule.train_dataloader() + dataloader = datamodule.val_dataloader() if len(dataloader.dataset) < 300: logger.warning( f">300 images recommended for INT8 quantization, found only {len(dataloader.dataset)} images", @@ -345,8 +348,8 @@ def _post_training_quantization_ov( calibration_dataset = nncf.Dataset(dataloader, lambda x: x["image"]) return nncf.quantize(model, calibration_dataset) + @staticmethod def _accuracy_control_quantization_ov( - self, model: "CompiledModel", datamodule: AnomalibDataModule | None = None, metric: Metric | str | None = None, @@ -373,6 +376,8 @@ def _accuracy_control_quantization_ov( if datamodule is None: msg = "Datamodule must be provided for OpenVINO INT8_PTQ compression" raise ValueError(msg) + datamodule.setup("fit") + if metric is None: msg = "Metric must be provided for OpenVINO INT8_ACQ compression" raise ValueError(msg) @@ -383,14 +388,14 @@ def _accuracy_control_quantization_ov( datamodule.train_batch_size = model_input.shape[0] datamodule.eval_batch_size = model_input.shape[0] - dataloader = datamodule.train_dataloader() + dataloader = datamodule.val_dataloader() if len(dataloader.dataset) < 300: logger.warning( f">300 images recommended for INT8 quantization, found only {len(dataloader.dataset)} images", ) calibration_dataset = nncf.Dataset(dataloader, lambda x: x["image"]) - validation_dataset = nncf.Dataset(datamodule.val_dataloader()) + validation_dataset = nncf.Dataset(datamodule.test_dataloader()) if isinstance(metric, str): metric = create_metric_collection([metric])[metric] diff --git a/src/anomalib/models/components/classification/__init__.py b/src/anomalib/models/components/classification/__init__.py index 7767cb466e..253db6aee6 100644 --- a/src/anomalib/models/components/classification/__init__.py +++ b/src/anomalib/models/components/classification/__init__.py @@ -1,5 +1,8 @@ """Classification modules.""" +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + from .kde_classifier import FeatureScalingMethod, KDEClassifier __all__ = ["KDEClassifier", "FeatureScalingMethod"] diff --git a/src/anomalib/models/components/dimensionality_reduction/random_projection.py b/src/anomalib/models/components/dimensionality_reduction/random_projection.py index 3b5d1e9bf8..cfa6ecad30 100644 --- a/src/anomalib/models/components/dimensionality_reduction/random_projection.py +++ b/src/anomalib/models/components/dimensionality_reduction/random_projection.py @@ -98,7 +98,8 @@ def _sparse_random_matrix(self, n_features: int) -> torch.Tensor: return components - def _johnson_lindenstrauss_min_dim(self, n_samples: int, eps: float = 0.1) -> int | np.integer: + @staticmethod + def _johnson_lindenstrauss_min_dim(n_samples: int, eps: float = 0.1) -> int | np.integer: """Find a 'safe' number of components to randomly project to. Ref eqn 2.1 https://cseweb.ucsd.edu/~dasgupta/papers/jl.pdf diff --git a/src/anomalib/models/components/filters/__init__.py b/src/anomalib/models/components/filters/__init__.py index 2878948759..340daa47f2 100644 --- a/src/anomalib/models/components/filters/__init__.py +++ b/src/anomalib/models/components/filters/__init__.py @@ -1,5 +1,8 @@ """Implements filters used by models.""" +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + from .blur import GaussianBlur2d __all__ = ["GaussianBlur2d"] diff --git a/src/anomalib/models/components/flow/all_in_one_block.py b/src/anomalib/models/components/flow/all_in_one_block.py index 3aa0460ae1..6c6713add8 100644 --- a/src/anomalib/models/components/flow/all_in_one_block.py +++ b/src/anomalib/models/components/flow/all_in_one_block.py @@ -330,7 +330,8 @@ def forward( return (x_out,), log_jac_det - def output_dims(self, input_dims: list[tuple[int]]) -> list[tuple[int]]: + @staticmethod + def output_dims(input_dims: list[tuple[int]]) -> list[tuple[int]]: """Output dimensions of the layer. Args: diff --git a/src/anomalib/models/components/sampling/k_center_greedy.py b/src/anomalib/models/components/sampling/k_center_greedy.py index 2b0f495d28..d7ca314f33 100644 --- a/src/anomalib/models/components/sampling/k_center_greedy.py +++ b/src/anomalib/models/components/sampling/k_center_greedy.py @@ -9,9 +9,9 @@ import torch from torch.nn import functional as F # noqa: N812 +from tqdm import tqdm from anomalib.models.components.dimensionality_reduction import SparseRandomProjection -from anomalib.utils.rich import safe_track class KCenterGreedy: @@ -98,7 +98,7 @@ def select_coreset_idxs(self, selected_idxs: list[int] | None = None) -> list[in selected_coreset_idxs: list[int] = [] idx = int(torch.randint(high=self.n_observations, size=(1,)).item()) - for _ in safe_track(sequence=range(self.coreset_size), description="Selecting Coreset Indices."): + for _ in tqdm(range(self.coreset_size), desc="Selecting Coreset Indices."): self.update_distances(cluster_centers=[idx]) idx = self.get_new_idx() if idx in selected_idxs: diff --git a/src/anomalib/models/image/__init__.py b/src/anomalib/models/image/__init__.py index f3a5435038..b09da8b07b 100644 --- a/src/anomalib/models/image/__init__.py +++ b/src/anomalib/models/image/__init__.py @@ -20,6 +20,7 @@ from .rkde import Rkde from .stfpm import Stfpm from .uflow import Uflow +from .vlm_ad import VlmAd from .winclip import WinClip __all__ = [ @@ -40,5 +41,6 @@ "Rkde", "Stfpm", "Uflow", + "VlmAd", "WinClip", ] diff --git a/src/anomalib/models/image/cfa/lightning_model.py b/src/anomalib/models/image/cfa/lightning_model.py index 39838c096f..05d38689a0 100644 --- a/src/anomalib/models/image/cfa/lightning_model.py +++ b/src/anomalib/models/image/cfa/lightning_model.py @@ -104,7 +104,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) batch["anomaly_maps"] = self.model(batch["image"]) return batch - def backward(self, loss: torch.Tensor, *args, **kwargs) -> None: + @staticmethod + def backward(loss: torch.Tensor, *args, **kwargs) -> None: """Perform backward-pass for the CFA model. Args: diff --git a/src/anomalib/models/image/cfa/torch_model.py b/src/anomalib/models/image/cfa/torch_model.py index fc94f2cfdd..5a6c490fac 100644 --- a/src/anomalib/models/image/cfa/torch_model.py +++ b/src/anomalib/models/image/cfa/torch_model.py @@ -47,7 +47,7 @@ def get_return_nodes(backbone: str) -> list[str]: raise NotImplementedError(msg) return_nodes: list[str] - if backbone in ("resnet18", "wide_resnet50_2"): + if backbone in {"resnet18", "wide_resnet50_2"}: return_nodes = ["layer1", "layer2", "layer3"] elif backbone == "vgg19_bn": return_nodes = ["features.25", "features.38", "features.52"] diff --git a/src/anomalib/models/image/csflow/loss.py b/src/anomalib/models/image/csflow/loss.py index 4e7809be7a..2e5d1da8ff 100644 --- a/src/anomalib/models/image/csflow/loss.py +++ b/src/anomalib/models/image/csflow/loss.py @@ -10,7 +10,8 @@ class CsFlowLoss(nn.Module): """Loss function for the CS-Flow Model Implementation.""" - def forward(self, z_dist: torch.Tensor, jacobians: torch.Tensor) -> torch.Tensor: + @staticmethod + def forward(z_dist: torch.Tensor, jacobians: torch.Tensor) -> torch.Tensor: """Compute the loss CS-Flow. Args: diff --git a/src/anomalib/models/image/csflow/torch_model.py b/src/anomalib/models/image/csflow/torch_model.py index 08c9106a3c..6569c7a0dd 100644 --- a/src/anomalib/models/image/csflow/torch_model.py +++ b/src/anomalib/models/image/csflow/torch_model.py @@ -271,7 +271,8 @@ def forward( return [input_tensor[i][:, self.perm_inv[i]] for i in range(self.n_inputs)], 0.0 - def output_dims(self, input_dims: list[tuple[int]]) -> list[tuple[int]]: + @staticmethod + def output_dims(input_dims: list[tuple[int]]) -> list[tuple[int]]: """Return the output dimensions of the module.""" return input_dims @@ -402,7 +403,8 @@ def forward( # Since Jacobians are only used for computing loss and summed in the loss, the idea is to sum them here return [z_dist0, z_dist1, z_dist2], torch.stack([jac0, jac1, jac2], dim=1).sum() - def output_dims(self, input_dims: list[tuple[int]]) -> list[tuple[int]]: + @staticmethod + def output_dims(input_dims: list[tuple[int]]) -> list[tuple[int]]: """Output dimensions of the module.""" return input_dims @@ -591,7 +593,8 @@ def forward(self, images: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: output = {"anomaly_map": anomaly_maps, "pred_score": anomaly_scores} return output - def _compute_anomaly_scores(self, z_dists: torch.Tensor) -> torch.Tensor: + @staticmethod + def _compute_anomaly_scores(z_dists: torch.Tensor) -> torch.Tensor: """Get anomaly scores from the latent distribution. Args: diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py index f33bff6538..6eb0e197fc 100644 --- a/src/anomalib/models/image/draem/lightning_model.py +++ b/src/anomalib/models/image/draem/lightning_model.py @@ -12,6 +12,7 @@ import torch from lightning.pytorch.utilities.types import STEP_OUTPUT from torch import nn +from torchvision.transforms.v2 import Compose, Resize, Transform from anomalib import LearningType from anomalib.data.utils import Augmenter @@ -150,3 +151,13 @@ def learning_type(self) -> LearningType: LearningType: Learning type of the model. """ return LearningType.ONE_CLASS + + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform: + """Default transform for DRAEM. Normalization is not needed as the images are scaled to [0, 1] in Dataset.""" + image_size = image_size or (256, 256) + return Compose( + [ + Resize(image_size, antialias=True), + ], + ) diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py index e9eb4d2693..8381fce73d 100644 --- a/src/anomalib/models/image/dsr/lightning_model.py +++ b/src/anomalib/models/image/dsr/lightning_model.py @@ -13,6 +13,7 @@ import torch from lightning.pytorch.utilities.types import STEP_OUTPUT, OptimizerLRScheduler from torch import Tensor +from torchvision.transforms.v2 import Compose, Resize, Transform from anomalib import LearningType from anomalib.data.utils import DownloadInfo, download_and_extract @@ -55,7 +56,8 @@ def __init__(self, latent_anomaly_strength: float = 0.2, upsampling_train_ratio: self.second_phase: int - def prepare_pretrained_model(self) -> Path: + @staticmethod + def prepare_pretrained_model() -> Path: """Download pre-trained models if they don't exist.""" pretrained_models_dir = Path("./pre_trained/") if not (pretrained_models_dir / "vq_model_pretrained_128_4096.pckl").is_file(): @@ -190,3 +192,13 @@ def learning_type(self) -> LearningType: LearningType: Learning type of the model. """ return LearningType.ONE_CLASS + + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform: + """Default transform for DSR. Normalization is not needed as the images are scaled to [0, 1] in Dataset.""" + image_size = image_size or (256, 256) + return Compose( + [ + Resize(image_size, antialias=True), + ], + ) diff --git a/src/anomalib/models/image/dsr/torch_model.py b/src/anomalib/models/image/dsr/torch_model.py index 34bc9b915d..395c1d2b5d 100644 --- a/src/anomalib/models/image/dsr/torch_model.py +++ b/src/anomalib/models/image/dsr/torch_model.py @@ -1093,8 +1093,8 @@ def vq_vae_bot(self) -> VectorQuantizer: """Return ``self._vq_vae_bot``.""" return self._vq_vae_bot + @staticmethod def generate_fake_anomalies_joined( - self, features: torch.Tensor, embeddings: torch.Tensor, memory_torch_original: torch.Tensor, diff --git a/src/anomalib/models/image/efficient_ad/lightning_model.py b/src/anomalib/models/image/efficient_ad/lightning_model.py index 9d1e23a06c..216ab418bf 100644 --- a/src/anomalib/models/image/efficient_ad/lightning_model.py +++ b/src/anomalib/models/image/efficient_ad/lightning_model.py @@ -321,7 +321,8 @@ def learning_type(self) -> LearningType: """ return LearningType.ONE_CLASS - def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform: + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform: """Default transform for EfficientAd. Imagenet normalization applied in forward.""" image_size = image_size or (256, 256) return Compose( diff --git a/src/anomalib/models/image/efficient_ad/torch_model.py b/src/anomalib/models/image/efficient_ad/torch_model.py index ee43879155..12f320e263 100644 --- a/src/anomalib/models/image/efficient_ad/torch_model.py +++ b/src/anomalib/models/image/efficient_ad/torch_model.py @@ -319,7 +319,8 @@ def __init__( }, ) - def is_set(self, p_dic: nn.ParameterDict) -> bool: + @staticmethod + def is_set(p_dic: nn.ParameterDict) -> bool: """Check if any of the parameters in the parameter dictionary is set. Args: @@ -330,7 +331,8 @@ def is_set(self, p_dic: nn.ParameterDict) -> bool: """ return any(value.sum() != 0 for _, value in p_dic.items()) - def choose_random_aug_image(self, image: torch.Tensor) -> torch.Tensor: + @staticmethod + def choose_random_aug_image(image: torch.Tensor) -> torch.Tensor: """Choose a random augmentation function and apply it to the input image. Args: diff --git a/src/anomalib/models/image/fastflow/loss.py b/src/anomalib/models/image/fastflow/loss.py index b29e6159cf..a47f49df88 100644 --- a/src/anomalib/models/image/fastflow/loss.py +++ b/src/anomalib/models/image/fastflow/loss.py @@ -10,7 +10,8 @@ class FastflowLoss(nn.Module): """FastFlow Loss.""" - def forward(self, hidden_variables: list[torch.Tensor], jacobians: list[torch.Tensor]) -> torch.Tensor: + @staticmethod + def forward(hidden_variables: list[torch.Tensor], jacobians: list[torch.Tensor]) -> torch.Tensor: """Calculate the Fastflow loss. Args: diff --git a/src/anomalib/models/image/fastflow/torch_model.py b/src/anomalib/models/image/fastflow/torch_model.py index 3e61112402..379416a8f3 100644 --- a/src/anomalib/models/image/fastflow/torch_model.py +++ b/src/anomalib/models/image/fastflow/torch_model.py @@ -124,11 +124,11 @@ def __init__( self.input_size = input_size - if backbone in ("cait_m48_448", "deit_base_distilled_patch16_384"): + if backbone in {"cait_m48_448", "deit_base_distilled_patch16_384"}: self.feature_extractor = timm.create_model(backbone, pretrained=pre_trained) channels = [768] scales = [16] - elif backbone in ("resnet18", "wide_resnet50_2"): + elif backbone in {"resnet18", "wide_resnet50_2"}: self.feature_extractor = timm.create_model( backbone, pretrained=pre_trained, diff --git a/src/anomalib/models/image/padim/anomaly_map.py b/src/anomalib/models/image/padim/anomaly_map.py index af43363629..054a930664 100644 --- a/src/anomalib/models/image/padim/anomaly_map.py +++ b/src/anomalib/models/image/padim/anomaly_map.py @@ -48,7 +48,8 @@ def compute_distance(embedding: torch.Tensor, stats: list[torch.Tensor]) -> torc distances = distances.reshape(batch, 1, height, width) return distances.clamp(0).sqrt() - def up_sample(self, distance: torch.Tensor, image_size: tuple[int, int] | torch.Size) -> torch.Tensor: + @staticmethod + def up_sample(distance: torch.Tensor, image_size: tuple[int, int] | torch.Size) -> torch.Tensor: """Up sample anomaly score to match the input image size. Args: diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py index 4912553291..c232403852 100644 --- a/src/anomalib/models/image/padim/lightning_model.py +++ b/src/anomalib/models/image/padim/lightning_model.py @@ -122,7 +122,8 @@ def learning_type(self) -> LearningType: """ return LearningType.ONE_CLASS - def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform: + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform: """Default transform for Padim.""" image_size = image_size or (256, 256) return Compose( diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py index ca0b2081d4..3f471a159c 100644 --- a/src/anomalib/models/image/patchcore/lightning_model.py +++ b/src/anomalib/models/image/patchcore/lightning_model.py @@ -57,7 +57,8 @@ def __init__( self.coreset_sampling_ratio = coreset_sampling_ratio self.embeddings: list[torch.Tensor] = [] - def configure_optimizers(self) -> None: + @staticmethod + def configure_optimizers() -> None: """Configure optimizers. Returns: @@ -126,7 +127,8 @@ def learning_type(self) -> LearningType: """ return LearningType.ONE_CLASS - def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform: + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform: """Default transform for Padim.""" image_size = image_size or (256, 256) # scale center crop size proportional to image size diff --git a/src/anomalib/models/image/reverse_distillation/anomaly_map.py b/src/anomalib/models/image/reverse_distillation/anomaly_map.py index bcc59f3d17..74dc19e1df 100644 --- a/src/anomalib/models/image/reverse_distillation/anomaly_map.py +++ b/src/anomalib/models/image/reverse_distillation/anomaly_map.py @@ -52,7 +52,7 @@ def __init__( self.sigma = sigma self.kernel_size = 2 * int(4.0 * sigma + 0.5) + 1 - if mode not in (AnomalyMapGenerationMode.ADD, AnomalyMapGenerationMode.MULTIPLY): + if mode not in {AnomalyMapGenerationMode.ADD, AnomalyMapGenerationMode.MULTIPLY}: msg = f"Found mode {mode}. Only multiply and add are supported." raise ValueError(msg) self.mode = mode diff --git a/src/anomalib/models/image/reverse_distillation/components/__init__.py b/src/anomalib/models/image/reverse_distillation/components/__init__.py index 631eba439a..b3f4796605 100644 --- a/src/anomalib/models/image/reverse_distillation/components/__init__.py +++ b/src/anomalib/models/image/reverse_distillation/components/__init__.py @@ -1,18 +1,7 @@ """PyTorch modules for Reverse Distillation.""" # Copyright (C) 2022-2024 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. +# SPDX-License-Identifier: Apache-2.0 from .bottleneck import get_bottleneck_layer from .de_resnet import get_decoder diff --git a/src/anomalib/models/image/reverse_distillation/components/bottleneck.py b/src/anomalib/models/image/reverse_distillation/components/bottleneck.py index 6949368410..220fc1d670 100644 --- a/src/anomalib/models/image/reverse_distillation/components/bottleneck.py +++ b/src/anomalib/models/image/reverse_distillation/components/bottleneck.py @@ -163,4 +163,4 @@ def get_bottleneck_layer(backbone: str, **kwargs) -> OCBE: Returns: Bottleneck_layer: One-Class Bottleneck Embedding module. """ - return OCBE(BasicBlock, 2, **kwargs) if backbone in ("resnet18", "resnet34") else OCBE(Bottleneck, 3, **kwargs) + return OCBE(BasicBlock, 2, **kwargs) if backbone in {"resnet18", "resnet34"} else OCBE(Bottleneck, 3, **kwargs) diff --git a/src/anomalib/models/image/reverse_distillation/components/de_resnet.py b/src/anomalib/models/image/reverse_distillation/components/de_resnet.py index 7c7ca25ebe..3bb8886e8b 100644 --- a/src/anomalib/models/image/reverse_distillation/components/de_resnet.py +++ b/src/anomalib/models/image/reverse_distillation/components/de_resnet.py @@ -336,7 +336,7 @@ def get_decoder(name: str) -> ResNet: Returns: ResNet: Decoder ResNet architecture. """ - if name in ( + if name in { "resnet18", "resnet34", "resnet50", @@ -346,7 +346,7 @@ def get_decoder(name: str) -> ResNet: "resnext101_32x8d", "wide_resnet50_2", "wide_resnet101_2", - ): + }: decoder = globals()[f"de_{name}"] else: msg = f"Decoder with architecture {name} not supported" diff --git a/src/anomalib/models/image/reverse_distillation/loss.py b/src/anomalib/models/image/reverse_distillation/loss.py index 03d2107829..3d563238ff 100644 --- a/src/anomalib/models/image/reverse_distillation/loss.py +++ b/src/anomalib/models/image/reverse_distillation/loss.py @@ -10,7 +10,8 @@ class ReverseDistillationLoss(nn.Module): """Loss function for Reverse Distillation.""" - def forward(self, encoder_features: list[torch.Tensor], decoder_features: list[torch.Tensor]) -> torch.Tensor: + @staticmethod + def forward(encoder_features: list[torch.Tensor], decoder_features: list[torch.Tensor]) -> torch.Tensor: """Compute cosine similarity loss based on features from encoder and decoder. Based on the official code: diff --git a/src/anomalib/models/image/rkde/lightning_model.py b/src/anomalib/models/image/rkde/lightning_model.py index 02ad6c2564..f8b6af6d7a 100644 --- a/src/anomalib/models/image/rkde/lightning_model.py +++ b/src/anomalib/models/image/rkde/lightning_model.py @@ -11,6 +11,7 @@ import torch from lightning.pytorch.utilities.types import STEP_OUTPUT +from torchvision.transforms.v2 import Compose, Resize, Transform from anomalib import LearningType from anomalib.models.components import AnomalyModule, MemoryBankMixin @@ -143,3 +144,13 @@ def learning_type(self) -> LearningType: LearningType: Learning type of the model. """ return LearningType.ONE_CLASS + + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform: + """Default transform for RKDE.""" + image_size = image_size or (240, 360) + return Compose( + [ + Resize(image_size, antialias=True), + ], + ) diff --git a/src/anomalib/models/image/stfpm/anomaly_map.py b/src/anomalib/models/image/stfpm/anomaly_map.py index ee3f2ccee3..9cd7887fea 100644 --- a/src/anomalib/models/image/stfpm/anomaly_map.py +++ b/src/anomalib/models/image/stfpm/anomaly_map.py @@ -15,8 +15,8 @@ def __init__(self) -> None: super().__init__() self.distance = torch.nn.PairwiseDistance(p=2, keepdim=True) + @staticmethod def compute_layer_map( - self, teacher_features: torch.Tensor, student_features: torch.Tensor, image_size: tuple[int, int] | torch.Size, diff --git a/src/anomalib/models/image/uflow/feature_extraction.py b/src/anomalib/models/image/uflow/feature_extraction.py index 1e6385fc4d..50cd2ba5e3 100644 --- a/src/anomalib/models/image/uflow/feature_extraction.py +++ b/src/anomalib/models/image/uflow/feature_extraction.py @@ -33,7 +33,7 @@ def get_feature_extractor(backbone: str, input_size: tuple[int, int] = (256, 256 raise ValueError(msg) feature_extractor: nn.Module - if backbone in ["resnet18", "wide_resnet50_2"]: + if backbone in {"resnet18", "wide_resnet50_2"}: feature_extractor = FeatureExtractor(backbone, input_size, layers=("layer1", "layer2", "layer3")).eval() if backbone == "mcait": feature_extractor = MCaitFeatureExtractor().eval() diff --git a/src/anomalib/models/image/uflow/lightning_model.py b/src/anomalib/models/image/uflow/lightning_model.py index cbc24e2717..06ed9b9eeb 100644 --- a/src/anomalib/models/image/uflow/lightning_model.py +++ b/src/anomalib/models/image/uflow/lightning_model.py @@ -118,7 +118,8 @@ def learning_type(self) -> LearningType: """ return LearningType.ONE_CLASS - def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform: + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform: """Default transform for Padim.""" if image_size is not None: logger.warning("Image size is not used in UFlow. The input image size is determined by the model.") diff --git a/src/anomalib/models/image/uflow/loss.py b/src/anomalib/models/image/uflow/loss.py index 7afe8a1fc2..08f2dfbe31 100644 --- a/src/anomalib/models/image/uflow/loss.py +++ b/src/anomalib/models/image/uflow/loss.py @@ -10,7 +10,8 @@ class UFlowLoss(nn.Module): """UFlow Loss.""" - def forward(self, hidden_variables: list[Tensor], jacobians: list[Tensor]) -> Tensor: + @staticmethod + def forward(hidden_variables: list[Tensor], jacobians: list[Tensor]) -> Tensor: """Calculate the UFlow loss. Args: diff --git a/src/anomalib/models/image/vlm_ad/__init__.py b/src/anomalib/models/image/vlm_ad/__init__.py new file mode 100644 index 0000000000..46ab8e0fee --- /dev/null +++ b/src/anomalib/models/image/vlm_ad/__init__.py @@ -0,0 +1,8 @@ +"""Visual Anomaly Model.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from .lightning_model import VlmAd + +__all__ = ["VlmAd"] diff --git a/src/anomalib/models/image/vlm_ad/backends/__init__.py b/src/anomalib/models/image/vlm_ad/backends/__init__.py new file mode 100644 index 0000000000..44009f8f83 --- /dev/null +++ b/src/anomalib/models/image/vlm_ad/backends/__init__.py @@ -0,0 +1,11 @@ +"""VLM backends.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from .base import Backend +from .chat_gpt import ChatGPT +from .huggingface import Huggingface +from .ollama import Ollama + +__all__ = ["Backend", "ChatGPT", "Huggingface", "Ollama"] diff --git a/src/anomalib/models/image/vlm_ad/backends/base.py b/src/anomalib/models/image/vlm_ad/backends/base.py new file mode 100644 index 0000000000..b4aadf9a22 --- /dev/null +++ b/src/anomalib/models/image/vlm_ad/backends/base.py @@ -0,0 +1,30 @@ +"""Base backend.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from abc import ABC, abstractmethod +from pathlib import Path + +from anomalib.models.image.vlm_ad.utils import Prompt + + +class Backend(ABC): + """Base backend.""" + + @abstractmethod + def __init__(self, model_name: str) -> None: + """Initialize the backend.""" + + @abstractmethod + def add_reference_images(self, image: str | Path) -> None: + """Add reference images for k-shot.""" + + @abstractmethod + def predict(self, image: str | Path, prompt: Prompt) -> str: + """Predict the anomaly label.""" + + @property + @abstractmethod + def num_reference_images(self) -> int: + """Get the number of reference images.""" diff --git a/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py b/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py new file mode 100644 index 0000000000..53648e688a --- /dev/null +++ b/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py @@ -0,0 +1,109 @@ +"""ChatGPT backend.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import base64 +import logging +import os +from pathlib import Path +from typing import TYPE_CHECKING + +from dotenv import load_dotenv +from lightning_utilities.core.imports import module_available + +from anomalib.models.image.vlm_ad.utils import Prompt + +from .base import Backend + +if module_available("openai"): + from openai import OpenAI +else: + OpenAI = None + +if TYPE_CHECKING: + from openai.types.chat import ChatCompletion + +logger = logging.getLogger(__name__) + + +class ChatGPT(Backend): + """ChatGPT backend.""" + + def __init__(self, model_name: str, api_key: str | None = None) -> None: + """Initialize the ChatGPT backend.""" + self._ref_images_encoded: list[str] = [] + self.model_name: str = model_name + self._client: OpenAI | None = None + self.api_key = self._get_api_key(api_key) + + @property + def client(self) -> OpenAI: + """Get the OpenAI client.""" + if OpenAI is None: + msg = "OpenAI is not installed. Please install it to use ChatGPT backend." + raise ImportError(msg) + if self._client is None: + self._client = OpenAI(api_key=self.api_key) + return self._client + + def add_reference_images(self, image: str | Path) -> None: + """Add reference images for k-shot.""" + self._ref_images_encoded.append(self._encode_image_to_url(image)) + + @property + def num_reference_images(self) -> int: + """Get the number of reference images.""" + return len(self._ref_images_encoded) + + def predict(self, image: str | Path, prompt: Prompt) -> str: + """Predict the anomaly label.""" + image_encoded = self._encode_image_to_url(image) + messages = [] + + # few-shot + if len(self._ref_images_encoded) > 0: + messages.append(self._generate_message(content=prompt.few_shot, images=self._ref_images_encoded)) + + messages.append(self._generate_message(content=prompt.predict, images=[image_encoded])) + + response: ChatCompletion = self.client.chat.completions.create(messages=messages, model=self.model_name) + return response.choices[0].message.content + + @staticmethod + def _generate_message(content: str, images: list[str] | None) -> dict: + """Generate a message.""" + message: dict[str, list[dict] | str] = {"role": "user"} + if images is not None: + _content: list[dict[str, str | dict]] = [{"type": "text", "text": content}] + _content.extend([{"type": "image_url", "image_url": {"url": image}} for image in images]) + message["content"] = _content + else: + message["content"] = content + return message + + def _encode_image_to_url(self, image: str | Path) -> str: + """Encode the image to base64 and embed in url string.""" + image_path = Path(image) + extension = image_path.suffix + base64_encoded = self._encode_image_to_base_64(image_path) + return f"data:image/{extension};base64,{base64_encoded}" + + @staticmethod + def _encode_image_to_base_64(image: str | Path) -> str: + """Encode the image to base64.""" + image = Path(image) + return base64.b64encode(image.read_bytes()).decode("utf-8") + + def _get_api_key(self, api_key: str | None = None) -> str: + if api_key is None: + load_dotenv() + api_key = os.getenv("OPENAI_API_KEY") + if api_key is None: + msg = ( + f"OpenAI API key must be provided to use {self.model_name}." + " Please provide the API key in the constructor, or set the OPENAI_API_KEY environment variable" + " or in a `.env` file." + ) + raise ValueError(msg) + return api_key diff --git a/src/anomalib/models/image/vlm_ad/backends/huggingface.py b/src/anomalib/models/image/vlm_ad/backends/huggingface.py new file mode 100644 index 0000000000..e8d3c1e84b --- /dev/null +++ b/src/anomalib/models/image/vlm_ad/backends/huggingface.py @@ -0,0 +1,98 @@ +"""Huggingface backend.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from pathlib import Path +from typing import TYPE_CHECKING + +from lightning_utilities.core.imports import module_available +from PIL import Image + +from anomalib.models.image.vlm_ad.utils import Prompt + +from .base import Backend + +if TYPE_CHECKING: + from transformers.modeling_utils import PreTrainedModel + from transformers.processing_utils import ProcessorMixin + +if module_available("transformers"): + import transformers +else: + transformers = None + + +logger = logging.getLogger(__name__) + + +class Huggingface(Backend): + """Huggingface backend.""" + + def __init__( + self, + model_name: str, + ) -> None: + """Initialize the Huggingface backend.""" + self.model_name: str = model_name + self._ref_images: list[str] = [] + self._processor: ProcessorMixin | None = None + self._model: PreTrainedModel | None = None + + @property + def processor(self) -> "ProcessorMixin": + """Get the Huggingface processor.""" + if self._processor is None: + if transformers is None: + msg = "transformers is not installed." + raise ValueError(msg) + self._processor = transformers.LlavaNextProcessor.from_pretrained(self.model_name) + return self._processor + + @property + def model(self) -> "PreTrainedModel": + """Get the Huggingface model.""" + if self._model is None: + if transformers is None: + msg = "transformers is not installed." + raise ValueError(msg) + self._model = transformers.LlavaNextForConditionalGeneration.from_pretrained(self.model_name) + return self._model + + @staticmethod + def _generate_message(content: str, images: list[str] | None) -> dict: + """Generate a message.""" + message: dict[str, str | list[dict]] = {"role": "user"} + _content: list[dict[str, str]] = [{"type": "text", "text": content}] + if images is not None: + _content.extend([{"type": "image"} for _ in images]) + message["content"] = _content + return message + + def add_reference_images(self, image: str | Path) -> None: + """Add reference images for k-shot.""" + self._ref_images.append(Image.open(image)) + + @property + def num_reference_images(self) -> int: + """Get the number of reference images.""" + return len(self._ref_images) + + def predict(self, image_path: str | Path, prompt: Prompt) -> str: + """Predict the anomaly label.""" + image = Image.open(image_path) + messages: list[dict] = [] + + if len(self._ref_images) > 0: + messages.append(self._generate_message(content=prompt.few_shot, images=self._ref_images)) + + messages.append(self._generate_message(content=prompt.predict, images=[image])) + processed_prompt = [self.processor.apply_chat_template(messages, add_generation_prompt=True)] + + images = [*self._ref_images, image] + inputs = self.processor(images, processed_prompt, return_tensors="pt", padding=True).to(self.model.device) + outputs = self.model.generate(**inputs, max_new_tokens=100) + result = self.processor.decode(outputs[0], skip_special_tokens=True) + print(result) + return result diff --git a/src/anomalib/models/image/vlm_ad/backends/ollama.py b/src/anomalib/models/image/vlm_ad/backends/ollama.py new file mode 100644 index 0000000000..ff680bee3b --- /dev/null +++ b/src/anomalib/models/image/vlm_ad/backends/ollama.py @@ -0,0 +1,73 @@ +"""Ollama backend. + +Assumes that the Ollama service is running in the background. +See: https://github.com/ollama/ollama +Ensure that ollama is running. On linux: `ollama serve` +On Mac and Windows ensure that the ollama service is running by launching from the application list. +""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from pathlib import Path + +from lightning_utilities.core.imports import module_available + +from anomalib.models.image.vlm_ad.utils import Prompt + +from .base import Backend + +if module_available("ollama"): + from ollama import chat + from ollama._client import _encode_image +else: + chat = None + +logger = logging.getLogger(__name__) + + +class Ollama(Backend): + """Ollama backend.""" + + def __init__(self, model_name: str) -> None: + """Initialize the Ollama backend.""" + self.model_name: str = model_name + self._ref_images_encoded: list[str] = [] + + def add_reference_images(self, image: str | Path) -> None: + """Encode the image to base64.""" + self._ref_images_encoded.append(_encode_image(image)) + + @property + def num_reference_images(self) -> int: + """Get the number of reference images.""" + return len(self._ref_images_encoded) + + @staticmethod + def _generate_message(content: str, images: list[str] | None) -> dict: + """Generate a message.""" + message: dict[str, str | list[str]] = {"role": "user", "content": content} + if images: + message["images"] = images + return message + + def predict(self, image: str | Path, prompt: Prompt) -> str: + """Predict the anomaly label.""" + if not chat: + msg = "Ollama is not installed. Please install it using `pip install ollama`." + raise ImportError(msg) + image_encoded = _encode_image(image) + messages = [] + + # few-shot + if len(self._ref_images_encoded) > 0: + messages.append(self._generate_message(content=prompt.few_shot, images=self._ref_images_encoded)) + + messages.append(self._generate_message(content=prompt.predict, images=[image_encoded])) + + response = chat( + model=self.model_name, + messages=messages, + ) + return response["message"]["content"].strip() diff --git a/src/anomalib/models/image/vlm_ad/lightning_model.py b/src/anomalib/models/image/vlm_ad/lightning_model.py new file mode 100644 index 0000000000..1279f7a31e --- /dev/null +++ b/src/anomalib/models/image/vlm_ad/lightning_model.py @@ -0,0 +1,115 @@ +"""Visual Anomaly Model for Zero/Few-Shot Anomaly Classification.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging + +import torch +from torch.utils.data import DataLoader + +from anomalib import LearningType +from anomalib.models import AnomalyModule + +from .backends import Backend, ChatGPT, Huggingface, Ollama +from .utils import ModelName, Prompt + +logger = logging.getLogger(__name__) + + +class VlmAd(AnomalyModule): + """Visual anomaly model.""" + + def __init__( + self, + model: ModelName | str = ModelName.LLAMA_OLLAMA, + api_key: str | None = None, + k_shot: int = 0, + ) -> None: + super().__init__() + self.k_shot = k_shot + model = ModelName(model) + self.vlm_backend: Backend = self._setup_vlm_backend(model, api_key) + + @staticmethod + def _setup_vlm_backend(model_name: ModelName, api_key: str | None) -> Backend: + if model_name == ModelName.LLAMA_OLLAMA: + return Ollama(model_name=model_name.value) + if model_name == ModelName.GPT_4O_MINI: + return ChatGPT(api_key=api_key, model_name=model_name.value) + if model_name in {ModelName.VICUNA_7B_HF, ModelName.VICUNA_13B_HF, ModelName.MISTRAL_7B_HF}: + return Huggingface(model_name=model_name.value) + + msg = f"Unsupported VLM model: {model_name}" + raise ValueError(msg) + + def _setup(self) -> None: + if self.k_shot > 0 and self.vlm_backend.num_reference_images != self.k_shot: + logger.info("Collecting reference images from training dataset.") + dataloader = self.trainer.datamodule.train_dataloader() + self.collect_reference_images(dataloader) + + def collect_reference_images(self, dataloader: DataLoader) -> None: + """Collect reference images for few-shot inference.""" + for batch in dataloader: + for img_path in batch["image_path"]: + self.vlm_backend.add_reference_images(img_path) + if self.vlm_backend.num_reference_images == self.k_shot: + return + + @property + def prompt(self) -> Prompt: + """Get the prompt.""" + return Prompt( + predict=( + "You are given an image. It is either normal or anomalous." + " First say 'YES' if the image is anomalous, or 'NO' if it is normal.\n" + "Then give the reason for your decision.\n" + "For example, 'YES: The image has a crack on the wall.'" + ), + few_shot=( + "These are a few examples of normal picture without any anomalies." + " You have to use these to determine if the image I provide in the next" + " chat is normal or anomalous." + ), + ) + + def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> dict: + """Validation step.""" + del args, kwargs # These variables are not used. + responses = [(self.vlm_backend.predict(img_path, self.prompt)) for img_path in batch["image_path"]] + batch["explanation"] = responses + batch["pred_scores"] = torch.tensor([1.0 if r.startswith("Y") else 0.0 for r in responses], device=self.device) + return batch + + @property + def learning_type(self) -> LearningType: + """The learning type of the model.""" + return LearningType.ZERO_SHOT if self.k_shot == 0 else LearningType.FEW_SHOT + + @property + def trainer_arguments(self) -> dict[str, int | float]: + """Doesn't need training.""" + return {} + + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> None: + """This modes does not require any transforms.""" + if image_size is not None: + logger.warning("Ignoring image_size argument as each backend has its own transforms.") + + @staticmethod + def _export_not_supported_message() -> None: + logging.warning("Exporting the model is not supported for VLM-AD model. Skipping...") + + def to_torch(self, *_, **__) -> None: # type: ignore[override] + """Skip export to torch.""" + return self._export_not_supported_message() + + def to_onnx(self, *_, **__) -> None: # type: ignore[override] + """Skip export to onnx.""" + return self._export_not_supported_message() + + def to_openvino(self, *_, **__) -> None: # type: ignore[override] + """Skip export to openvino.""" + return self._export_not_supported_message() diff --git a/src/anomalib/models/image/vlm_ad/utils.py b/src/anomalib/models/image/vlm_ad/utils.py new file mode 100644 index 0000000000..ce9b9067ac --- /dev/null +++ b/src/anomalib/models/image/vlm_ad/utils.py @@ -0,0 +1,25 @@ +"""Dataclasses.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from dataclasses import dataclass +from enum import Enum + + +@dataclass +class Prompt: + """Prompt.""" + + few_shot: str + predict: str + + +class ModelName(Enum): + """List of supported models.""" + + LLAMA_OLLAMA = "llava" + GPT_4O_MINI = "gpt-4o-mini" + VICUNA_7B_HF = "llava-hf/llava-v1.6-vicuna-7b-hf" + VICUNA_13B_HF = "llava-hf/llava-v1.6-vicuna-13b-hf" + MISTRAL_7B_HF = "llava-hf/llava-v1.6-mistral-7b-hf" diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py index 0d86697faf..6a405969fd 100644 --- a/src/anomalib/models/image/winclip/lightning_model.py +++ b/src/anomalib/models/image/winclip/lightning_model.py @@ -168,7 +168,8 @@ def load_state_dict(self, state_dict: OrderedDict[str, Any], strict: bool = True state_dict.update(restore_dict) return super().load_state_dict(state_dict, strict) - def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform: + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform: """Configure the default transforms used by the model.""" if image_size is not None: logger.warning("Image size is not used in WinCLIP. The input image size is determined by the model.") diff --git a/src/anomalib/models/video/ai_vad/clip/clip.py b/src/anomalib/models/video/ai_vad/clip/clip.py index 553f55bf7d..905e07fc35 100644 --- a/src/anomalib/models/video/ai_vad/clip/clip.py +++ b/src/anomalib/models/video/ai_vad/clip/clip.py @@ -104,15 +104,13 @@ def _convert_image_to_rgb(image): def _transform(n_px): - return Compose( - [ - Resize(n_px, interpolation=BICUBIC), - CenterCrop(n_px), - _convert_image_to_rgb, - ToTensor(), - Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), - ] - ) + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) def available_models() -> List[str]: diff --git a/src/anomalib/models/video/ai_vad/clip/model.py b/src/anomalib/models/video/ai_vad/clip/model.py index 9f23afa8fc..06ee36922e 100644 --- a/src/anomalib/models/video/ai_vad/clip/model.py +++ b/src/anomalib/models/video/ai_vad/clip/model.py @@ -45,13 +45,11 @@ def __init__(self, inplanes, planes, stride=1): if stride > 1 or inplanes != planes * Bottleneck.expansion: # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1 self.downsample = nn.Sequential( - OrderedDict( - [ - ("-1", nn.AvgPool2d(stride)), - ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)), - ("1", nn.BatchNorm2d(planes * self.expansion)), - ] - ) + OrderedDict([ + ("-1", nn.AvgPool2d(stride)), + ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)), + ("1", nn.BatchNorm2d(planes * self.expansion)), + ]) ) def forward(self, x: torch.Tensor): @@ -192,13 +190,11 @@ def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None): self.attn = nn.MultiheadAttention(d_model, n_head) self.ln_1 = LayerNorm(d_model) self.mlp = nn.Sequential( - OrderedDict( - [ - ("c_fc", nn.Linear(d_model, d_model * 4)), - ("gelu", QuickGELU()), - ("c_proj", nn.Linear(d_model * 4, d_model)), - ] - ) + OrderedDict([ + ("c_fc", nn.Linear(d_model, d_model * 4)), + ("gelu", QuickGELU()), + ("c_proj", nn.Linear(d_model * 4, d_model)), + ]) ) self.ln_2 = LayerNorm(d_model) self.attn_mask = attn_mask @@ -430,9 +426,9 @@ def build_model(state_dict: dict): if vit: vision_width = state_dict["visual.conv1.weight"].shape[0] - vision_layers = len( - [k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")] - ) + vision_layers = len([ + k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight") + ]) vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5) image_resolution = vision_patch_size * grid_size diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py index dde0149b3b..40f6d50b8b 100644 --- a/src/anomalib/models/video/ai_vad/lightning_model.py +++ b/src/anomalib/models/video/ai_vad/lightning_model.py @@ -159,7 +159,8 @@ def learning_type(self) -> LearningType: """ return LearningType.ONE_CLASS - def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform | None: + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform | None: """AI-VAD does not need a transform, as the region- and feature-extractors apply their own transforms.""" del image_size return None diff --git a/src/anomalib/models/video/ai_vad/regions.py b/src/anomalib/models/video/ai_vad/regions.py index 165de0091a..441af32493 100644 --- a/src/anomalib/models/video/ai_vad/regions.py +++ b/src/anomalib/models/video/ai_vad/regions.py @@ -73,18 +73,18 @@ def forward(self, first_frame: torch.Tensor, last_frame: torch.Tensor) -> list[d regions = self.backbone(last_frame) if self.enable_foreground_detections: - regions = self.add_foreground_boxes( - regions, - first_frame, - last_frame, - self.foreground_kernel_size, - self.foreground_binary_threshold, + regions = self._add_foreground_boxes( + regions=regions, + first_frame=first_frame, + last_frame=last_frame, + kernel_size=self.foreground_kernel_size, + binary_threshold=self.foreground_binary_threshold, ) return self.post_process_bbox_detections(regions) - def add_foreground_boxes( - self, + @staticmethod + def _add_foreground_boxes( regions: list[dict[str, torch.Tensor]], first_frame: torch.Tensor, last_frame: torch.Tensor, diff --git a/src/anomalib/pipelines/benchmark/generator.py b/src/anomalib/pipelines/benchmark/generator.py index 922dfa06cb..988e0111b7 100644 --- a/src/anomalib/pipelines/benchmark/generator.py +++ b/src/anomalib/pipelines/benchmark/generator.py @@ -10,6 +10,7 @@ from anomalib.pipelines.components import JobGenerator from anomalib.pipelines.components.utils import get_iterator_from_grid_dict from anomalib.pipelines.types import PREV_STAGE_RESULT +from anomalib.utils.config import flatten_dict from anomalib.utils.logging import hide_output from .job import BenchmarkJob @@ -39,9 +40,12 @@ def generate_jobs( """Return iterator based on the arguments.""" del previous_stage_result # Not needed for this job for _container in get_iterator_from_grid_dict(args): + # Pass experimental configs as a flatten dictionary to the job runner. + flat_cfg = flatten_dict(_container) yield BenchmarkJob( accelerator=self.accelerator, seed=_container["seed"], model=get_model(_container["model"]), datamodule=get_datamodule(_container["data"]), + flat_cfg=flat_cfg, ) diff --git a/src/anomalib/pipelines/benchmark/job.py b/src/anomalib/pipelines/benchmark/job.py index ab443cfa8a..f56899ac5d 100644 --- a/src/anomalib/pipelines/benchmark/job.py +++ b/src/anomalib/pipelines/benchmark/job.py @@ -4,6 +4,7 @@ # SPDX-License-Identifier: Apache-2.0 import logging +import time from datetime import datetime from pathlib import Path from tempfile import TemporaryDirectory @@ -31,16 +32,25 @@ class BenchmarkJob(Job): model (AnomalyModule): The model to use. datamodule (AnomalibDataModule): The data module to use. seed (int): The seed to use. + flat_cfg (dict): The flat dictionary of configs with dotted keys. """ name = "benchmark" - def __init__(self, accelerator: str, model: AnomalyModule, datamodule: AnomalibDataModule, seed: int) -> None: + def __init__( + self, + accelerator: str, + model: AnomalyModule, + datamodule: AnomalibDataModule, + seed: int, + flat_cfg: dict, + ) -> None: super().__init__() self.accelerator = accelerator self.model = model self.datamodule = datamodule self.seed = seed + self.flat_cfg = flat_cfg @hide_output def run( @@ -48,6 +58,7 @@ def run( task_id: int | None = None, ) -> dict[str, Any]: """Run the benchmark.""" + job_start_time = time.time() devices: str | list[int] = "auto" if task_id is not None: devices = [task_id] @@ -59,16 +70,22 @@ def run( devices=devices, default_root_dir=temp_dir, ) + fit_start_time = time.time() engine.fit(self.model, self.datamodule) + test_start_time = time.time() test_results = engine.test(self.model, self.datamodule) + job_end_time = time.time() + durations = { + "job_duration": job_end_time - job_start_time, + "fit_duration": test_start_time - fit_start_time, + "test_duration": job_end_time - test_start_time, + } # TODO(ashwinvaidya17): Restore throughput # https://github.com/openvinotoolkit/anomalib/issues/2054 output = { - "seed": self.seed, "accelerator": self.accelerator, - "model": self.model.__class__.__name__, - "data": self.datamodule.__class__.__name__, - "category": self.datamodule.category, + **durations, + **self.flat_cfg, **test_results[0], } logger.info(f"Completed with result {output}") diff --git a/src/anomalib/pipelines/benchmark/pipeline.py b/src/anomalib/pipelines/benchmark/pipeline.py index b4410f8094..f68ee5e2a1 100644 --- a/src/anomalib/pipelines/benchmark/pipeline.py +++ b/src/anomalib/pipelines/benchmark/pipeline.py @@ -14,16 +14,18 @@ class Benchmark(Pipeline): """Benchmarking pipeline.""" - def _setup_runners(self, args: dict) -> list[Runner]: + @staticmethod + def _setup_runners(args: dict) -> list[Runner]: """Setup the runners for the pipeline.""" accelerators = args["accelerator"] if isinstance(args["accelerator"], list) else [args["accelerator"]] runners: list[Runner] = [] for accelerator in accelerators: - if accelerator == "cpu": - runners.append(SerialRunner(BenchmarkJobGenerator("cpu"))) - elif accelerator == "cuda": - runners.append(ParallelRunner(BenchmarkJobGenerator("cuda"), n_jobs=torch.cuda.device_count())) - else: + if accelerator not in {"cpu", "cuda"}: msg = f"Unsupported accelerator: {accelerator}" raise ValueError(msg) + device_count = torch.cuda.device_count() + if device_count <= 1: + runners.append(SerialRunner(BenchmarkJobGenerator(accelerator))) + else: + runners.append(ParallelRunner(BenchmarkJobGenerator(accelerator), n_jobs=device_count)) return runners diff --git a/src/anomalib/pipelines/components/base/pipeline.py b/src/anomalib/pipelines/components/base/pipeline.py index 49328c62e0..850c64afcb 100644 --- a/src/anomalib/pipelines/components/base/pipeline.py +++ b/src/anomalib/pipelines/components/base/pipeline.py @@ -10,7 +10,7 @@ import yaml from jsonargparse import ArgumentParser, Namespace -from rich import print, traceback +from rich import traceback from anomalib.utils.logging import redirect_logs @@ -41,7 +41,7 @@ def _get_args(self, args: Namespace) -> dict: parser = self.get_parser() args = parser.parse_args() - with Path(args.config).open() as file: + with Path(args.config).open(encoding="utf-8") as file: return yaml.safe_load(file) @abstractmethod @@ -66,9 +66,9 @@ def run(self, args: Namespace | None = None) -> None: except Exception: # noqa: PERF203 catch all exception and allow try-catch in loop logger.exception("An error occurred when running the runner.") print( - f"There were some errors when running [red]{runner.generator.job_class.name}[/red] with" - f" [green]{runner.__class__.__name__}[/green]." - f" Please check [magenta]{log_file}[/magenta] for more details.", + f"There were some errors when running {runner.generator.job_class.name} with" + f" {runner.__class__.__name__}." + f" Please check {log_file} for more details.", ) @staticmethod diff --git a/src/anomalib/pipelines/components/runners/parallel.py b/src/anomalib/pipelines/components/runners/parallel.py index 03d1e6fde6..148980a6c2 100644 --- a/src/anomalib/pipelines/components/runners/parallel.py +++ b/src/anomalib/pipelines/components/runners/parallel.py @@ -8,9 +8,6 @@ from concurrent.futures import ProcessPoolExecutor from typing import TYPE_CHECKING -from rich import print -from rich.progress import Progress, TaskID - from anomalib.pipelines.components.base import JobGenerator, Runner from anomalib.pipelines.types import GATHERED_RESULTS, PREV_STAGE_RESULT @@ -51,16 +48,12 @@ def __init__(self, generator: JobGenerator, n_jobs: int) -> None: super().__init__(generator) self.n_jobs = n_jobs self.processes: dict[int, Future | None] = {} - self.progress = Progress() - self.task_id: TaskID self.results: list[dict] = [] self.failures = False def run(self, args: dict, prev_stage_results: PREV_STAGE_RESULT = None) -> GATHERED_RESULTS: """Run the job in parallel.""" - self.task_id = self.progress.add_task(self.generator.job_class.name, total=None) - self.progress.start() - self.processes = {i: None for i in range(self.n_jobs)} + self.processes = dict.fromkeys(range(self.n_jobs)) with ProcessPoolExecutor(max_workers=self.n_jobs, mp_context=multiprocessing.get_context("spawn")) as executor: for job in self.generator(args, prev_stage_results): @@ -71,12 +64,10 @@ def run(self, args: dict, prev_stage_results: PREV_STAGE_RESULT = None) -> GATHE self.processes[index] = executor.submit(job.run, task_id=index) self._await_cleanup_processes(blocking=True) - self.progress.update(self.task_id, completed=1, total=1) - self.progress.stop() gathered_result = self.generator.job_class.collect(self.results) self.generator.job_class.save(gathered_result) if self.failures: - msg = f"[bold red]There were some errors with job {self.generator.job_class.name}[/bold red]" + msg = f"There were some errors with job {self.generator.job_class.name}" print(msg) logger.error(msg) raise ParallelExecutionError(msg) @@ -97,4 +88,3 @@ def _await_cleanup_processes(self, blocking: bool = False) -> None: logger.exception("An exception occurred while getting the process result.") self.failures = True self.processes[index] = None - self.progress.update(self.task_id, advance=1) diff --git a/src/anomalib/pipelines/components/runners/serial.py b/src/anomalib/pipelines/components/runners/serial.py index a72f75a5c7..86cc3533ea 100644 --- a/src/anomalib/pipelines/components/runners/serial.py +++ b/src/anomalib/pipelines/components/runners/serial.py @@ -5,8 +5,7 @@ import logging -from rich import print -from rich.progress import track +from tqdm import tqdm from anomalib.pipelines.components.base import JobGenerator, Runner from anomalib.pipelines.types import GATHERED_RESULTS, PREV_STAGE_RESULT @@ -29,7 +28,7 @@ def run(self, args: dict, prev_stage_results: PREV_STAGE_RESULT = None) -> GATHE results = [] failures = False logger.info(f"Running job {self.generator.job_class.name}") - for job in track(self.generator(args, prev_stage_results), description=self.generator.job_class.name): + for job in tqdm(self.generator(args, prev_stage_results), desc=self.generator.job_class.name): try: results.append(job.run()) except Exception: # noqa: PERF203 @@ -38,7 +37,7 @@ def run(self, args: dict, prev_stage_results: PREV_STAGE_RESULT = None) -> GATHE gathered_result = self.generator.job_class.collect(results) self.generator.job_class.save(gathered_result) if failures: - msg = f"[bold red]There were some errors with job {self.generator.job_class.name}[/bold red]" + msg = f"There were some errors with job {self.generator.job_class.name}" print(msg) logger.error(msg) raise SerialExecutionError(msg) diff --git a/src/anomalib/pipelines/tiled_ensemble/__init__.py b/src/anomalib/pipelines/tiled_ensemble/__init__.py new file mode 100644 index 0000000000..1a068562b7 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/__init__.py @@ -0,0 +1,12 @@ +"""Tiled ensemble pipelines.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from .test_pipeline import EvalTiledEnsemble +from .train_pipeline import TrainTiledEnsemble + +__all__ = [ + "TrainTiledEnsemble", + "EvalTiledEnsemble", +] diff --git a/src/anomalib/pipelines/tiled_ensemble/components/__init__.py b/src/anomalib/pipelines/tiled_ensemble/components/__init__.py new file mode 100644 index 0000000000..619dc2e673 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/__init__.py @@ -0,0 +1,30 @@ +"""Tiled ensemble pipeline components.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from .merging import MergeJobGenerator +from .metrics_calculation import MetricsCalculationJobGenerator +from .model_training import TrainModelJobGenerator +from .normalization import NormalizationJobGenerator +from .prediction import PredictJobGenerator +from .smoothing import SmoothingJobGenerator +from .stats_calculation import StatisticsJobGenerator +from .thresholding import ThresholdingJobGenerator +from .utils import NormalizationStage, PredictData, ThresholdStage +from .visualization import VisualizationJobGenerator + +__all__ = [ + "NormalizationStage", + "ThresholdStage", + "PredictData", + "TrainModelJobGenerator", + "PredictJobGenerator", + "MergeJobGenerator", + "SmoothingJobGenerator", + "StatisticsJobGenerator", + "NormalizationJobGenerator", + "ThresholdingJobGenerator", + "VisualizationJobGenerator", + "MetricsCalculationJobGenerator", +] diff --git a/src/anomalib/pipelines/tiled_ensemble/components/merging.py b/src/anomalib/pipelines/tiled_ensemble/components/merging.py new file mode 100644 index 0000000000..6e8d5fc84c --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/merging.py @@ -0,0 +1,110 @@ +"""Tiled ensemble - prediction merging job.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from collections.abc import Generator +from typing import Any + +from tqdm import tqdm + +from anomalib.pipelines.components import Job, JobGenerator +from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS + +from .utils.ensemble_tiling import EnsembleTiler +from .utils.helper_functions import get_ensemble_tiler +from .utils.prediction_data import EnsemblePredictions +from .utils.prediction_merging import PredictionMergingMechanism + +logger = logging.getLogger(__name__) + + +class MergeJob(Job): + """Job for merging tile-level predictions into image-level predictions. + + Args: + predictions (EnsemblePredictions): Object containing ensemble predictions. + tiler (EnsembleTiler): Ensemble tiler used for untiling. + """ + + name = "Merge" + + def __init__(self, predictions: EnsemblePredictions, tiler: EnsembleTiler) -> None: + super().__init__() + self.predictions = predictions + self.tiler = tiler + + def run(self, task_id: int | None = None) -> list[Any]: + """Run merging job that merges all batches of tile-level predictions into image-level predictions. + + Args: + task_id: Not used in this case. + + Returns: + list[Any]: List of merged predictions. + """ + del task_id # not needed here + + merger = PredictionMergingMechanism(self.predictions, self.tiler) + + logger.info("Merging predictions.") + + # merge all batches + merged_predictions = [ + merger.merge_tile_predictions(batch_idx) + for batch_idx in tqdm(range(merger.num_batches), desc="Prediction merging") + ] + + return merged_predictions # noqa: RET504 + + @staticmethod + def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS: + """Nothing to collect in this job. + + Returns: + list[Any]: List of predictions. + """ + # take the first element as result is list of lists here + return results[0] + + @staticmethod + def save(results: GATHERED_RESULTS) -> None: + """Nothing to save in this job.""" + + +class MergeJobGenerator(JobGenerator): + """Generate MergeJob.""" + + def __init__(self, tiling_args: dict, data_args: dict) -> None: + super().__init__() + self.tiling_args = tiling_args + self.data_args = data_args + + @property + def job_class(self) -> type: + """Return the job class.""" + return MergeJob + + def generate_jobs( + self, + args: dict | None = None, + prev_stage_result: EnsemblePredictions | None = None, + ) -> Generator[MergeJob, None, None]: + """Return a generator producing a single merging job. + + Args: + args (dict): Tiled ensemble pipeline args. + prev_stage_result (EnsemblePredictions): Ensemble predictions from predict step. + + Returns: + Generator[MergeJob, None, None]: MergeJob generator + """ + del args # args not used here + + tiler = get_ensemble_tiler(self.tiling_args, self.data_args) + if prev_stage_result is not None: + yield MergeJob(prev_stage_result, tiler) + else: + msg = "Merging job requires tile level predictions from previous step." + raise ValueError(msg) diff --git a/src/anomalib/pipelines/tiled_ensemble/components/metrics_calculation.py b/src/anomalib/pipelines/tiled_ensemble/components/metrics_calculation.py new file mode 100644 index 0000000000..530662b1d3 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/metrics_calculation.py @@ -0,0 +1,217 @@ +"""Tiled ensemble - metrics calculation job.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from collections.abc import Generator +from pathlib import Path +from typing import Any + +import pandas as pd +from tqdm import tqdm + +from anomalib import TaskType +from anomalib.metrics import AnomalibMetricCollection, create_metric_collection +from anomalib.pipelines.components import Job, JobGenerator +from anomalib.pipelines.types import GATHERED_RESULTS, PREV_STAGE_RESULT, RUN_RESULTS + +from .utils import NormalizationStage +from .utils.helper_functions import get_threshold_values + +logger = logging.getLogger(__name__) + + +class MetricsCalculationJob(Job): + """Job for image and pixel metrics calculation. + + Args: + accelerator (str): Accelerator (device) to use. + predictions (list[Any]): List of batch predictions. + root_dir (Path): Root directory to save checkpoints, stats and images. + image_metrics (AnomalibMetricCollection): Collection of all image-level metrics. + pixel_metrics (AnomalibMetricCollection): Collection of all pixel-level metrics. + """ + + name = "Metrics" + + def __init__( + self, + accelerator: str, + predictions: list[Any] | None, + root_dir: Path, + image_metrics: AnomalibMetricCollection, + pixel_metrics: AnomalibMetricCollection, + ) -> None: + super().__init__() + self.accelerator = accelerator + self.predictions = predictions + self.root_dir = root_dir + self.image_metrics = image_metrics + self.pixel_metrics = pixel_metrics + + def run(self, task_id: int | None = None) -> dict: + """Run a job that calculates image and pixel level metrics. + + Args: + task_id: Not used in this case. + + Returns: + dict[str, float]: Dictionary containing calculated metric values. + """ + del task_id # not needed here + + logger.info("Starting metrics calculation.") + + # add predicted data to metrics + for data in tqdm(self.predictions, desc="Calculating metrics"): + self.image_metrics.update(data["pred_scores"], data["label"].int()) + if "mask" in data and "anomaly_maps" in data: + self.pixel_metrics.update(data["anomaly_maps"], data["mask"].int()) + + # compute all metrics on specified accelerator + metrics_dict = {} + for name, metric in self.image_metrics.items(): + metric.to(self.accelerator) + metrics_dict[name] = metric.compute().item() + metric.cpu() + + if self.pixel_metrics.update_called: + for name, metric in self.pixel_metrics.items(): + metric.to(self.accelerator) + metrics_dict[name] = metric.compute().item() + metric.cpu() + + for name, value in metrics_dict.items(): + print(f"{name}: {value:.4f}") + + # save path used in `save` method + metrics_dict["save_path"] = self.root_dir / "metric_results.csv" + + return metrics_dict + + @staticmethod + def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS: + """Nothing to collect in this job. + + Returns: + list[Any]: list of predictions. + """ + # take the first element as result is list of dict here + return results[0] + + @staticmethod + def save(results: GATHERED_RESULTS) -> None: + """Save metrics values to csv.""" + logger.info("Saving metrics to csv.") + + # get and remove path from stats dict + results_path: Path = results.pop("save_path") + results_path.parent.mkdir(parents=True, exist_ok=True) + + df_dict = {k: [v] for k, v in results.items()} + metrics_df = pd.DataFrame(df_dict) + metrics_df.to_csv(results_path, index=False) + + +class MetricsCalculationJobGenerator(JobGenerator): + """Generate MetricsCalculationJob. + + Args: + root_dir (Path): Root directory to save checkpoints, stats and images. + """ + + def __init__( + self, + accelerator: str, + root_dir: Path, + task: TaskType, + metrics: dict, + normalization_stage: NormalizationStage, + ) -> None: + self.accelerator = accelerator + self.root_dir = root_dir + self.task = task + self.metrics = metrics + self.normalization_stage = normalization_stage + + @property + def job_class(self) -> type: + """Return the job class.""" + return MetricsCalculationJob + + def configure_ensemble_metrics( + self, + image_metrics: list[str] | dict[str, dict[str, Any]] | None = None, + pixel_metrics: list[str] | dict[str, dict[str, Any]] | None = None, + ) -> tuple[AnomalibMetricCollection, AnomalibMetricCollection]: + """Configure image and pixel metrics and put them into a collection. + + Args: + image_metrics (list[str] | None): List of image-level metric names. + pixel_metrics (list[str] | None): List of pixel-level metric names. + + Returns: + tuple[AnomalibMetricCollection, AnomalibMetricCollection]: + Image-metrics collection and pixel-metrics collection + """ + image_metrics = [] if image_metrics is None else image_metrics + + if pixel_metrics is None: + pixel_metrics = [] + elif self.task == TaskType.CLASSIFICATION: + pixel_metrics = [] + logger.warning( + "Cannot perform pixel-level evaluation when task type is classification. " + "Ignoring the following pixel-level metrics: %s", + pixel_metrics, + ) + + # if a single metric is passed, transform to list to fit the creation function + if isinstance(image_metrics, str): + image_metrics = [image_metrics] + if isinstance(pixel_metrics, str): + pixel_metrics = [pixel_metrics] + + image_metrics_collection = create_metric_collection(image_metrics, "image_") + pixel_metrics_collection = create_metric_collection(pixel_metrics, "pixel_") + + return image_metrics_collection, pixel_metrics_collection + + def generate_jobs( + self, + args: dict | None = None, + prev_stage_result: PREV_STAGE_RESULT = None, + ) -> Generator[MetricsCalculationJob, None, None]: + """Make a generator that yields a single metrics calculation job. + + Args: + args: ensemble run config. + prev_stage_result: ensemble predictions from previous step. + + Returns: + Generator[MetricsCalculationJob, None, None]: MetricsCalculationJob generator + """ + del args # args not used here + + image_metrics_config = self.metrics.get("image", None) + pixel_metrics_config = self.metrics.get("pixel", None) + + image_threshold, pixel_threshold = get_threshold_values(self.normalization_stage, self.root_dir) + + image_metrics, pixel_metrics = self.configure_ensemble_metrics( + image_metrics=image_metrics_config, + pixel_metrics=pixel_metrics_config, + ) + + # set thresholds for metrics that need it + image_metrics.set_threshold(image_threshold) + pixel_metrics.set_threshold(pixel_threshold) + + yield MetricsCalculationJob( + accelerator=self.accelerator, + predictions=prev_stage_result, + root_dir=self.root_dir, + image_metrics=image_metrics, + pixel_metrics=pixel_metrics, + ) diff --git a/src/anomalib/pipelines/tiled_ensemble/components/model_training.py b/src/anomalib/pipelines/tiled_ensemble/components/model_training.py new file mode 100644 index 0000000000..6bc81c793b --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/model_training.py @@ -0,0 +1,192 @@ +"""Tiled ensemble - ensemble training job.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from collections.abc import Generator +from itertools import product +from pathlib import Path + +from lightning import seed_everything + +from anomalib.data import AnomalibDataModule +from anomalib.models import AnomalyModule +from anomalib.pipelines.components import Job, JobGenerator +from anomalib.pipelines.types import GATHERED_RESULTS, PREV_STAGE_RESULT + +from .utils import NormalizationStage +from .utils.ensemble_engine import TiledEnsembleEngine +from .utils.helper_functions import ( + get_ensemble_datamodule, + get_ensemble_engine, + get_ensemble_model, + get_ensemble_tiler, +) + +logger = logging.getLogger(__name__) + + +class TrainModelJob(Job): + """Job for training of individual models in the tiled ensemble. + + Args: + accelerator (str): Accelerator (device) to use. + seed (int): Random seed for reproducibility. + root_dir (Path): Root directory to save checkpoints, stats and images. + tile_index (tuple[int, int]): Index of tile that this model processes. + normalization_stage (str): Normalization stage flag. + metrics (dict): metrics dict with pixel and image metric names. + trainer_args (dict| None): Additional arguments to pass to the trainer class. + model (AnomalyModule): Model to train. + datamodule (AnomalibDataModule): Datamodule with all dataloaders. + + """ + + name = "TrainModels" + + def __init__( + self, + accelerator: str, + seed: int, + root_dir: Path, + tile_index: tuple[int, int], + normalization_stage: str, + metrics: dict, + trainer_args: dict | None, + model: AnomalyModule, + datamodule: AnomalibDataModule, + ) -> None: + super().__init__() + self.accelerator = accelerator + self.seed = seed + self.root_dir = root_dir + self.tile_index = tile_index + self.normalization_stage = normalization_stage + self.metrics = metrics + self.trainer_args = trainer_args + self.model = model + self.datamodule = datamodule + + def run( + self, + task_id: int | None = None, + ) -> TiledEnsembleEngine: + """Run train job that fits the model for given tile location. + + Args: + task_id: Passed when job is ran in parallel. + + Returns: + TiledEnsembleEngine: Engine containing trained model. + """ + devices: str | list[int] = "auto" + if task_id is not None: + devices = [task_id] + logger.info(f"Running job {self.model.__class__.__name__} with device {task_id}") + + logger.info("Start of training for tile at position %s,", self.tile_index) + seed_everything(self.seed) + + # create engine for specific tile location and fit the model + engine = get_ensemble_engine( + tile_index=self.tile_index, + accelerator=self.accelerator, + devices=devices, + root_dir=self.root_dir, + normalization_stage=self.normalization_stage, + metrics=self.metrics, + trainer_args=self.trainer_args, + ) + engine.fit(model=self.model, datamodule=self.datamodule) + # move model to cpu to avoid memory issues as the engine is returned to be used in validation phase + engine.model.cpu() + + return engine + + @staticmethod + def collect(results: list[TiledEnsembleEngine]) -> dict[tuple[int, int], TiledEnsembleEngine]: + """Collect engines from each tile location into a dict. + + Returns: + dict[tuple[int, int], TiledEnsembleEngine]: Dict has form {tile_index: TiledEnsembleEngine} + """ + return {r.tile_index: r for r in results} + + @staticmethod + def save(results: GATHERED_RESULTS) -> None: + """Skip as checkpoints are already saved by callback.""" + + +class TrainModelJobGenerator(JobGenerator): + """Generator for training job that train model for each tile location. + + Args: + root_dir (Path): Root directory to save checkpoints, stats and images. + """ + + def __init__( + self, + seed: int, + accelerator: str, + root_dir: Path, + tiling_args: dict, + data_args: dict, + normalization_stage: NormalizationStage, + ) -> None: + self.seed = seed + self.accelerator = accelerator + self.root_dir = root_dir + self.tiling_args = tiling_args + self.data_args = data_args + self.normalization_stage = normalization_stage + + @property + def job_class(self) -> type: + """Return the job class.""" + return TrainModelJob + + def generate_jobs( + self, + args: dict | None = None, + prev_stage_result: PREV_STAGE_RESULT = None, + ) -> Generator[TrainModelJob, None, None]: + """Generate training jobs for each tile location. + + Args: + args (dict): Dict with config passed to training. + prev_stage_result (None): Not used here. + + Returns: + Generator[TrainModelJob, None, None]: TrainModelJob generator + """ + del prev_stage_result # Not needed for this job + if args is None: + msg = "TrainModels job requires config args" + raise ValueError(msg) + + # tiler used for splitting the image and getting the tile count + tiler = get_ensemble_tiler(self.tiling_args, self.data_args) + + logger.info( + "Tiled ensemble training started. Separate models will be trained for %d tile locations.", + tiler.num_tiles, + ) + # go over all tile positions + for tile_index in product(range(tiler.num_patches_h), range(tiler.num_patches_w)): + # prepare datamodule with custom collate function that only provides specific tile of image + datamodule = get_ensemble_datamodule(self.data_args, tiler, tile_index) + model = get_ensemble_model(args["model"], tiler) + + # pass root_dir to engine so all models in ensemble have the same root dir + yield TrainModelJob( + accelerator=self.accelerator, + seed=self.seed, + root_dir=self.root_dir, + tile_index=tile_index, + normalization_stage=self.normalization_stage, + metrics=args["metrics"], + trainer_args=args.get("trainer", {}), + model=model, + datamodule=datamodule, + ) diff --git a/src/anomalib/pipelines/tiled_ensemble/components/normalization.py b/src/anomalib/pipelines/tiled_ensemble/components/normalization.py new file mode 100644 index 0000000000..8c7a563506 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/normalization.py @@ -0,0 +1,120 @@ +"""Tiled ensemble - normalization job.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import json +import logging +from collections.abc import Generator +from pathlib import Path +from typing import Any + +from tqdm import tqdm + +from anomalib.pipelines.components import Job, JobGenerator +from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS +from anomalib.utils.normalization.min_max import normalize + +logger = logging.getLogger(__name__) + + +class NormalizationJob(Job): + """Job for normalization of predictions. + + Args: + predictions (list[Any]): List of predictions. + root_dir (Path): Root directory containing statistics needed for normalization. + """ + + name = "Normalize" + + def __init__(self, predictions: list[Any] | None, root_dir: Path) -> None: + super().__init__() + self.predictions = predictions + self.root_dir = root_dir + + def run(self, task_id: int | None = None) -> list[Any] | None: + """Run normalization job which normalizes image, pixel and box scores. + + Args: + task_id: Not used in this case. + + Returns: + list[Any]: List of normalized predictions. + """ + del task_id # not needed here + + # load all statistics needed for normalization + stats_path = self.root_dir / "weights" / "lightning" / "stats.json" + with stats_path.open("r") as f: + stats = json.load(f) + minmax = stats["minmax"] + image_threshold = stats["image_threshold"] + pixel_threshold = stats["pixel_threshold"] + + logger.info("Starting normalization.") + + for data in tqdm(self.predictions, desc="Normalizing"): + data["pred_scores"] = normalize( + data["pred_scores"], + image_threshold, + minmax["pred_scores"]["min"], + minmax["pred_scores"]["max"], + ) + if "anomaly_maps" in data: + data["anomaly_maps"] = normalize( + data["anomaly_maps"], + pixel_threshold, + minmax["anomaly_maps"]["min"], + minmax["anomaly_maps"]["max"], + ) + + return self.predictions + + @staticmethod + def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS: + """Nothing to collect in this job. + + Returns: + list[Any]: List of predictions. + """ + # take the first element as result is list of lists here + return results[0] + + @staticmethod + def save(results: GATHERED_RESULTS) -> None: + """Nothing is saved in this job.""" + + +class NormalizationJobGenerator(JobGenerator): + """Generate NormalizationJob. + + Args: + root_dir (Path): Root directory where statistics are saved. + """ + + def __init__(self, root_dir: Path) -> None: + self.root_dir = root_dir + + @property + def job_class(self) -> type: + """Return the job class.""" + return NormalizationJob + + def generate_jobs( + self, + args: dict | None = None, + prev_stage_result: list[Any] | None = None, + ) -> Generator[NormalizationJob, None, None]: + """Return a generator producing a single normalization job. + + Args: + args: not used here. + prev_stage_result (list[Any]): Ensemble predictions from previous step. + + Returns: + Generator[NormalizationJob, None, None]: NormalizationJob generator. + """ + del args # not needed here + + yield NormalizationJob(prev_stage_result, self.root_dir) diff --git a/src/anomalib/pipelines/tiled_ensemble/components/prediction.py b/src/anomalib/pipelines/tiled_ensemble/components/prediction.py new file mode 100644 index 0000000000..792d86a497 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/prediction.py @@ -0,0 +1,228 @@ +"""Tiled ensemble - ensemble prediction job.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from collections.abc import Generator +from itertools import product +from pathlib import Path +from typing import Any + +from lightning import seed_everything +from torch.utils.data import DataLoader + +from anomalib.models import AnomalyModule +from anomalib.pipelines.components import Job, JobGenerator +from anomalib.pipelines.types import GATHERED_RESULTS, PREV_STAGE_RESULT + +from .utils import NormalizationStage, PredictData +from .utils.ensemble_engine import TiledEnsembleEngine +from .utils.helper_functions import ( + get_ensemble_datamodule, + get_ensemble_engine, + get_ensemble_model, + get_ensemble_tiler, +) +from .utils.prediction_data import EnsemblePredictions + +logger = logging.getLogger(__name__) + + +class PredictJob(Job): + """Job for generating predictions with individual models in the tiled ensemble. + + Args: + accelerator (str): Accelerator (device) to use. + seed (int): Random seed for reproducibility. + root_dir (Path): Root directory to save checkpoints, stats and images. + tile_index (tuple[int, int]): Index of tile that this model processes. + normalization_stage (str): Normalization stage flag. + dataloader (DataLoader): Dataloader to use for training (either val or test). + model (AnomalyModule): Model to train. + engine (TiledEnsembleEngine | None): + engine from train job. If job is used standalone, instantiate engine and model from checkpoint. + ckpt_path (Path | None): Path to checkpoint to be loaded if engine doesn't contain correct weights. + + """ + + name = "Predict" + + def __init__( + self, + accelerator: str, + seed: int, + root_dir: Path, + tile_index: tuple[int, int], + normalization_stage: str, + dataloader: DataLoader, + model: AnomalyModule | None, + engine: TiledEnsembleEngine | None, + ckpt_path: Path | None, + ) -> None: + super().__init__() + if engine is None and ckpt_path is None: + msg = "Either engine or checkpoint must be provided to predict job." + raise ValueError(msg) + + self.accelerator = accelerator + self.seed = seed + self.root_dir = root_dir + self.tile_index = tile_index + self.normalization_stage = normalization_stage + self.dataloader = dataloader + self.model = model + self.engine = engine + self.ckpt_path = ckpt_path + + def run( + self, + task_id: int | None = None, + ) -> tuple[tuple[int, int], Any | None]: + """Predict job that predicts the data with specific model for given tile location. + + Args: + task_id: Passed when job is ran in parallel. + + Returns: + tuple[tuple[int, int], list[Any]]: Tile index, List of predictions. + """ + devices: str | list[int] = "auto" + if task_id is not None: + devices = [task_id] + logger.info(f"Running job {self.model.__class__.__name__} with device {task_id}") + + logger.info("Start of predicting for tile at position %s,", self.tile_index) + seed_everything(self.seed) + + if self.engine is None: + # in case predict is invoked separately from train job, make new engine instance + self.engine = get_ensemble_engine( + tile_index=self.tile_index, + accelerator=self.accelerator, + devices=devices, + root_dir=self.root_dir, + normalization_stage=self.normalization_stage, + ) + + predictions = self.engine.predict(model=self.model, dataloaders=self.dataloader, ckpt_path=self.ckpt_path) + + # also return tile index as it's needed in collect method + return self.tile_index, predictions + + @staticmethod + def collect(results: list[tuple[tuple[int, int], list[Any]]]) -> EnsemblePredictions: + """Collect predictions from each tile location into the predictions class. + + Returns: + EnsemblePredictions: Object containing all predictions in form ready for merging. + """ + storage = EnsemblePredictions() + + for tile_index, predictions in results: + storage.add_tile_prediction(tile_index, predictions) + + return storage + + @staticmethod + def save(results: GATHERED_RESULTS) -> None: + """This stage doesn't save anything.""" + + +class PredictJobGenerator(JobGenerator): + """Generator for predict job that uses individual models to predict for each tile location. + + Args: + root_dir (Path): Root directory to save checkpoints, stats and images. + data_source (PredictData): Whether to predict on validation set. If false use test set. + """ + + def __init__( + self, + data_source: PredictData, + seed: int, + accelerator: str, + root_dir: Path, + tiling_args: dict, + data_args: dict, + model_args: dict, + normalization_stage: NormalizationStage, + ) -> None: + self.data_source = data_source + self.seed = seed + self.accelerator = accelerator + self.root_dir = root_dir + self.tiling_args = tiling_args + self.data_args = data_args + self.model_args = model_args + self.normalization_stage = normalization_stage + + @property + def job_class(self) -> type: + """Return the job class.""" + return PredictJob + + def generate_jobs( + self, + args: dict | None = None, + prev_stage_result: PREV_STAGE_RESULT = None, + ) -> Generator[PredictJob, None, None]: + """Generate predict jobs for each tile location. + + Args: + args (dict): Dict with config passed to training. + prev_stage_result (dict[tuple[int, int], TiledEnsembleEngine] | None): + if called after train job this contains engines with individual models, otherwise load from checkpoints. + + Returns: + Generator[PredictJob, None, None]: PredictJob generator. + """ + del args # args not used here + + # tiler used for splitting the image and getting the tile count + tiler = get_ensemble_tiler(self.tiling_args, self.data_args) + + logger.info( + "Tiled ensemble predicting started using %s data.", + self.data_source.value, + ) + # go over all tile positions + for tile_index in product(range(tiler.num_patches_h), range(tiler.num_patches_w)): + # prepare datamodule with custom collate function that only provides specific tile of image + datamodule = get_ensemble_datamodule(self.data_args, tiler, tile_index) + + # check if predict step is positioned after training + if prev_stage_result and tile_index in prev_stage_result: + engine = prev_stage_result[tile_index] + # model is inside engine in this case + model = engine.model + ckpt_path = None + else: + # any other case - predict is called standalone + engine = None + # we need to make new model instance as it's not inside engine + model = get_ensemble_model(self.model_args, tiler) + tile_i, tile_j = tile_index + # prepare checkpoint path for model on current tile location + ckpt_path = self.root_dir / "weights" / "lightning" / f"model{tile_i}_{tile_j}.ckpt" + + # pick the dataloader based on predict data + dataloader = datamodule.test_dataloader() + if self.data_source == PredictData.VAL: + dataloader = datamodule.val_dataloader() + # TODO(blaz-r): - this is tweak to avoid problem in engine:388 + # 2254 + dataloader.dataset.transform = None + + # pass root_dir to engine so all models in ensemble have the same root dir + yield PredictJob( + accelerator=self.accelerator, + seed=self.seed, + root_dir=self.root_dir, + tile_index=tile_index, + normalization_stage=self.normalization_stage, + model=model, + dataloader=dataloader, + engine=engine, + ckpt_path=ckpt_path, + ) diff --git a/src/anomalib/pipelines/tiled_ensemble/components/smoothing.py b/src/anomalib/pipelines/tiled_ensemble/components/smoothing.py new file mode 100644 index 0000000000..b3d5a51000 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/smoothing.py @@ -0,0 +1,167 @@ +"""Tiled ensemble - seam smoothing job.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from collections.abc import Generator +from typing import Any + +import torch +from tqdm import tqdm + +from anomalib.models.components import GaussianBlur2d +from anomalib.pipelines.components import Job, JobGenerator +from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS + +from .utils.ensemble_tiling import EnsembleTiler +from .utils.helper_functions import get_ensemble_tiler + +logger = logging.getLogger(__name__) + + +class SmoothingJob(Job): + """Job for smoothing the area around the tile seam. + + Args: + accelerator (str): Accelerator used for processing. + predictions (list[Any]): List of image-level predictions. + width_factor (float): Factor multiplied by tile dimension to get the region around seam which will be smoothed. + filter_sigma (float): Sigma of filter used for smoothing the seams. + tiler (EnsembleTiler): Tiler object used to get tile dimension data. + """ + + name = "SeamSmoothing" + + def __init__( + self, + accelerator: str, + predictions: list[Any], + width_factor: float, + filter_sigma: float, + tiler: EnsembleTiler, + ) -> None: + super().__init__() + self.accelerator = accelerator + self.predictions = predictions + + # offset in pixels of region around tile seam that will be smoothed + self.height_offset = int(tiler.tile_size_h * width_factor) + self.width_offset = int(tiler.tile_size_w * width_factor) + self.tiler = tiler + + self.seam_mask = self.prepare_seam_mask() + + self.blur = GaussianBlur2d(sigma=filter_sigma) + + def prepare_seam_mask(self) -> torch.Tensor: + """Prepare boolean mask of regions around the part where tiles seam in ensemble. + + Returns: + torch.Tensor: Representation of boolean mask where filtered seams should be used. + """ + img_h, img_w = self.tiler.image_size + stride_h, stride_w = self.tiler.stride_h, self.tiler.stride_w + + mask = torch.zeros(img_h, img_w, dtype=torch.bool) + + # prepare mask strip on vertical seams + curr_w = stride_w + while curr_w < img_w: + start_i = curr_w - self.width_offset + end_i = curr_w + self.width_offset + mask[:, start_i:end_i] = 1 + curr_w += stride_w + + # prepare mask strip on horizontal seams + curr_h = stride_h + while curr_h < img_h: + start_i = curr_h - self.height_offset + end_i = curr_h + self.height_offset + mask[start_i:end_i, :] = True + curr_h += stride_h + + return mask + + def run(self, task_id: int | None = None) -> list[Any]: + """Run smoothing job. + + Args: + task_id: Not used in this case. + + Returns: + list[Any]: List of predictions. + """ + del task_id # not needed here + + logger.info("Starting seam smoothing.") + + for data in tqdm(self.predictions, desc="Seam smoothing"): + # move to specified accelerator for faster execution + data["anomaly_maps"] = data["anomaly_maps"].to(self.accelerator) + # smooth the anomaly map and take only region around seams delimited by seam_mask + smoothed = self.blur(data["anomaly_maps"]) + data["anomaly_maps"][:, :, self.seam_mask] = smoothed[:, :, self.seam_mask] + data["anomaly_maps"] = data["anomaly_maps"].cpu() + + return self.predictions + + @staticmethod + def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS: + """Nothing to collect in this job. + + Returns: + list[Any]: List of predictions. + """ + # take the first element as result is list of lists here + return results[0] + + @staticmethod + def save(results: GATHERED_RESULTS) -> None: + """Nothing to save in this job.""" + + +class SmoothingJobGenerator(JobGenerator): + """Generate SmoothingJob.""" + + def __init__(self, accelerator: str, tiling_args: dict, data_args: dict) -> None: + super().__init__() + self.accelerator = accelerator + self.tiling_args = tiling_args + self.data_args = data_args + + @property + def job_class(self) -> type: + """Return the job class.""" + return SmoothingJob + + def generate_jobs( + self, + args: dict | None = None, + prev_stage_result: list[Any] | None = None, + ) -> Generator[SmoothingJob, None, None]: + """Return a generator producing a single seam smoothing job. + + Args: + args: Tiled ensemble pipeline args. + prev_stage_result (list[Any]): Ensemble predictions from previous step. + + Returns: + Generator[SmoothingJob, None, None]: SmoothingJob generator + """ + if args is None: + msg = "SeamSmoothing job requires config args" + raise ValueError(msg) + # tiler is used to determine where seams appear + tiler = get_ensemble_tiler(self.tiling_args, self.data_args) + if prev_stage_result is not None: + yield SmoothingJob( + accelerator=self.accelerator, + predictions=prev_stage_result, + width_factor=args["width"], + filter_sigma=args["sigma"], + tiler=tiler, + ) + else: + msg = "Join smoothing job requires tile level predictions from previous step." + raise ValueError(msg) diff --git a/src/anomalib/pipelines/tiled_ensemble/components/stats_calculation.py b/src/anomalib/pipelines/tiled_ensemble/components/stats_calculation.py new file mode 100644 index 0000000000..6c48b639f7 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/stats_calculation.py @@ -0,0 +1,180 @@ +"""Tiled ensemble - post-processing statistics calculation job.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import json +import logging +from collections.abc import Generator +from pathlib import Path +from typing import Any + +import torch +from omegaconf import DictConfig, ListConfig +from torchmetrics import MetricCollection +from tqdm import tqdm + +from anomalib.callbacks.thresholding import _ThresholdCallback +from anomalib.metrics import MinMax +from anomalib.metrics.threshold import Threshold +from anomalib.pipelines.components import Job, JobGenerator +from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS + +logger = logging.getLogger(__name__) + + +class StatisticsJob(Job): + """Job for calculating min, max and threshold statistics for post-processing. + + Args: + predictions (list[Any]): List of image-level predictions. + root_dir (Path): Root directory to save checkpoints, stats and images. + """ + + name = "Stats" + + def __init__( + self, + predictions: list[Any] | None, + root_dir: Path, + image_threshold: Threshold, + pixel_threshold: Threshold, + ) -> None: + super().__init__() + self.predictions = predictions + self.root_dir = root_dir + self.image_threshold = image_threshold + self.pixel_threshold = pixel_threshold + + def run(self, task_id: int | None = None) -> dict: + """Run job that calculates statistics needed in post-processing steps. + + Args: + task_id: Not used in this case + + Returns: + dict: Statistics dict with min, max and threshold values. + """ + del task_id # not needed here + + minmax = MetricCollection( + { + "anomaly_maps": MinMax().cpu(), + "pred_scores": MinMax().cpu(), + }, + ) + pixel_update_called = False + + logger.info("Starting post-processing statistics calculation.") + + for data in tqdm(self.predictions, desc="Stats calculation"): + # update minmax + if "anomaly_maps" in data: + minmax["anomaly_maps"](data["anomaly_maps"]) + if "pred_scores" in data: + minmax["pred_scores"](data["pred_scores"]) + + # update thresholds + self.image_threshold.update(data["pred_scores"], data["label"].int()) + if "mask" in data and "anomaly_maps" in data: + self.pixel_threshold.update(torch.squeeze(data["anomaly_maps"]), torch.squeeze(data["mask"].int())) + pixel_update_called = True + + self.image_threshold.compute() + if pixel_update_called: + self.pixel_threshold.compute() + else: + self.pixel_threshold.value = self.image_threshold.value + + min_max_vals = {} + for pred_name, pred_metric in minmax.items(): + min_max_vals[pred_name] = { + "min": pred_metric.min.item(), + "max": pred_metric.max.item(), + } + + # return stats with save path that is later used to save statistics. + return { + "minmax": min_max_vals, + "image_threshold": self.image_threshold.value.item(), + "pixel_threshold": self.pixel_threshold.value.item(), + "save_path": (self.root_dir / "weights" / "lightning" / "stats.json"), + } + + @staticmethod + def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS: + """Nothing to collect in this job. + + Returns: + dict: statistics dictionary. + """ + # take the first element as result is list of lists here + return results[0] + + @staticmethod + def save(results: GATHERED_RESULTS) -> None: + """Save statistics to file system.""" + # get and remove path from stats dict + stats_path: Path = results.pop("save_path") + stats_path.parent.mkdir(parents=True, exist_ok=True) + + # save statistics next to weights + with stats_path.open("w", encoding="utf-8") as stats_file: + json.dump(results, stats_file, ensure_ascii=False, indent=4) + + +class StatisticsJobGenerator(JobGenerator): + """Generate StatisticsJob. + + Args: + root_dir (Path): Root directory where statistics file will be saved (in weights folder). + """ + + def __init__( + self, + root_dir: Path, + thresholding_method: DictConfig | str | ListConfig | list[dict[str, str | float]], + ) -> None: + self.root_dir = root_dir + self.threshold = thresholding_method + + @property + def job_class(self) -> type: + """Return the job class.""" + return StatisticsJob + + def generate_jobs( + self, + args: dict | None = None, + prev_stage_result: list[Any] | None = None, + ) -> Generator[StatisticsJob, None, None]: + """Return a generator producing a single stats calculating job. + + Args: + args: Not used here. + prev_stage_result (list[Any]): Ensemble predictions from previous step. + + Returns: + Generator[StatisticsJob, None, None]: StatisticsJob generator. + """ + del args # not needed here + + # get threshold class based config + if isinstance(self.threshold, str | DictConfig): + # single method provided + image_threshold = _ThresholdCallback._get_threshold_from_config(self.threshold) # noqa: SLF001 + pixel_threshold = image_threshold.clone() + elif isinstance(self.threshold, ListConfig | list): + # image and pixel method specified separately + image_threshold = _ThresholdCallback._get_threshold_from_config(self.threshold[0]) # noqa: SLF001 + pixel_threshold = _ThresholdCallback._get_threshold_from_config(self.threshold[1]) # noqa: SLF001 + else: + msg = f"Invalid threshold config {self.threshold}" + raise TypeError(msg) + + yield StatisticsJob( + predictions=prev_stage_result, + root_dir=self.root_dir, + image_threshold=image_threshold, + pixel_threshold=pixel_threshold, + ) diff --git a/src/anomalib/pipelines/tiled_ensemble/components/thresholding.py b/src/anomalib/pipelines/tiled_ensemble/components/thresholding.py new file mode 100644 index 0000000000..733c3d99db --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/thresholding.py @@ -0,0 +1,114 @@ +"""Tiled ensemble - thresholding job.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from collections.abc import Generator +from pathlib import Path +from typing import Any + +from tqdm import tqdm + +from anomalib.pipelines.components import Job, JobGenerator +from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS + +from .utils import NormalizationStage +from .utils.helper_functions import get_threshold_values + +logger = logging.getLogger(__name__) + + +class ThresholdingJob(Job): + """Job used to threshold predictions, producing labels from scores. + + Args: + predictions (list[Any]): List of predictions. + image_threshold (float): Threshold used for image-level thresholding. + pixel_threshold (float): Threshold used for pixel-level thresholding. + """ + + name = "Threshold" + + def __init__(self, predictions: list[Any] | None, image_threshold: float, pixel_threshold: float) -> None: + super().__init__() + self.predictions = predictions + self.image_threshold = image_threshold + self.pixel_threshold = pixel_threshold + + def run(self, task_id: int | None = None) -> list[Any] | None: + """Run job that produces prediction labels from scores. + + Args: + task_id: Not used in this case. + + Returns: + list[Any]: List of thresholded predictions. + """ + del task_id # not needed here + + logger.info("Starting thresholding.") + + for data in tqdm(self.predictions, desc="Thresholding"): + if "pred_scores" in data: + data["pred_labels"] = data["pred_scores"] >= self.image_threshold + if "anomaly_maps" in data: + data["pred_masks"] = data["anomaly_maps"] >= self.pixel_threshold + + return self.predictions + + @staticmethod + def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS: + """Nothing to collect in this job. + + Returns: + list[Any]: List of predictions. + """ + # take the first element as result is list of lists here + return results[0] + + @staticmethod + def save(results: GATHERED_RESULTS) -> None: + """Nothing is saved in this job.""" + + +class ThresholdingJobGenerator(JobGenerator): + """Generate ThresholdingJob. + + Args: + root_dir (Path): Root directory containing post-processing stats. + """ + + def __init__(self, root_dir: Path, normalization_stage: NormalizationStage) -> None: + self.root_dir = root_dir + self.normalization_stage = normalization_stage + + @property + def job_class(self) -> type: + """Return the job class.""" + return ThresholdingJob + + def generate_jobs( + self, + args: dict | None = None, + prev_stage_result: list[Any] | None = None, + ) -> Generator[ThresholdingJob, None, None]: + """Return a generator producing a single thresholding job. + + Args: + args: ensemble run args. + prev_stage_result (list[Any]): Ensemble predictions from previous step. + + Returns: + Generator[ThresholdingJob, None, None]: ThresholdingJob generator. + """ + del args # args not used here + + # get threshold values base on normalization + image_threshold, pixel_threshold = get_threshold_values(self.normalization_stage, self.root_dir) + + yield ThresholdingJob( + predictions=prev_stage_result, + image_threshold=image_threshold, + pixel_threshold=pixel_threshold, + ) diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/__init__.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/__init__.py new file mode 100644 index 0000000000..a010208908 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/utils/__init__.py @@ -0,0 +1,44 @@ +"""Tiled ensemble utils and helper functions.""" + +from enum import Enum + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + + +class NormalizationStage(str, Enum): + """Enum signaling at which stage the normalization is done. + + In case of tile, tiles are normalized for each tile position separately. + In case of image, normalization is done at the end when images are joined back together. + In case of none, output is not normalized. + """ + + TILE = "tile" + IMAGE = "image" + NONE = "none" + + +class ThresholdStage(str, Enum): + """Enum signaling at which stage the thresholding is applied. + + In case of tile, thresholding is applied for each tile location separately. + In case of image, thresholding is applied at the end when images are joined back together. + """ + + TILE = "tile" + IMAGE = "image" + + +class PredictData(Enum): + """Enum indicating which data to use in prediction job.""" + + VAL = "val" + TEST = "test" + + +__all__ = [ + "NormalizationStage", + "ThresholdStage", + "PredictData", +] diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_engine.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_engine.py new file mode 100644 index 0000000000..449109ed3f --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_engine.py @@ -0,0 +1,92 @@ +"""Implements custom Anomalib engine for tiled ensemble training.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from pathlib import Path + +from lightning.pytorch.callbacks import Callback, RichModelSummary + +from anomalib.callbacks import ModelCheckpoint, TimerCallback +from anomalib.callbacks.metrics import _MetricsCallback +from anomalib.callbacks.normalization import get_normalization_callback +from anomalib.callbacks.post_processor import _PostProcessorCallback +from anomalib.callbacks.thresholding import _ThresholdCallback +from anomalib.engine import Engine +from anomalib.models import AnomalyModule +from anomalib.utils.path import create_versioned_dir + +logger = logging.getLogger(__name__) + + +class TiledEnsembleEngine(Engine): + """Engine used for training and evaluating tiled ensemble. + + Most of the logic stays the same, but workspace creation and callbacks are adjusted for ensemble. + + Args: + tile_index (tuple[int, int]): index of tile that this engine instance processes. + **kwargs: Engine arguments. + """ + + def __init__(self, tile_index: tuple[int, int], **kwargs) -> None: + self.tile_index = tile_index + super().__init__(**kwargs) + + def _setup_workspace(self, *args, **kwargs) -> None: + """Skip since in case of tiled ensemble, workspace is only setup once at the beginning of training.""" + + @staticmethod + def setup_ensemble_workspace(args: dict, versioned_dir: bool = True) -> Path: + """Set up the workspace at the beginning of tiled ensemble training. + + Args: + args (dict): Tiled ensemble config dict. + versioned_dir (bool, optional): Whether to create a versioned directory. + Defaults to ``True``. + + Returns: + Path: path to new workspace root dir + """ + model_name = args["TrainModels"]["model"]["class_path"].split(".")[-1] + dataset_name = args["data"]["class_path"].split(".")[-1] + category = args["data"]["init_args"]["category"] + root_dir = Path(args["default_root_dir"]) / model_name / dataset_name / category + return create_versioned_dir(root_dir) if versioned_dir else root_dir / "latest" + + def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None: + """Modified method to enable individual model training. It's called when Trainer is being set up.""" + del model # not used here + + _callbacks: list[Callback] = [RichModelSummary()] + + # Add ModelCheckpoint if it is not in the callbacks list. + has_checkpoint_callback = any(isinstance(c, ModelCheckpoint) for c in self._cache.args["callbacks"]) + if not has_checkpoint_callback: + tile_i, tile_j = self.tile_index + _callbacks.append( + ModelCheckpoint( + dirpath=self._cache.args["default_root_dir"] / "weights" / "lightning", + filename=f"model{tile_i}_{tile_j}", + auto_insert_metric_name=False, + ), + ) + + # Add the post-processor callbacks. Used for thresholding and label calculation. + _callbacks.append(_PostProcessorCallback()) + + # Add the normalization callback if tile level normalization was specified (is not none). + normalization_callback = get_normalization_callback(self.normalization) + if normalization_callback is not None: + _callbacks.append(normalization_callback) + + # Add the thresholding and metrics callbacks in all cases, + # because individual model might still need this for early stop. + _callbacks.append(_ThresholdCallback(self.threshold)) + _callbacks.append(_MetricsCallback(self.task, self.image_metric_names, self.pixel_metric_names)) + + _callbacks.append(TimerCallback()) + + # Combine the callbacks, and update the trainer callbacks. + self._cache.args["callbacks"] = _callbacks + self._cache.args["callbacks"] diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_tiling.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_tiling.py new file mode 100644 index 0000000000..db56f88b47 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_tiling.py @@ -0,0 +1,147 @@ +"""Tiler used with ensemble of models.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from collections.abc import Sequence +from typing import Any + +from torch import Tensor + +from anomalib.data.base.datamodule import collate_fn +from anomalib.data.utils.tiler import Tiler, compute_new_image_size + + +class EnsembleTiler(Tiler): + """Tile Image into (non)overlapping Patches which are then used for ensemble training. + + Args: + tile_size (int | Sequence): Tile dimension for each patch. + stride (int | Sequence): Stride length between patches. + image_size (int | Sequence): Size of input image that will be tiled. + + Examples: + >>> import torch + >>> tiler = EnsembleTiler(tile_size=256, stride=128, image_size=512) + >>> + >>> # random images, shape: [B, C, H, W] + >>> images = torch.rand(32, 5, 512, 512) + >>> # once tiled, the shape is [tile_count_H, tile_count_W, B, C, tile_H, tile_W] + >>> tiled = tiler.tile(images) + >>> tiled.shape + torch.Size([3, 3, 32, 5, 256, 256]) + + >>> # assemble the tiles back together + >>> untiled = tiler.untile(tiled) + >>> untiled.shape + torch.Size([32, 5, 512, 512]) + """ + + def __init__(self, tile_size: int | Sequence, stride: int | Sequence, image_size: int | Sequence) -> None: + super().__init__( + tile_size=tile_size, + stride=stride, + ) + + # calculate final image size + self.image_size = self.validate_size_type(image_size) + self.input_h, self.input_w = self.image_size + self.resized_h, self.resized_w = compute_new_image_size( + image_size=(self.input_h, self.input_w), + tile_size=(self.tile_size_h, self.tile_size_w), + stride=(self.stride_h, self.stride_w), + ) + + # get number of patches in both dimensions + self.num_patches_h = int((self.resized_h - self.tile_size_h) / self.stride_h) + 1 + self.num_patches_w = int((self.resized_w - self.tile_size_w) / self.stride_w) + 1 + self.num_tiles = self.num_patches_h * self.num_patches_w + + def tile(self, image: Tensor, use_random_tiling: bool = False) -> Tensor: + """Tiles an input image to either overlapping or non-overlapping patches. + + Args: + image (Tensor): Input images. + use_random_tiling (bool): Random tiling, which is part of original tiler but is unused here. + + Returns: + Tensor: Tiles generated from images. + Returned shape: [num_h, num_w, batch, channel, tile_height, tile_width]. + """ + # tiles are returned in order [tile_count * batch, channels, tile_height, tile_width] + combined_tiles = super().tile(image, use_random_tiling) + + # rearrange to [num_h, num_w, batch, channel, tile_height, tile_width] + tiles = combined_tiles.contiguous().view( + self.batch_size, + self.num_patches_h, + self.num_patches_w, + self.num_channels, + self.tile_size_h, + self.tile_size_w, + ) + tiles = tiles.permute(1, 2, 0, 3, 4, 5) + + return tiles # noqa: RET504 + + def untile(self, tiles: Tensor) -> Tensor: + """Reassemble the tiled tensor into image level representation. + + Args: + tiles (Tensor): Tiles in shape: [num_h, num_w, batch, channel, tile_height, tile_width]. + + Returns: + Tensor: Image constructed from input tiles. Shape: [B, C, H, W]. + """ + # tiles have shape [num_h, num_w, batch, channel, tile_height, tile_width] + _, _, batch, channels, tile_size_h, tile_size_w = tiles.shape + + # set tilers batch size as it might have been changed by previous tiling + self.batch_size = batch + + # rearrange the tiles in order [tile_count * batch, channels, tile_height, tile_width] + # the required shape for untiling + tiles = tiles.permute(2, 0, 1, 3, 4, 5) + tiles = tiles.contiguous().view(-1, channels, tile_size_h, tile_size_w) + + untiled = super().untile(tiles) + + return untiled # noqa: RET504 + + +class TileCollater: + """Class serving as collate function to perform tiling on batch of images from Dataloader. + + Args: + tiler (EnsembleTiler): Tiler used to split the images to tiles. + tile_index (tuple[int, int]): Index of tile we want to return. + """ + + def __init__(self, tiler: EnsembleTiler, tile_index: tuple[int, int]) -> None: + self.tiler = tiler + self.tile_index = tile_index + + def __call__(self, batch: list) -> dict[str, Any]: + """Collate batch and tile images + masks from batch. + + Args: + batch (list): Batch of elements from data, also including images. + + Returns: + dict[str, Any]: Collated batch dictionary with tiled images. + """ + # use default collate + coll_batch = collate_fn(batch) + + tiled_images = self.tiler.tile(coll_batch["image"]) + # return only tiles at given index + coll_batch["image"] = tiled_images[self.tile_index] + + if "mask" in coll_batch: + # insert channel (as mask has just one) + tiled_masks = self.tiler.tile(coll_batch["mask"].unsqueeze(1)) + + # return only tiled at given index, squeeze to remove previously added channel + coll_batch["mask"] = tiled_masks[self.tile_index].squeeze(1) + + return coll_batch diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/helper_functions.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/helper_functions.py new file mode 100644 index 0000000000..bc1e5f4f55 --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/utils/helper_functions.py @@ -0,0 +1,179 @@ +"""Helper functions for the tiled ensemble training.""" + +import json + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +from pathlib import Path + +from jsonargparse import ArgumentParser, Namespace +from lightning import Trainer + +from anomalib.data import AnomalibDataModule, get_datamodule +from anomalib.models import AnomalyModule, get_model +from anomalib.utils.normalization import NormalizationMethod + +from . import NormalizationStage +from .ensemble_engine import TiledEnsembleEngine +from .ensemble_tiling import EnsembleTiler, TileCollater + + +def get_ensemble_datamodule(data_args: dict, tiler: EnsembleTiler, tile_index: tuple[int, int]) -> AnomalibDataModule: + """Get Anomaly Datamodule adjusted for use in ensemble. + + Datamodule collate function gets replaced by TileCollater in order to tile all images before they are passed on. + + Args: + data_args: tiled ensemble data configuration. + tiler (EnsembleTiler): Tiler used to split the images to tiles for use in ensemble. + tile_index (tuple[int, int]): Index of the tile in the split image. + + Returns: + AnomalibDataModule: Anomalib Lightning DataModule + """ + datamodule = get_datamodule(data_args) + # set custom collate function that does the tiling + datamodule.collate_fn = TileCollater(tiler, tile_index) + datamodule.setup() + + return datamodule + + +def get_ensemble_model(model_args: dict, tiler: EnsembleTiler) -> AnomalyModule: + """Get model prepared for ensemble training. + + Args: + model_args: tiled ensemble model configuration. + tiler (EnsembleTiler): tiler used to get tile dimensions. + + Returns: + AnomalyModule: model with input_size setup + """ + model = get_model(model_args) + # set model input size match tile size + model.set_input_size((tiler.tile_size_h, tiler.tile_size_w)) + + return model + + +def get_ensemble_tiler(tiling_args: dict, data_args: dict) -> EnsembleTiler: + """Get tiler used for image tiling and to obtain tile dimensions. + + Args: + tiling_args: tiled ensemble tiling configuration. + data_args: tiled ensemble data configuration. + + Returns: + EnsembleTiler: tiler object. + """ + tiler = EnsembleTiler( + tile_size=tiling_args["tile_size"], + stride=tiling_args["stride"], + image_size=data_args["init_args"]["image_size"], + ) + + return tiler # noqa: RET504 + + +def parse_trainer_kwargs(trainer_args: dict | None) -> Namespace | dict: + """Parse trainer args and instantiate all needed elements. + + Transforms config into kwargs ready for Trainer, including instantiation of callback etc. + + Args: + trainer_args (dict): Trainer args dictionary. + + Returns: + dict: parsed kwargs with instantiated elements. + """ + if not trainer_args: + return {} + + # try to get trainer args, if not present return empty + parser = ArgumentParser() + + parser.add_class_arguments(Trainer, fail_untyped=False, instantiate=False, sub_configs=True) + config = parser.parse_object(trainer_args) + objects = parser.instantiate_classes(config) + + return objects # noqa: RET504 + + +def get_ensemble_engine( + tile_index: tuple[int, int], + accelerator: str, + devices: list[int] | str | int, + root_dir: Path, + normalization_stage: str, + metrics: dict | None = None, + trainer_args: dict | None = None, +) -> TiledEnsembleEngine: + """Prepare engine for ensemble training or prediction. + + This method makes sure correct normalization is used, prepares metrics and additional trainer kwargs.. + + Args: + tile_index (tuple[int, int]): Index of tile that this model processes. + accelerator (str): Accelerator (device) to use. + devices (list[int] | str | int): device IDs used for training. + root_dir (Path): Root directory to save checkpoints, stats and images. + normalization_stage (str): Config dictionary for ensemble post-processing. + metrics (dict): Dict containing pixel and image metrics names. + trainer_args (dict): Trainer args dictionary. Empty dict if not present. + + Returns: + TiledEnsembleEngine: set up engine for ensemble training/prediction. + """ + # if we want tile level normalization we set it here, otherwise it's done later on joined images + if normalization_stage == NormalizationStage.TILE: + normalization = NormalizationMethod.MIN_MAX + else: + normalization = NormalizationMethod.NONE + + # parse additional trainer args and callbacks if present in config + trainer_kwargs = parse_trainer_kwargs(trainer_args) + # remove keys that we already have + trainer_kwargs.pop("accelerator", None) + trainer_kwargs.pop("default_root_dir", None) + trainer_kwargs.pop("devices", None) + + # create engine for specific tile location + engine = TiledEnsembleEngine( + tile_index=tile_index, + normalization=normalization, + accelerator=accelerator, + devices=devices, + default_root_dir=root_dir, + image_metrics=metrics.get("image", None) if metrics else None, + pixel_metrics=metrics.get("pixel", None) if metrics else None, + **trainer_kwargs, + ) + + return engine # noqa: RET504 + + +def get_threshold_values(normalization_stage: NormalizationStage, root_dir: Path) -> tuple[float, float]: + """Get threshold values for image and pixel level predictions. + + If normalization is not used, get values based on statistics obtained from validation set. + If normalization is used, both image and pixel threshold are 0.5 + + Args: + normalization_stage (NormalizationStage): ensemble run args, used to get normalization stage. + root_dir (Path): path to run root where stats file is saved. + + Returns: + tuple[float, float]: image and pixel threshold. + """ + if normalization_stage == NormalizationStage.NONE: + stats_path = root_dir / "weights" / "lightning" / "stats.json" + with stats_path.open("r") as f: + stats = json.load(f) + image_threshold = stats["image_threshold"] + pixel_threshold = stats["pixel_threshold"] + else: + # normalization transforms the scores so that threshold is at 0.5 + image_threshold = 0.5 + pixel_threshold = 0.5 + + return image_threshold, pixel_threshold diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_data.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_data.py new file mode 100644 index 0000000000..4fe45e9c4a --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_data.py @@ -0,0 +1,45 @@ +"""Classes used to store ensemble predictions.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from torch import Tensor + + +class EnsemblePredictions: + """Basic implementation of EnsemblePredictionData that keeps all predictions in main memory.""" + + def __init__(self) -> None: + super().__init__() + self.all_data: dict[tuple[int, int], list] = {} + + def add_tile_prediction(self, tile_index: tuple[int, int], tile_prediction: list[dict[str, Tensor | list]]) -> None: + """Add tile prediction data at provided index to class dictionary in main memory. + + Args: + tile_index (tuple[int, int]): Index of tile that we are adding in form (row, column). + tile_prediction (list[dict[str, Tensor | list]]): + List of batches containing all predicted data for current tile position. + + """ + self.num_batches = len(tile_prediction) + + self.all_data[tile_index] = tile_prediction + + def get_batch_tiles(self, batch_index: int) -> dict[tuple[int, int], dict]: + """Get all tiles of current batch from class dictionary. + + Called by merging mechanism. + + Args: + batch_index (int): Index of current batch of tiles to be returned. + + Returns: + dict[tuple[int, int], dict]: Dictionary mapping tile index to predicted data, for provided batch index. + """ + batch_data = {} + + for index, batches in self.all_data.items(): + batch_data[index] = batches[batch_index] + + return batch_data diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_merging.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_merging.py new file mode 100644 index 0000000000..7337cc4ffe --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_merging.py @@ -0,0 +1,167 @@ +"""Class used as mechanism to merge ensemble predictions from each tile into complete whole-image representation.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import torch +from torch import Tensor + +from .ensemble_tiling import EnsembleTiler +from .prediction_data import EnsemblePredictions + + +class PredictionMergingMechanism: + """Class used for merging the data predicted by each separate model of tiled ensemble. + + Tiles are stacked in one tensor and untiled using Ensemble Tiler. + Boxes from tiles are either stacked or generated anew from anomaly map. + Labels are combined with OR operator, meaning one anomalous tile -> anomalous image. + Scores are averaged across all tiles. + + Args: + ensemble_predictions (EnsemblePredictions): Object containing predictions on tile level. + tiler (EnsembleTiler): Tiler used to transform tiles back to image level representation. + + Example: + >>> from anomalib.pipelines.tiled_ensemble.components.utils.ensemble_tiling import EnsembleTiler + >>> from anomalib.pipelines.tiled_ensemble.components.utils.prediction_data import EnsemblePredictions + >>> + >>> tiler = EnsembleTiler(tile_size=256, stride=128, image_size=512) + >>> data = EnsemblePredictions() + >>> merger = PredictionMergingMechanism(data, tiler) + >>> + >>> # we can then start merging procedure for each batch + >>> merger.merge_tile_predictions(0) + """ + + def __init__(self, ensemble_predictions: EnsemblePredictions, tiler: EnsembleTiler) -> None: + assert ensemble_predictions.num_batches > 0, "There should be at least one batch for each tile prediction." + assert (0, 0) in ensemble_predictions.get_batch_tiles( + 0, + ), "Tile prediction dictionary should always have at least one tile" + + self.ensemble_predictions = ensemble_predictions + self.num_batches = self.ensemble_predictions.num_batches + + self.tiler = tiler + + def merge_tiles(self, batch_data: dict, tile_key: str) -> Tensor: + """Merge tiles back into one tensor and perform untiling with tiler. + + Args: + batch_data (dict): Dictionary containing all tile predictions of current batch. + tile_key (str): Key used in prediction dictionary for tiles that we want to merge. + + Returns: + Tensor: Tensor of tiles in original (stitched) shape. + """ + # batch of tiles with index (0, 0) always exists, so we use it to get some basic information + first_tiles = batch_data[0, 0][tile_key] + batch_size = first_tiles.shape[0] + device = first_tiles.device + + if tile_key == "mask": + # in case of ground truth masks, we don't have channels + merged_size = [ + self.tiler.num_patches_h, + self.tiler.num_patches_w, + batch_size, + self.tiler.tile_size_h, + self.tiler.tile_size_w, + ] + else: + # all tiles beside masks also have channels + num_channels = first_tiles.shape[1] + merged_size = [ + self.tiler.num_patches_h, + self.tiler.num_patches_w, + batch_size, + int(num_channels), + self.tiler.tile_size_h, + self.tiler.tile_size_w, + ] + + # create new empty tensor for merged tiles + merged_masks = torch.zeros(size=merged_size, device=device) + + # insert tile into merged tensor at right locations + for (tile_i, tile_j), tile_data in batch_data.items(): + merged_masks[tile_i, tile_j, ...] = tile_data[tile_key] + + if tile_key == "mask": + # add channel as tiler needs it + merged_masks = merged_masks.unsqueeze(3) + + # stitch tiles back into whole, output is [B, C, H, W] + merged_output = self.tiler.untile(merged_masks) + + if tile_key == "mask": + # remove previously added channels + merged_output = merged_output.squeeze(1) + + return merged_output + + def merge_labels_and_scores(self, batch_data: dict) -> dict[str, Tensor]: + """Join scores and their corresponding label predictions from all tiles for each image. + + Label merging is done by rule where one anomalous tile in image results in whole image being anomalous. + Scores are averaged over tiles. + + Args: + batch_data (dict): Dictionary containing all tile predictions of current batch. + + Returns: + dict[str, Tensor]: Dictionary with "pred_labels" and "pred_scores" + """ + # create accumulator with same shape as original + labels = torch.zeros(batch_data[0, 0]["pred_labels"].shape, dtype=torch.bool) + scores = torch.zeros(batch_data[0, 0]["pred_scores"].shape) + + for curr_tile_data in batch_data.values(): + curr_labels = curr_tile_data["pred_labels"] + curr_scores = curr_tile_data["pred_scores"] + + labels = labels.logical_or(curr_labels) + scores += curr_scores + + scores /= self.tiler.num_tiles + + return {"pred_labels": labels, "pred_scores": scores} + + def merge_tile_predictions(self, batch_index: int) -> dict[str, Tensor | list]: + """Join predictions from ensemble into whole image level representation for batch at index batch_index. + + Args: + batch_index (int): Index of current batch. + + Returns: + dict[str, Tensor | list]: List of merged predictions for specified batch. + """ + current_batch_data = self.ensemble_predictions.get_batch_tiles(batch_index) + + # take first tile as base prediction, keep items that are the same over all tiles: + # image_path, label, mask_path + merged_predictions = { + "image_path": current_batch_data[0, 0]["image_path"], + "label": current_batch_data[0, 0]["label"], + } + if "mask_path" in current_batch_data[0, 0]: + merged_predictions["mask_path"] = current_batch_data[0, 0]["mask_path"] + if "boxes" in current_batch_data[0, 0]: + merged_predictions["boxes"] = current_batch_data[0, 0]["boxes"] + + tiled_data = ["image", "mask"] + if "anomaly_maps" in current_batch_data[0, 0]: + tiled_data += ["anomaly_maps", "pred_masks"] + + # merge all tiled data + for t_key in tiled_data: + if t_key in current_batch_data[0, 0]: + merged_predictions[t_key] = self.merge_tiles(current_batch_data, t_key) + + # label and score merging + merged_scores_and_labels = self.merge_labels_and_scores(current_batch_data) + merged_predictions["pred_labels"] = merged_scores_and_labels["pred_labels"] + merged_predictions["pred_scores"] = merged_scores_and_labels["pred_scores"] + + return merged_predictions diff --git a/src/anomalib/pipelines/tiled_ensemble/components/visualization.py b/src/anomalib/pipelines/tiled_ensemble/components/visualization.py new file mode 100644 index 0000000000..1298ece89f --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/components/visualization.py @@ -0,0 +1,125 @@ +"""Tiled ensemble - visualization job.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from collections.abc import Generator +from pathlib import Path +from typing import Any + +from tqdm import tqdm + +from anomalib import TaskType +from anomalib.data.utils.image import save_image +from anomalib.pipelines.components import Job, JobGenerator +from anomalib.pipelines.tiled_ensemble.components.utils import NormalizationStage +from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS +from anomalib.utils.visualization import ImageVisualizer + +logger = logging.getLogger(__name__) + + +class VisualizationJob(Job): + """Job for visualization of predictions. + + Args: + predictions (list[Any]): list of image-level predictions. + root_dir (Path): Root directory to save checkpoints, stats and images. + task (TaskType): type of task the predictions represent. + normalize (bool): if predictions need to be normalized + """ + + name = "Visualize" + + def __init__(self, predictions: list[Any], root_dir: Path, task: TaskType, normalize: bool) -> None: + super().__init__() + self.predictions = predictions + self.root_dir = root_dir / "images" + self.task = task + self.normalize = normalize + + def run(self, task_id: int | None = None) -> list[Any]: + """Run job that visualizes all prediction data. + + Args: + task_id: Not used in this case. + + Returns: + list[Any]: Unchanged predictions. + """ + del task_id # not needed here + + visualizer = ImageVisualizer(task=self.task, normalize=self.normalize) + + logger.info("Starting visualization.") + + for data in tqdm(self.predictions, desc="Visualizing"): + for result in visualizer(outputs=data): + # Finally image path is root/defect_type/image_name + if result.file_name is not None: + file_path = Path(result.file_name) + else: + msg = "file_path should exist in returned Visualizer." + raise ValueError(msg) + + root = self.root_dir / file_path.parent.name + filename = file_path.name + + save_image(image=result.image, root=root, filename=filename) + + return self.predictions + + @staticmethod + def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS: + """Nothing to collect in this job. + + Returns: + list[Any]: Unchanged list of predictions. + """ + # take the first element as result is list of lists here + return results[0] + + @staticmethod + def save(results: GATHERED_RESULTS) -> None: + """This job doesn't save anything.""" + + +class VisualizationJobGenerator(JobGenerator): + """Generate VisualizationJob. + + Args: + root_dir (Path): Root directory where images will be saved (root/images). + """ + + def __init__(self, root_dir: Path, task: TaskType, normalization_stage: NormalizationStage) -> None: + self.root_dir = root_dir + self.task = task + self.normalize = normalization_stage == NormalizationStage.NONE + + @property + def job_class(self) -> type: + """Return the job class.""" + return VisualizationJob + + def generate_jobs( + self, + args: dict | None = None, + prev_stage_result: list[Any] | None = None, + ) -> Generator[VisualizationJob, None, None]: + """Return a generator producing a single visualization job. + + Args: + args: Ensemble run args. + prev_stage_result (list[Any]): Ensemble predictions from previous step. + + Returns: + Generator[VisualizationJob, None, None]: VisualizationJob generator + """ + del args # args not used here + + if prev_stage_result is not None: + yield VisualizationJob(prev_stage_result, self.root_dir, self.task, self.normalize) + else: + msg = "Visualization job requires tile level predictions from previous step." + raise ValueError(msg) diff --git a/src/anomalib/pipelines/tiled_ensemble/test_pipeline.py b/src/anomalib/pipelines/tiled_ensemble/test_pipeline.py new file mode 100644 index 0000000000..7fdd61e9ff --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/test_pipeline.py @@ -0,0 +1,124 @@ +"""Tiled ensemble test pipeline.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging +from pathlib import Path + +import torch + +from anomalib.data.utils import TestSplitMode +from anomalib.pipelines.components.base import Pipeline, Runner +from anomalib.pipelines.components.runners import ParallelRunner, SerialRunner +from anomalib.pipelines.tiled_ensemble.components import ( + MergeJobGenerator, + MetricsCalculationJobGenerator, + NormalizationJobGenerator, + PredictJobGenerator, + SmoothingJobGenerator, + ThresholdingJobGenerator, + VisualizationJobGenerator, +) +from anomalib.pipelines.tiled_ensemble.components.utils import NormalizationStage, PredictData, ThresholdStage + +logger = logging.getLogger(__name__) + + +class EvalTiledEnsemble(Pipeline): + """Tiled ensemble evaluation pipeline. + + Args: + root_dir (Path): Path to root dir of run that contains checkpoints. + """ + + def __init__(self, root_dir: Path) -> None: + self.root_dir = Path(root_dir) + + def _setup_runners(self, args: dict) -> list[Runner]: + """Set up the runners for the pipeline. + + This pipeline consists of jobs used to test/evaluate tiled ensemble: + Prediction on test data > merging of predictions > (optional) seam smoothing + > (optional) Normalization > (optional) Thresholding + > Visualisation of predictions > Metrics calculation. + + Returns: + list[Runner]: List of runners executing tiled ensemble testing jobs. + """ + runners: list[Runner] = [] + + if args["data"]["init_args"]["test_split_mode"] == TestSplitMode.NONE: + logger.info("Test split mode set to `none`, skipping test phase.") + return runners + + seed = args["seed"] + accelerator = args["accelerator"] + tiling_args = args["tiling"] + data_args = args["data"] + normalization_stage = NormalizationStage(args["normalization_stage"]) + threshold_stage = ThresholdStage(args["thresholding"]["stage"]) + model_args = args["TrainModels"]["model"] + task = args["data"]["init_args"]["task"] + metrics = args["TrainModels"]["metrics"] + + predict_job_generator = PredictJobGenerator( + PredictData.TEST, + seed=seed, + accelerator=accelerator, + root_dir=self.root_dir, + tiling_args=tiling_args, + data_args=data_args, + model_args=model_args, + normalization_stage=normalization_stage, + ) + # 1. predict using test data + if accelerator == "cuda": + runners.append( + ParallelRunner( + predict_job_generator, + n_jobs=torch.cuda.device_count(), + ), + ) + else: + runners.append( + SerialRunner( + predict_job_generator, + ), + ) + # 2. merge predictions + runners.append(SerialRunner(MergeJobGenerator(tiling_args=tiling_args, data_args=data_args))) + + # 3. (optional) smooth seams + if args["SeamSmoothing"]["apply"]: + runners.append( + SerialRunner( + SmoothingJobGenerator(accelerator=accelerator, tiling_args=tiling_args, data_args=data_args), + ), + ) + + # 4. (optional) normalize + if normalization_stage == NormalizationStage.IMAGE: + runners.append(SerialRunner(NormalizationJobGenerator(self.root_dir))) + # 5. (optional) threshold to get labels from scores + if threshold_stage == ThresholdStage.IMAGE: + runners.append(SerialRunner(ThresholdingJobGenerator(self.root_dir, normalization_stage))) + + # 6. visualize predictions + runners.append( + SerialRunner(VisualizationJobGenerator(self.root_dir, task=task, normalization_stage=normalization_stage)), + ) + # calculate metrics + runners.append( + SerialRunner( + MetricsCalculationJobGenerator( + accelerator=accelerator, + root_dir=self.root_dir, + task=task, + metrics=metrics, + normalization_stage=normalization_stage, + ), + ), + ) + + return runners diff --git a/src/anomalib/pipelines/tiled_ensemble/train_pipeline.py b/src/anomalib/pipelines/tiled_ensemble/train_pipeline.py new file mode 100644 index 0000000000..38e4e34e4b --- /dev/null +++ b/src/anomalib/pipelines/tiled_ensemble/train_pipeline.py @@ -0,0 +1,123 @@ +"""Tiled ensemble training pipeline.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from typing import TYPE_CHECKING + +from anomalib.data.utils import ValSplitMode + +if TYPE_CHECKING: + from pathlib import Path + +import logging + +import torch + +from anomalib.pipelines.components.base import Pipeline, Runner +from anomalib.pipelines.components.runners import ParallelRunner, SerialRunner + +from .components import ( + MergeJobGenerator, + PredictJobGenerator, + SmoothingJobGenerator, + StatisticsJobGenerator, + TrainModelJobGenerator, +) +from .components.utils import NormalizationStage, PredictData +from .components.utils.ensemble_engine import TiledEnsembleEngine + +logger = logging.getLogger(__name__) + + +class TrainTiledEnsemble(Pipeline): + """Tiled ensemble training pipeline.""" + + def __init__(self) -> None: + self.root_dir: Path + + def _setup_runners(self, args: dict) -> list[Runner]: + """Setup the runners for the pipeline. + + This pipeline consists of training and validation steps: + Training models > prediction on val data > merging val data > + > (optionally) smoothing seams > calculation of post-processing statistics + + Returns: + list[Runner]: List of runners executing tiled ensemble train + val jobs. + """ + runners: list[Runner] = [] + self.root_dir = TiledEnsembleEngine.setup_ensemble_workspace(args) + + seed = args["seed"] + accelerator = args["accelerator"] + tiling_args = args["tiling"] + data_args = args["data"] + normalization_stage = NormalizationStage(args["normalization_stage"]) + thresholding_method = args["thresholding"]["method"] + model_args = args["TrainModels"]["model"] + + train_job_generator = TrainModelJobGenerator( + seed=seed, + accelerator=accelerator, + root_dir=self.root_dir, + tiling_args=tiling_args, + data_args=data_args, + normalization_stage=normalization_stage, + ) + + predict_job_generator = PredictJobGenerator( + data_source=PredictData.VAL, + seed=seed, + accelerator=accelerator, + root_dir=self.root_dir, + tiling_args=tiling_args, + data_args=data_args, + model_args=model_args, + normalization_stage=normalization_stage, + ) + + # 1. train + if accelerator == "cuda": + runners.append( + ParallelRunner( + train_job_generator, + n_jobs=torch.cuda.device_count(), + ), + ) + else: + runners.append( + SerialRunner( + train_job_generator, + ), + ) + + if data_args["init_args"]["val_split_mode"] == ValSplitMode.NONE: + logger.warning("No validation set provided, skipping statistics calculation.") + return runners + + # 2. predict using validation data + if accelerator == "cuda": + runners.append( + ParallelRunner(predict_job_generator, n_jobs=torch.cuda.device_count()), + ) + else: + runners.append( + SerialRunner(predict_job_generator), + ) + + # 3. merge predictions + runners.append(SerialRunner(MergeJobGenerator(tiling_args=tiling_args, data_args=data_args))) + + # 4. (optional) smooth seams + if args["SeamSmoothing"]["apply"]: + runners.append( + SerialRunner( + SmoothingJobGenerator(accelerator=accelerator, tiling_args=tiling_args, data_args=data_args), + ), + ) + + # 5. calculate statistics used for inference + runners.append(SerialRunner(StatisticsJobGenerator(self.root_dir, thresholding_method))) + + return runners diff --git a/src/anomalib/utils/exceptions/imports.py b/src/anomalib/utils/exceptions/imports.py index ebf6f11c61..6ef8dbd89d 100644 --- a/src/anomalib/utils/exceptions/imports.py +++ b/src/anomalib/utils/exceptions/imports.py @@ -18,6 +18,15 @@ def try_import(import_path: str) -> bool: Returns: bool: True if import succeeds, False otherwise. """ + import warnings + + warnings.warn( + "The 'try_import' function is deprecated and will be removed in v2.0.0. " + "Use 'module_available' from lightning-utilities instead.", + DeprecationWarning, + stacklevel=2, + ) + try: import_module(import_path) except ImportError: diff --git a/src/anomalib/utils/logging.py b/src/anomalib/utils/logging.py index 21f7994fbf..d73ef440c4 100644 --- a/src/anomalib/utils/logging.py +++ b/src/anomalib/utils/logging.py @@ -74,10 +74,8 @@ def redirect_logs(log_file: str) -> None: """ Path(log_file).parent.mkdir(exist_ok=True, parents=True) logger_file_handler = logging.FileHandler(log_file) - root_logger = logging.getLogger() - root_logger.setLevel(logging.DEBUG) format_string = "%(asctime)s - %(name)s - %(levelname)s - %(message)s" - logging.basicConfig(format=format_string, level=logging.DEBUG, handlers=[logger_file_handler]) + logging.basicConfig(format=format_string, handlers=[logger_file_handler]) logging.captureWarnings(capture=True) # remove other handlers from all loggers loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict] diff --git a/src/anomalib/utils/post_processing.py b/src/anomalib/utils/post_processing.py index 46456502c6..27c5f95073 100644 --- a/src/anomalib/utils/post_processing.py +++ b/src/anomalib/utils/post_processing.py @@ -35,7 +35,7 @@ def add_label( img_height, img_width, _ = image.shape font = cv2.FONT_HERSHEY_PLAIN - text = label_name if confidence is None else f"{label_name} ({confidence*100:.0f}%)" + text = label_name if confidence is None else f"{label_name} ({confidence * 100:.0f}%)" # get font sizing font_scale = min(img_width, img_height) * font_scale diff --git a/src/anomalib/utils/rich.py b/src/anomalib/utils/rich.py deleted file mode 100644 index fb61e78caa..0000000000 --- a/src/anomalib/utils/rich.py +++ /dev/null @@ -1,47 +0,0 @@ -"""Custom rich methods.""" - -# Copyright (C) 2024 Intel Corporation -# SPDX-License-Identifier: Apache-2.0 - -from collections.abc import Generator, Iterable -from typing import TYPE_CHECKING, Any - -from rich import get_console -from rich.progress import track - -if TYPE_CHECKING: - from rich.live import Live - - -class CacheRichLiveState: - """Cache the live state of the console. - - Note: This is a bit dangerous as it accesses private attributes of the console. - Use this with caution. - """ - - def __init__(self) -> None: - self.console = get_console() - self.live: Live | None = None - - def __enter__(self) -> None: - """Save the live state of the console.""" - # Need to access private attribute to get the live state - with self.console._lock: # noqa: SLF001 - self.live = self.console._live # noqa: SLF001 - self.console.clear_live() - - def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None: # noqa: ANN401 - """Restore the live state of the console.""" - if self.live: - self.console.clear_live() - self.console.set_live(self.live) - - -def safe_track(*args, **kwargs) -> Generator[Iterable, Any, Any]: - """Wraps ``rich.progress.track`` with a context manager to cache the live state. - - For parameters look at ``rich.progress.track``. - """ - with CacheRichLiveState(): - yield from track(*args, **kwargs) diff --git a/src/anomalib/utils/types/__init__.py b/src/anomalib/utils/types/__init__.py index a706626a40..a220571bc0 100644 --- a/src/anomalib/utils/types/__init__.py +++ b/src/anomalib/utils/types/__init__.py @@ -8,10 +8,10 @@ from lightning.pytorch import Callback from omegaconf import DictConfig, ListConfig -from anomalib.metrics.threshold import BaseThreshold +from anomalib.metrics.threshold import Threshold from anomalib.utils.normalization import NormalizationMethod NORMALIZATION: TypeAlias = NormalizationMethod | DictConfig | Callback | str THRESHOLD: TypeAlias = ( - BaseThreshold | tuple[BaseThreshold, BaseThreshold] | DictConfig | ListConfig | list[dict[str, str | float]] | str + Threshold | tuple[Threshold, Threshold] | DictConfig | ListConfig | list[dict[str, str | float]] | str ) diff --git a/src/anomalib/utils/visualization/__init__.py b/src/anomalib/utils/visualization/__init__.py index f68036ed78..404036dfad 100644 --- a/src/anomalib/utils/visualization/__init__.py +++ b/src/anomalib/utils/visualization/__init__.py @@ -4,11 +4,13 @@ # SPDX-License-Identifier: Apache-2.0 from .base import BaseVisualizer, GeneratorResult, VisualizationStep +from .explanation import ExplanationVisualizer from .image import ImageResult, ImageVisualizer from .metrics import MetricsVisualizer __all__ = [ "BaseVisualizer", + "ExplanationVisualizer", "ImageResult", "ImageVisualizer", "GeneratorResult", diff --git a/src/anomalib/utils/visualization/explanation.py b/src/anomalib/utils/visualization/explanation.py new file mode 100644 index 0000000000..10904161e3 --- /dev/null +++ b/src/anomalib/utils/visualization/explanation.py @@ -0,0 +1,106 @@ +"""Explanation visualization generator. + +Note: This is a temporary visualizer, and will be replaced with the new visualizer in the future. +""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from collections.abc import Iterator +from pathlib import Path + +import numpy as np +from PIL import Image, ImageDraw, ImageFont + +from .base import BaseVisualizer, GeneratorResult, VisualizationStep + + +class ExplanationVisualizer(BaseVisualizer): + """Explanation visualization generator.""" + + def __init__(self) -> None: + super().__init__(visualize_on=VisualizationStep.BATCH) + self.padding = 3 + self.font = ImageFont.load_default(size=16) + + def generate(self, **kwargs) -> Iterator[GeneratorResult]: + """Generate images and return them as an iterator.""" + outputs = kwargs.get("outputs", None) + if outputs is None: + msg = "Outputs must be provided to generate images." + raise ValueError(msg) + return self._visualize_batch(outputs) + + def _visualize_batch(self, batch: dict) -> Iterator[GeneratorResult]: + """Visualize batch of images.""" + batch_size = batch["image"].shape[0] + height, width = batch["image"].shape[-2:] + for i in range(batch_size): + image = batch["image"][i] + explanation = batch["explanation"][i] + file_name = Path(batch["image_path"][i]) + image = Image.open(file_name) + image = image.resize((width, height)) + image = self._draw_image(width, height, image=image, explanation=explanation) + yield GeneratorResult(image=image, file_name=file_name) + + def _draw_image(self, width: int, height: int, image: Image, explanation: str) -> np.ndarray: + text_canvas: Image = self._get_explanation_image(width, height, image, explanation) + label_canvas: Image = self._get_label_image(explanation) + + final_width = max(text_canvas.size[0], width) + final_height = height + text_canvas.size[1] + combined_image = Image.new("RGB", (final_width, final_height), (255, 255, 255)) + combined_image.paste(image, (self.padding, 0)) + combined_image.paste(label_canvas, (10, 10)) + combined_image.paste(text_canvas, (0, height)) + return np.array(combined_image) + + def _get_label_image(self, explanation: str) -> Image: + # Draw label + # Can't use pred_labels as it is computed from the pred_scores using image_threshold. It gives incorrect value. + # So, using explanation. This will probably change with the new design. + label = "Anomalous" if explanation.startswith("Y") else "Normal" + label_color = "red" if label == "Anomalous" else "green" + label_canvas = Image.new("RGB", (100, 20), color=label_color) + draw = ImageDraw.Draw(label_canvas) + draw.text((0, 0), label, font=self.font, fill="white", align="center") + return label_canvas + + def _get_explanation_image(self, width: int, height: int, image: Image, explanation: str) -> Image: + # compute wrap width + text_canvas = Image.new("RGB", (width, height), color="white") + dummy_image = ImageDraw.Draw(image) + text_bbox = dummy_image.textbbox((0, 0), explanation, font=self.font, align="center") + text_canvas_width = text_bbox[2] - text_bbox[0] + self.padding + + # split lines based on the width + lines = list(explanation.split("\n")) + line_with_max_len = max(lines, key=len) + new_width = int(width * len(line_with_max_len) // text_canvas_width) + + # wrap text based on the new width + lines = [] + current_line: list[str] = [] + for word in explanation.split(" "): + test_line = " ".join([*current_line, word]) + if len(test_line) <= new_width: + current_line.append(word) + else: + lines.append(" ".join(current_line)) + current_line = [word] + lines.append(" ".join(current_line)) + wrapped_lines = "\n".join(lines) + + # recompute height + dummy_image = Image.new("RGB", (new_width, height), color="white") + draw = ImageDraw.Draw(dummy_image) + text_bbox = draw.textbbox((0, 0), wrapped_lines, font=self.font, align="center") + new_width = int(text_bbox[2] - text_bbox[0] + self.padding) + new_height = int(text_bbox[3] - text_bbox[1] + self.padding) + + # Final text image + text_canvas = Image.new("RGB", (new_width, new_height), color="white") + draw = ImageDraw.Draw(text_canvas) + draw.text((self.padding // 2, 0), wrapped_lines, font=self.font, fill="black", align="center") + return text_canvas diff --git a/src/anomalib/utils/visualization/metrics.py b/src/anomalib/utils/visualization/metrics.py index a7a1ebcb2b..48f426ea11 100644 --- a/src/anomalib/utils/visualization/metrics.py +++ b/src/anomalib/utils/visualization/metrics.py @@ -18,7 +18,8 @@ class MetricsVisualizer(BaseVisualizer): def __init__(self) -> None: super().__init__(VisualizationStep.STAGE_END) - def generate(self, **kwargs) -> Iterator[GeneratorResult]: + @staticmethod + def generate(**kwargs) -> Iterator[GeneratorResult]: """Generate metric plots and return them as an iterator.""" pl_module: AnomalyModule = kwargs.get("pl_module", None) if pl_module is None: diff --git a/tests/helpers/data.py b/tests/helpers/data.py index 51b683acab..60433df9eb 100644 --- a/tests/helpers/data.py +++ b/tests/helpers/data.py @@ -5,6 +5,7 @@ from __future__ import annotations +import json import shutil from contextlib import ContextDecorator from pathlib import Path @@ -104,7 +105,8 @@ def generate_image( return image, mask - def save_image(self, filename: Path | str, image: np.ndarray, check_contrast: bool = False) -> None: + @staticmethod + def save_image(filename: Path | str, image: np.ndarray, check_contrast: bool = False) -> None: """Save image to filesystem. Args: @@ -318,6 +320,43 @@ def __init__( self.min_size = min_size self.image_generator = DummyImageGenerator(image_shape=image_shape, rng=self.rng) + def _generate_dummy_datumaro_dataset(self) -> None: + """Generates dummy Datumaro dataset in a temporary directory.""" + # generate images + image_root = self.dataset_root / "images" / "default" + image_root.mkdir(parents=True, exist_ok=True) + + file_names: list[str] = [] + + # Create normal images + for i in range(self.num_train + self.num_test): + label = LabelName.NORMAL + image_filename = image_root / f"normal_{i:03}.png" + file_names.append(image_filename) + self.image_generator.generate_image(label, image_filename) + + # Create abnormal images + for i in range(self.num_test): + label = LabelName.ABNORMAL + image_filename = image_root / f"abnormal_{i:03}.png" + file_names.append(image_filename) + self.image_generator.generate_image(label, image_filename) + + # create annotation file + annotation_file = self.dataset_root / "annotations" / "default.json" + annotation_file.parent.mkdir(parents=True, exist_ok=True) + annotations = { + "categories": {"label": {"labels": [{"name": "Normal"}, {"name": "Anomalous"}]}}, + "items": [], + } + for file_name in file_names: + annotations["items"].append({ + "annotations": [{"label_id": 1 if "abnormal" in str(file_name) else 0}], + "image": {"path": file_name.name}, + }) + with annotation_file.open("w") as f: + json.dump(annotations, f) + def _generate_dummy_mvtec_dataset( self, normal_dir: str = "good", @@ -503,7 +542,7 @@ def _generate_dummy_avenue_dataset( train_path = self.dataset_root / train_dir train_path.mkdir(exist_ok=True, parents=True) for clip_idx in range(self.num_train): - clip_path = train_path / f"{clip_idx+1:02}.avi" + clip_path = train_path / f"{clip_idx + 1:02}.avi" frames, _ = self.video_generator.generate_video(length=32, first_label=LabelName.NORMAL, p_state_switch=0) fourcc = cv2.VideoWriter_fourcc("F", "M", "P", "4") writer = cv2.VideoWriter(str(clip_path), fourcc, 30, self.frame_shape) @@ -517,8 +556,8 @@ def _generate_dummy_avenue_dataset( gt_path = self.dataset_root / ground_truth_dir / "testing_label_mask" for clip_idx in range(self.num_test): - clip_path = test_path / f"{clip_idx+1:02}.avi" - mask_path = gt_path / f"{clip_idx+1}_label" + clip_path = test_path / f"{clip_idx + 1:02}.avi" + mask_path = gt_path / f"{clip_idx + 1}_label" mask_path.mkdir(exist_ok=True, parents=True) frames, masks = self.video_generator.generate_video(length=32, p_state_switch=0.2) fourcc = cv2.VideoWriter_fourcc("F", "M", "P", "4") diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py index 09a4749b84..eea3d88e66 100644 --- a/tests/integration/model/test_models.py +++ b/tests/integration/model/test_models.py @@ -7,6 +7,7 @@ # SPDX-License-Identifier: Apache-2.0 from pathlib import Path +from unittest.mock import MagicMock import pytest @@ -159,8 +160,8 @@ def test_export( export_type=export_type, ) + @staticmethod def _get_objects( - self, model_name: str, dataset_path: Path, project_path: Path, @@ -177,9 +178,9 @@ def _get_objects( and engine """ # select task type - if model_name in ("rkde", "ai_vad"): + if model_name in {"rkde", "ai_vad"}: task_type = TaskType.DETECTION - elif model_name in ("ganomaly", "dfkde"): + elif model_name in {"ganomaly", "dfkde", "vlm_ad"}: task_type = TaskType.CLASSIFICATION else: task_type = TaskType.SEGMENTATION @@ -189,7 +190,7 @@ def _get_objects( # https://github.com/openvinotoolkit/anomalib/issues/1478 extra_args = {} - if model_name in ("rkde", "dfkde"): + if model_name in {"rkde", "dfkde"}: extra_args["n_pca_components"] = 2 if model_name == "ai_vad": pytest.skip("Revisit AI-VAD test") @@ -209,6 +210,11 @@ def _get_objects( ) model = get_model(model_name, **extra_args) + + if model_name == "vlm_ad": + model.vlm_backend = MagicMock() + model.vlm_backend.predict.return_value = "YES: Because reasons..." + engine = Engine( logger=False, default_root_dir=project_path, diff --git a/tests/integration/pipelines/test_tiled_ensemble.py b/tests/integration/pipelines/test_tiled_ensemble.py new file mode 100644 index 0000000000..2909311276 --- /dev/null +++ b/tests/integration/pipelines/test_tiled_ensemble.py @@ -0,0 +1,62 @@ +"""Test tiled ensemble training and prediction.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from pathlib import Path + +import pytest +import yaml + +from anomalib.pipelines.tiled_ensemble import EvalTiledEnsemble, TrainTiledEnsemble + + +@pytest.fixture(scope="session") +def get_mock_environment(dataset_path: Path, project_path: Path) -> Path: + """Return mock directory for testing with datapath setup to dummy data.""" + ens_temp_dir = project_path / "ens_tmp" + ens_temp_dir.mkdir(exist_ok=True) + + with Path("tests/integration/pipelines/tiled_ensemble.yaml").open(encoding="utf-8") as file: + config = yaml.safe_load(file) + + # use separate project temp dir to avoid messing with other tests + config["default_root_dir"] = str(ens_temp_dir) + config["data"]["init_args"]["root"] = str(dataset_path / "mvtec") + + with (Path(ens_temp_dir) / "tiled_ensemble.yaml").open("w", encoding="utf-8") as file: + yaml.safe_dump(config, file) + + return Path(ens_temp_dir) + + +def test_train(get_mock_environment: Path, capsys: pytest.CaptureFixture) -> None: + """Test training of the tiled ensemble.""" + train_pipeline = TrainTiledEnsemble() + train_parser = train_pipeline.get_parser() + args = train_parser.parse_args(["--config", str(get_mock_environment / "tiled_ensemble.yaml")]) + train_pipeline.run(args) + # check that no errors were printed -> all stages were successful + out = capsys.readouterr().out + assert not any(line.startswith("There were some errors") for line in out.split("\n")) + + +def test_predict(get_mock_environment: Path, capsys: pytest.CaptureFixture) -> None: + """Test prediction with the tiled ensemble.""" + predict_pipeline = EvalTiledEnsemble(root_dir=get_mock_environment / "Padim" / "MVTec" / "dummy" / "v0") + predict_parser = predict_pipeline.get_parser() + args = predict_parser.parse_args(["--config", str(get_mock_environment / "tiled_ensemble.yaml")]) + predict_pipeline.run(args) + # check that no errors were printed -> all stages were successful + out = capsys.readouterr().out + assert not any(line.startswith("There were some errors") for line in out.split("\n")) + + +def test_visualisation(get_mock_environment: Path) -> None: + """Test that images were produced.""" + assert (get_mock_environment / "Padim/MVTec/dummy/v0/images/bad/000.png").exists() + + +def test_metric_results(get_mock_environment: Path) -> None: + """Test that metrics were saved.""" + assert (get_mock_environment / "Padim/MVTec/dummy/v0/metric_results.csv").exists() diff --git a/tests/integration/pipelines/tiled_ensemble.yaml b/tests/integration/pipelines/tiled_ensemble.yaml new file mode 100644 index 0000000000..8d35be8297 --- /dev/null +++ b/tests/integration/pipelines/tiled_ensemble.yaml @@ -0,0 +1,43 @@ +seed: 42 +accelerator: "cpu" +default_root_dir: "results" + +tiling: + tile_size: [50, 50] + stride: 50 + +normalization_stage: image # on what level we normalize, options: [tile, image, none] +thresholding: + method: F1AdaptiveThreshold # refer to documentation for thresholding methods + stage: image # stage at which we apply threshold, options: [tile, image] + +data: + class_path: anomalib.data.MVTec + init_args: + root: toBeSetup + category: dummy + train_batch_size: 32 + eval_batch_size: 32 + num_workers: 0 + task: segmentation + transform: null + train_transform: null + eval_transform: null + test_split_mode: from_dir + test_split_ratio: 0.2 + val_split_mode: same_as_test + val_split_ratio: 0.5 + image_size: [50, 100] + +SeamSmoothing: + apply: True # if this is applied, area around tile seams are is smoothed + sigma: 2 # sigma of gaussian filter used to smooth this area + width: 0.1 # width factor, multiplied by tile dimension gives the region width around seam which will be smoothed + +TrainModels: + model: + class_path: Padim + + metrics: + pixel: AUROC + image: AUROC diff --git a/tests/integration/tools/test_gradio_entrypoint.py b/tests/integration/tools/test_gradio_entrypoint.py index ad34f0cfa1..25b0d7de5f 100644 --- a/tests/integration/tools/test_gradio_entrypoint.py +++ b/tests/integration/tools/test_gradio_entrypoint.py @@ -24,7 +24,8 @@ class TestGradioInferenceEntrypoint: """ @pytest.fixture() - def get_functions(self) -> tuple[Callable, Callable]: + @staticmethod + def get_functions() -> tuple[Callable, Callable]: """Get functions from Gradio_inference.py.""" if find_spec("gradio_inference") is not None: from tools.inference.gradio_inference import get_inferencer, get_parser @@ -33,8 +34,8 @@ def get_functions(self) -> tuple[Callable, Callable]: raise ImportError(msg) return get_parser, get_inferencer + @staticmethod def test_torch_inference( - self, get_functions: tuple[Callable, Callable], ckpt_path: Callable[[str], Path], ) -> None: @@ -57,8 +58,8 @@ def test_torch_inference( ) assert isinstance(inferencer(arguments.weights, arguments.metadata), TorchInferencer) + @staticmethod def test_openvino_inference( - self, get_functions: tuple[Callable, Callable], ckpt_path: Callable[[str], Path], ) -> None: diff --git a/tests/integration/tools/test_lightning_entrypoint.py b/tests/integration/tools/test_lightning_entrypoint.py index 51c93fbcb5..aa239e7c8d 100644 --- a/tests/integration/tools/test_lightning_entrypoint.py +++ b/tests/integration/tools/test_lightning_entrypoint.py @@ -17,7 +17,8 @@ class TestLightningInferenceEntrypoint: """This tests whether the entrypoints run without errors without quantitative measure of the outputs.""" @pytest.fixture() - def get_functions(self) -> tuple[Callable, Callable]: + @staticmethod + def get_functions() -> tuple[Callable, Callable]: """Get functions from lightning_inference.py.""" if find_spec("lightning_inference") is not None: from tools.inference.lightning_inference import get_parser, infer @@ -26,8 +27,8 @@ def get_functions(self) -> tuple[Callable, Callable]: raise ImportError(msg) return get_parser, infer + @staticmethod def test_lightning_inference( - self, get_functions: tuple[Callable, Callable], project_path: Path, get_dummy_inference_image: str, diff --git a/tests/integration/tools/test_openvino_entrypoint.py b/tests/integration/tools/test_openvino_entrypoint.py index dbbe214e62..5883a49957 100644 --- a/tests/integration/tools/test_openvino_entrypoint.py +++ b/tests/integration/tools/test_openvino_entrypoint.py @@ -20,7 +20,8 @@ class TestOpenVINOInferenceEntrypoint: """This tests whether the entrypoints run without errors without quantitative measure of the outputs.""" @pytest.fixture(scope="module") - def get_functions(self) -> tuple[Callable, Callable]: + @staticmethod + def get_functions() -> tuple[Callable, Callable]: """Get functions from openvino_inference.py.""" if find_spec("openvino_inference") is not None: from tools.inference.openvino_inference import get_parser, infer @@ -29,8 +30,8 @@ def get_functions(self) -> tuple[Callable, Callable]: raise ImportError(msg) return get_parser, infer + @staticmethod def test_openvino_inference( - self, get_functions: tuple[Callable, Callable], ckpt_path: Callable[[str], Path], get_dummy_inference_image: str, diff --git a/tests/integration/tools/test_torch_entrypoint.py b/tests/integration/tools/test_torch_entrypoint.py index 3980026122..7d81093cec 100644 --- a/tests/integration/tools/test_torch_entrypoint.py +++ b/tests/integration/tools/test_torch_entrypoint.py @@ -20,7 +20,8 @@ class TestTorchInferenceEntrypoint: """This tests whether the entrypoints run without errors without quantitative measure of the outputs.""" @pytest.fixture() - def get_functions(self) -> tuple[Callable, Callable]: + @staticmethod + def get_functions() -> tuple[Callable, Callable]: """Get functions from torch_inference.py.""" if find_spec("torch_inference") is not None: from tools.inference.torch_inference import get_parser, infer @@ -29,8 +30,8 @@ def get_functions(self) -> tuple[Callable, Callable]: raise ImportError(msg) return get_parser, infer + @staticmethod def test_torch_inference( - self, get_functions: tuple[Callable, Callable], project_path: Path, ckpt_path: Callable[[str], Path], diff --git a/tests/integration/tools/upgrade/test_config.py b/tests/integration/tools/upgrade/test_config.py index a7a8dc5569..548baad060 100644 --- a/tests/integration/tools/upgrade/test_config.py +++ b/tests/integration/tools/upgrade/test_config.py @@ -17,7 +17,8 @@ class TestConfigAdapter: and comparing it to the expected v1 config. """ - def test_config_adapter(self, project_path: Path) -> None: + @staticmethod + def test_config_adapter(project_path: Path) -> None: """Test the ConfigAdapter upgrade_all method. Test the ConfigAdapter class by upgrading and saving a v0 config to v1, diff --git a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py b/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py index a57622cf3b..e8c52f13f5 100644 --- a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py +++ b/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py @@ -29,16 +29,20 @@ def __init__(self) -> None: self.image_threshold = F1AdaptiveThreshold() self.pixel_threshold = F1AdaptiveThreshold() - def test_step(self, **_kwdargs) -> None: + @staticmethod + def test_step(**_kwdargs) -> None: return None - def validation_epoch_end(self, **_kwdargs) -> None: + @staticmethod + def validation_epoch_end(**_kwdargs) -> None: return None - def test_epoch_end(self, **_kwdargs) -> None: + @staticmethod + def test_epoch_end(**_kwdargs) -> None: return None - def configure_optimizers(self) -> None: + @staticmethod + def configure_optimizers() -> None: return None @property diff --git a/tests/unit/cli/test_help_formatter.py b/tests/unit/cli/test_help_formatter.py index 83278903fa..fb9713866d 100644 --- a/tests/unit/cli/test_help_formatter.py +++ b/tests/unit/cli/test_help_formatter.py @@ -86,7 +86,8 @@ class TestCustomHelpFormatter: """Test Custom Help Formatter.""" @pytest.fixture() - def mock_parser(self) -> ArgumentParser: + @staticmethod + def mock_parser() -> ArgumentParser: """Mock ArgumentParser.""" parser = ArgumentParser(formatter_class=CustomHelpFormatter) parser.formatter_class.subcommand = "fit" @@ -103,7 +104,8 @@ def mock_parser(self) -> ArgumentParser: ) return parser - def test_verbose_0(self, capfd: "pytest.CaptureFixture", mock_parser: ArgumentParser) -> None: + @staticmethod + def test_verbose_0(capfd: "pytest.CaptureFixture", mock_parser: ArgumentParser) -> None: """Test verbose level 0.""" argv = ["anomalib", "fit", "-h"] assert mock_parser.formatter_class == CustomHelpFormatter @@ -114,7 +116,8 @@ def test_verbose_0(self, capfd: "pytest.CaptureFixture", mock_parser: ArgumentPa assert "Quick-Start" in out assert "Arguments" not in out - def test_verbose_1(self, capfd: "pytest.CaptureFixture", mock_parser: ArgumentParser) -> None: + @staticmethod + def test_verbose_1(capfd: "pytest.CaptureFixture", mock_parser: ArgumentParser) -> None: """Test verbose level 1.""" argv = ["anomalib", "fit", "-h", "-v"] assert mock_parser.formatter_class == CustomHelpFormatter @@ -125,7 +128,8 @@ def test_verbose_1(self, capfd: "pytest.CaptureFixture", mock_parser: ArgumentPa assert "Quick-Start" in out assert "Arguments" in out - def test_verbose_2(self, capfd: "pytest.CaptureFixture", mock_parser: ArgumentParser) -> None: + @staticmethod + def test_verbose_2(capfd: "pytest.CaptureFixture", mock_parser: ArgumentParser) -> None: """Test verbose level 2.""" argv = ["anomalib", "fit", "-h", "-vv"] assert mock_parser.formatter_class == CustomHelpFormatter diff --git a/tests/unit/cli/test_installation.py b/tests/unit/cli/test_installation.py index ff2f0b5184..6a34017639 100644 --- a/tests/unit/cli/test_installation.py +++ b/tests/unit/cli/test_installation.py @@ -26,7 +26,7 @@ def requirements_file() -> Path: """Create a temporary requirements file with some example requirements.""" requirements = ["numpy==1.19.5", "opencv-python-headless>=4.5.1.48"] - with tempfile.NamedTemporaryFile(mode="w", delete=False) as f: + with tempfile.NamedTemporaryFile(mode="w", delete=False, encoding="utf-8") as f: f.write("\n".join(requirements)) return Path(f.name) diff --git a/tests/unit/data/base/base.py b/tests/unit/data/base/base.py index 86f7dd59e4..9e44c11fb4 100644 --- a/tests/unit/data/base/base.py +++ b/tests/unit/data/base/base.py @@ -17,14 +17,16 @@ class _TestAnomalibDataModule: test class is not meant to be used directly. """ + @staticmethod @pytest.mark.parametrize("subset", ["train", "val", "test"]) - def test_datamodule_has_dataloader_attributes(self, datamodule: AnomalibDataModule, subset: str) -> None: + def test_datamodule_has_dataloader_attributes(datamodule: AnomalibDataModule, subset: str) -> None: """Test that the datamodule has the correct dataloader attributes.""" dataloader = f"{subset}_dataloader" assert hasattr(datamodule, dataloader) assert isinstance(getattr(datamodule, dataloader)(), DataLoader) - def test_datamodule_from_config(self, fxt_data_config_path: str) -> None: + @staticmethod + def test_datamodule_from_config(fxt_data_config_path: str) -> None: # 1. Wrong file path: with pytest.raises(FileNotFoundError): AnomalibDataModule.from_config(config_path="wrong_configs.yaml") diff --git a/tests/unit/data/base/depth.py b/tests/unit/data/base/depth.py index 4747314591..3e1a6bde9f 100644 --- a/tests/unit/data/base/depth.py +++ b/tests/unit/data/base/depth.py @@ -11,8 +11,9 @@ class _TestAnomalibDepthDatamodule(_TestAnomalibDataModule): + @staticmethod @pytest.mark.parametrize("subset", ["train", "val", "test"]) - def test_get_item_returns_correct_keys_and_shapes(self, datamodule: AnomalibDataModule, subset: str) -> None: + def test_get_item_returns_correct_keys_and_shapes(subset: str, datamodule: AnomalibDataModule) -> None: """Test that the datamodule __getitem__ returns the correct keys and shapes.""" # Get the dataloader. dataloader = getattr(datamodule, f"{subset}_dataloader")() @@ -23,7 +24,7 @@ def test_get_item_returns_correct_keys_and_shapes(self, datamodule: AnomalibData # Check that the batch has the correct keys. expected_keys = {"image_path", "depth_path", "label", "image", "depth_image"} - if dataloader.dataset.task in ("detection", "segmentation"): + if dataloader.dataset.task in {"detection", "segmentation"}: expected_keys |= {"mask_path", "mask"} if dataloader.dataset.task == "detection": @@ -38,5 +39,5 @@ def test_get_item_returns_correct_keys_and_shapes(self, datamodule: AnomalibData assert batch["depth_image"].shape == (4, 3, 256, 256) assert batch["label"].shape == (4,) - if dataloader.dataset.task in ("detection", "segmentation"): + if dataloader.dataset.task in {"detection", "segmentation"}: assert batch["mask"].shape == (4, 256, 256) diff --git a/tests/unit/data/base/image.py b/tests/unit/data/base/image.py index 261ee19739..d5b1a59f8c 100644 --- a/tests/unit/data/base/image.py +++ b/tests/unit/data/base/image.py @@ -14,8 +14,9 @@ class _TestAnomalibImageDatamodule(_TestAnomalibDataModule): # 1. Test if the image datasets are correctly created. + @staticmethod @pytest.mark.parametrize("subset", ["train", "val", "test"]) - def test_get_item_returns_correct_keys_and_shapes(self, datamodule: AnomalibDataModule, subset: str) -> None: + def test_get_item_returns_correct_keys_and_shapes(subset: str, datamodule: AnomalibDataModule) -> None: """Test that the datamodule __getitem__ returns image, mask, label and boxes.""" # Get the dataloader. dataloader = getattr(datamodule, f"{subset}_dataloader")() @@ -27,10 +28,11 @@ def test_get_item_returns_correct_keys_and_shapes(self, datamodule: AnomalibData assert batch["image"].shape == (4, 3, 256, 256) assert batch["label"].shape == (4,) - if dataloader.dataset.task in ("detection", "segmentation"): + if dataloader.dataset.task in {"detection", "segmentation"}: assert batch["mask"].shape == (4, 256, 256) - def test_non_overlapping_splits(self, datamodule: AnomalibDataModule) -> None: + @staticmethod + def test_non_overlapping_splits(datamodule: AnomalibDataModule) -> None: """This test ensures that all splits are non-overlapping when split mode == from_test.""" if datamodule.val_split_mode == "from_test": assert ( @@ -50,7 +52,8 @@ def test_non_overlapping_splits(self, datamodule: AnomalibDataModule) -> None: == 0 ), "Found train and test split contamination" - def test_equal_splits(self, datamodule: AnomalibDataModule) -> None: + @staticmethod + def test_equal_splits(datamodule: AnomalibDataModule) -> None: """This test ensures that val and test split are equal when split mode == same_as_test.""" if datamodule.val_split_mode == "same_as_test": assert np.array_equal( diff --git a/tests/unit/data/base/video.py b/tests/unit/data/base/video.py index d42768bd6c..ef14fc50db 100644 --- a/tests/unit/data/base/video.py +++ b/tests/unit/data/base/video.py @@ -12,8 +12,9 @@ class _TestAnomalibVideoDatamodule(_TestAnomalibDataModule): + @staticmethod @pytest.mark.parametrize("subset", ["train", "val", "test"]) - def test_get_item_returns_correct_keys_and_shapes(self, datamodule: AnomalibDataModule, subset: str) -> None: + def test_get_item_returns_correct_keys_and_shapes(datamodule: AnomalibDataModule, subset: str) -> None: """Test that the datamodule __getitem__ returns image, mask, label and boxes.""" # Get the dataloader. dataloader = getattr(datamodule, f"{subset}_dataloader")() @@ -42,13 +43,14 @@ def test_get_item_returns_correct_keys_and_shapes(self, datamodule: AnomalibData # We don't know the shape of the original image, so we only check that it is a list of 4 images. assert batch["original_image"].shape[0] == 4 - if subset in ("val", "test"): + if subset in {"val", "test"}: assert len(batch["label"]) == 4 assert batch["mask"].shape == (4, 256, 256) assert batch["mask"].shape == (4, 256, 256) + @staticmethod @pytest.mark.parametrize("subset", ["train", "val", "test"]) - def test_item_dtype(self, datamodule: AnomalibDataModule, subset: str) -> None: + def test_item_dtype(subset: str, datamodule: AnomalibDataModule) -> None: """Test that the input tensor is of float type and scaled between 0-1.""" # Get the dataloader. dataloader = getattr(datamodule, f"{subset}_dataloader")() @@ -60,8 +62,9 @@ def test_item_dtype(self, datamodule: AnomalibDataModule, subset: str) -> None: assert clip.min() >= 0 assert clip.max() <= 1 + @staticmethod @pytest.mark.parametrize("clip_length_in_frames", [1]) - def test_single_frame_squeezed(self, datamodule: AnomalibDataModule) -> None: + def test_single_frame_squeezed(datamodule: AnomalibDataModule) -> None: """Test that the temporal dimension is squeezed when the clip lenght is 1.""" # Get the dataloader. dataloader = datamodule.train_dataloader() diff --git a/tests/unit/data/image/test_btech.py b/tests/unit/data/image/test_btech.py index 91abf35cc0..02ec81b889 100644 --- a/tests/unit/data/image/test_btech.py +++ b/tests/unit/data/image/test_btech.py @@ -16,7 +16,8 @@ class TestBTech(_TestAnomalibImageDatamodule): """MVTec Datamodule Unit Tests.""" @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType) -> BTech: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType) -> BTech: """Create and return a BTech datamodule.""" _datamodule = BTech( root=dataset_path / "btech", @@ -33,6 +34,7 @@ def datamodule(self, dataset_path: Path, task_type: TaskType) -> BTech: return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" return "configs/data/btech.yaml" diff --git a/tests/unit/data/image/test_datumaro.py b/tests/unit/data/image/test_datumaro.py new file mode 100644 index 0000000000..2aef9ae715 --- /dev/null +++ b/tests/unit/data/image/test_datumaro.py @@ -0,0 +1,39 @@ +"""Unit tests - Datumaro Datamodule.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from pathlib import Path + +import pytest + +from anomalib import TaskType +from anomalib.data import Datumaro +from tests.unit.data.base.image import _TestAnomalibImageDatamodule + + +class TestDatumaro(_TestAnomalibImageDatamodule): + """Datumaro Datamodule Unit Tests.""" + + @pytest.fixture() + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType) -> Datumaro: + """Create and return a Datumaro datamodule.""" + if task_type != TaskType.CLASSIFICATION: + pytest.skip("Datumaro only supports classification tasks.") + + _datamodule = Datumaro( + root=dataset_path / "datumaro", + task=task_type, + train_batch_size=4, + eval_batch_size=4, + ) + _datamodule.setup() + + return _datamodule + + @pytest.fixture() + @staticmethod + def fxt_data_config_path() -> str: + """Return the path to the test data config.""" + return "configs/data/datumaro.yaml" diff --git a/tests/unit/data/image/test_folder.py b/tests/unit/data/image/test_folder.py index 48cd7ff0b3..61cb2fd0c3 100644 --- a/tests/unit/data/image/test_folder.py +++ b/tests/unit/data/image/test_folder.py @@ -19,7 +19,8 @@ class TestFolder(_TestAnomalibImageDatamodule): """ @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType) -> Folder: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType) -> Folder: """Create and return a Folder datamodule.""" # Make sure to use a mask directory for segmentation. Folder datamodule # expects a relative directory to the root. @@ -43,6 +44,7 @@ def datamodule(self, dataset_path: Path, task_type: TaskType) -> Folder: return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" return "configs/data/folder.yaml" diff --git a/tests/unit/data/image/test_folder_3d.py b/tests/unit/data/image/test_folder_3d.py index 1fb4a7edda..c3d1dd6991 100644 --- a/tests/unit/data/image/test_folder_3d.py +++ b/tests/unit/data/image/test_folder_3d.py @@ -16,7 +16,8 @@ class TestFolder3D(_TestAnomalibDepthDatamodule): """Folder3D Datamodule Unit Tests.""" @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType) -> Folder3D: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType) -> Folder3D: """Create and return a Folder 3D datamodule.""" _datamodule = Folder3D( name="dummy", @@ -40,11 +41,13 @@ def datamodule(self, dataset_path: Path, task_type: TaskType) -> Folder3D: return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" return "configs/data/folder_3d.yaml" - def test_datamodule_from_config(self, fxt_data_config_path: str) -> None: + @staticmethod + def test_datamodule_from_config(fxt_data_config_path: str) -> None: """Test method to create a datamodule from a configuration file. Args: diff --git a/tests/unit/data/image/test_kolektor.py b/tests/unit/data/image/test_kolektor.py index 4ba9e5ccd2..f2b86253d6 100644 --- a/tests/unit/data/image/test_kolektor.py +++ b/tests/unit/data/image/test_kolektor.py @@ -16,7 +16,8 @@ class TestKolektor(_TestAnomalibImageDatamodule): """Kolektor Datamodule Unit Tests.""" @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType) -> Kolektor: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType) -> Kolektor: """Create and return a BTech datamodule.""" _datamodule = Kolektor( root=dataset_path / "kolektor", @@ -32,6 +33,7 @@ def datamodule(self, dataset_path: Path, task_type: TaskType) -> Kolektor: return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" return "configs/data/kolektor.yaml" diff --git a/tests/unit/data/image/test_mvtec.py b/tests/unit/data/image/test_mvtec.py index 2cfe8ed9cf..d4c6852563 100644 --- a/tests/unit/data/image/test_mvtec.py +++ b/tests/unit/data/image/test_mvtec.py @@ -16,7 +16,8 @@ class TestMVTec(_TestAnomalibImageDatamodule): """MVTec Datamodule Unit Tests.""" @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType) -> MVTec: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType) -> MVTec: """Create and return a MVTec datamodule.""" _datamodule = MVTec( root=dataset_path / "mvtec", @@ -31,6 +32,7 @@ def datamodule(self, dataset_path: Path, task_type: TaskType) -> MVTec: return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" return "configs/data/mvtec.yaml" diff --git a/tests/unit/data/image/test_mvtec_3d.py b/tests/unit/data/image/test_mvtec_3d.py index 1e5c0ccb01..1e50c61795 100644 --- a/tests/unit/data/image/test_mvtec_3d.py +++ b/tests/unit/data/image/test_mvtec_3d.py @@ -16,7 +16,8 @@ class TestMVTec3D(_TestAnomalibDepthDatamodule): """MVTec Datamodule Unit Tests.""" @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType) -> MVTec3D: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType) -> MVTec3D: """Create and return a Folder 3D datamodule.""" _datamodule = MVTec3D( root=dataset_path / "mvtec_3d", @@ -33,6 +34,7 @@ def datamodule(self, dataset_path: Path, task_type: TaskType) -> MVTec3D: return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" return "configs/data/mvtec_3d.yaml" diff --git a/tests/unit/data/image/test_visa.py b/tests/unit/data/image/test_visa.py index 5028aa066d..1bb251b00c 100644 --- a/tests/unit/data/image/test_visa.py +++ b/tests/unit/data/image/test_visa.py @@ -16,7 +16,8 @@ class TestVisa(_TestAnomalibImageDatamodule): """Visa Datamodule Unit Tests.""" @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType) -> Visa: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType) -> Visa: """Create and return a Avenue datamodule.""" _datamodule = Visa( root=dataset_path, @@ -33,6 +34,7 @@ def datamodule(self, dataset_path: Path, task_type: TaskType) -> Visa: return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" return "configs/data/visa.yaml" diff --git a/tests/unit/data/test_inference.py b/tests/unit/data/test_inference.py index 1152457592..0ac049db18 100644 --- a/tests/unit/data/test_inference.py +++ b/tests/unit/data/test_inference.py @@ -20,7 +20,8 @@ def predict_dataset_path(dataset_path: Path) -> Path: class TestPredictDataset: """Test PredictDataset class.""" - def test_inference_dataset(self, predict_dataset_path: Path) -> None: + @staticmethod + def test_inference_dataset(predict_dataset_path: Path) -> None: """Test the PredictDataset class.""" # Use the bad images from the dummy MVTec AD dataset. dataset = PredictDataset(path=predict_dataset_path, image_size=(256, 256)) @@ -36,7 +37,8 @@ def test_inference_dataset(self, predict_dataset_path: Path) -> None: assert sample["image"].shape == (3, 256, 256) assert Path(sample["image_path"]).suffix == ".png" - def test_transforms_applied(self, predict_dataset_path: Path) -> None: + @staticmethod + def test_transforms_applied(predict_dataset_path: Path) -> None: """Test whether the transforms are applied to the images.""" # Create a transform that resizes the image to 512x512. transform = v2.Compose([v2.Resize(512)]) diff --git a/tests/unit/data/utils/test_image.py b/tests/unit/data/utils/test_image.py index b18b0107b1..00cff13edd 100644 --- a/tests/unit/data/utils/test_image.py +++ b/tests/unit/data/utils/test_image.py @@ -13,30 +13,35 @@ class TestGetImageFilenames: """Tests for ``get_image_filenames`` function.""" - def test_existing_image_file(self, dataset_path: Path) -> None: + @staticmethod + def test_existing_image_file(dataset_path: Path) -> None: """Test ``get_image_filenames`` returns the correct path for an existing image file.""" image_path = dataset_path / "mvtec/dummy/train/good/000.png" image_filenames = get_image_filenames(image_path) assert image_filenames == [image_path.resolve()] - def test_existing_image_directory(self, dataset_path: Path) -> None: + @staticmethod + def test_existing_image_directory(dataset_path: Path) -> None: """Test ``get_image_filenames`` returns the correct image filenames from an existing directory.""" directory_path = dataset_path / "mvtec/dummy/train/good" image_filenames = get_image_filenames(directory_path) expected_filenames = [(directory_path / f"{i:03d}.png").resolve() for i in range(5)] assert set(image_filenames) == set(expected_filenames) - def test_nonexistent_image_file(self) -> None: + @staticmethod + def test_nonexistent_image_file() -> None: """Test ``get_image_filenames`` raises FileNotFoundError for a nonexistent image file.""" with pytest.raises(FileNotFoundError): get_image_filenames("009.tiff") - def test_nonexistent_image_directory(self) -> None: + @staticmethod + def test_nonexistent_image_directory() -> None: """Test ``get_image_filenames`` raises FileNotFoundError for a nonexistent image directory.""" with pytest.raises(FileNotFoundError): get_image_filenames("nonexistent_directory") - def test_non_image_file(self, dataset_path: Path) -> None: + @staticmethod + def test_non_image_file(dataset_path: Path) -> None: """Test ``get_image_filenames`` raises ValueError for a non-image file.""" filename = dataset_path / "avenue/ground_truth_demo/testing_label_mask/1_label.mat" with pytest.raises(ValueError, match=r"``filename`` is not an image file*"): diff --git a/tests/unit/data/utils/test_path.py b/tests/unit/data/utils/test_path.py index 2230157079..09f88496ad 100644 --- a/tests/unit/data/utils/test_path.py +++ b/tests/unit/data/utils/test_path.py @@ -14,44 +14,52 @@ class TestValidatePath: """Tests for ``validate_path`` function.""" - def test_invalid_path_type(self) -> None: + @staticmethod + def test_invalid_path_type() -> None: """Test ``validate_path`` raises TypeError for an invalid path type.""" with pytest.raises(TypeError, match=r"Expected str, bytes or os.PathLike object, not*"): validate_path(123) - def test_is_path_too_long(self) -> None: + @staticmethod + def test_is_path_too_long() -> None: """Test ``validate_path`` raises ValueError for a path that is too long.""" with pytest.raises(ValueError, match=r"Path is too long: *"): validate_path("/" * 1000) - def test_contains_non_printable_characters(self) -> None: + @staticmethod + def test_contains_non_printable_characters() -> None: """Test ``validate_path`` raises ValueError for a path that contains non-printable characters.""" with pytest.raises(ValueError, match=r"Path contains non-printable characters: *"): validate_path("/\x00") - def test_existing_file_within_base_dir(self, dataset_path: Path) -> None: + @staticmethod + def test_existing_file_within_base_dir(dataset_path: Path) -> None: """Test ``validate_path`` returns the validated path for an existing file within the base directory.""" file_path = dataset_path / "mvtec/dummy/train/good/000.png" validated_path = validate_path(file_path, base_dir=dataset_path) assert validated_path == file_path.resolve() - def test_existing_directory_within_base_dir(self, dataset_path: Path) -> None: + @staticmethod + def test_existing_directory_within_base_dir(dataset_path: Path) -> None: """Test ``validate_path`` returns the validated path for an existing directory within the base directory.""" directory_path = dataset_path / "mvtec/dummy/train/good" validated_path = validate_path(directory_path, base_dir=dataset_path) assert validated_path == directory_path.resolve() - def test_nonexistent_file(self, dataset_path: Path) -> None: + @staticmethod + def test_nonexistent_file(dataset_path: Path) -> None: """Test ``validate_path`` raises FileNotFoundError for a nonexistent file.""" with pytest.raises(FileNotFoundError): validate_path(dataset_path / "nonexistent/file.png") - def test_nonexistent_directory(self, dataset_path: Path) -> None: + @staticmethod + def test_nonexistent_directory(dataset_path: Path) -> None: """Test ``validate_path`` raises FileNotFoundError for a nonexistent directory.""" with pytest.raises(FileNotFoundError): validate_path(dataset_path / "nonexistent/directory") - def test_no_read_permission(self) -> None: + @staticmethod + def test_no_read_permission() -> None: """Test ``validate_path`` raises PermissionError for a file without read permission.""" with TemporaryDirectory() as tmp_dir: file_path = Path(tmp_dir) / "test.txt" @@ -61,9 +69,16 @@ def test_no_read_permission(self) -> None: with pytest.raises(PermissionError, match=r"Read or execute permissions denied for the path:*"): validate_path(file_path, base_dir=Path(tmp_dir)) - def test_no_read_execute_permission(self) -> None: + @staticmethod + def test_no_read_execute_permission() -> None: """Test ``validate_path`` raises PermissionError for a directory without read and execute permission.""" with TemporaryDirectory() as tmp_dir: Path(tmp_dir).chmod(0o222) # Remove read and execute permission with pytest.raises(PermissionError, match=r"Read or execute permissions denied for the path:*"): validate_path(tmp_dir, base_dir=Path(tmp_dir)) + + @staticmethod + def test_file_wrongsuffix() -> None: + """Test ``validate_path`` raises ValueError for a file with wrong suffix.""" + with pytest.raises(ValueError, match="Path extension is not accepted."): + validate_path("file.png", should_exist=False, extensions=(".json", ".txt")) diff --git a/tests/unit/data/utils/test_synthetic.py b/tests/unit/data/utils/test_synthetic.py index 599cf5cc68..4d6ab0a3c7 100644 --- a/tests/unit/data/utils/test_synthetic.py +++ b/tests/unit/data/utils/test_synthetic.py @@ -47,24 +47,28 @@ def synthetic_dataset_from_samples(folder_dataset: FolderDataset) -> SyntheticAn class TestSyntheticAnomalyDataset: """Test SyntheticAnomalyDataset class.""" - def test_create_synthetic_dataset(self, synthetic_dataset: SyntheticAnomalyDataset) -> None: + @staticmethod + def test_create_synthetic_dataset(synthetic_dataset: SyntheticAnomalyDataset) -> None: """Tests if the image and mask files listed in the synthetic dataset exist.""" assert all(Path(path).exists() for path in synthetic_dataset.samples.image_path) assert all(Path(path).exists() for path in synthetic_dataset.samples.mask_path) - def test_create_from_dataset(self, synthetic_dataset_from_samples: SyntheticAnomalyDataset) -> None: + @staticmethod + def test_create_from_dataset(synthetic_dataset_from_samples: SyntheticAnomalyDataset) -> None: """Test if the synthetic dataset is instantiated correctly from samples df.""" assert all(Path(path).exists() for path in synthetic_dataset_from_samples.samples.image_path) assert all(Path(path).exists() for path in synthetic_dataset_from_samples.samples.mask_path) - def test_copy(self, synthetic_dataset: SyntheticAnomalyDataset) -> None: + @staticmethod + def test_copy(synthetic_dataset: SyntheticAnomalyDataset) -> None: """Tests if the dataset is copied correctly, and files still exist after original instance is deleted.""" synthetic_dataset_cp = copy(synthetic_dataset) assert all(synthetic_dataset.samples == synthetic_dataset_cp.samples) del synthetic_dataset assert synthetic_dataset_cp.root.exists() - def test_cleanup(self, folder_dataset: FolderDataset) -> None: + @staticmethod + def test_cleanup(folder_dataset: FolderDataset) -> None: """Tests if the temporary directory is cleaned up when the instance is deleted.""" synthetic_dataset = SyntheticAnomalyDataset.from_dataset(folder_dataset) root = synthetic_dataset.root diff --git a/tests/unit/data/utils/test_tiler.py b/tests/unit/data/utils/test_tiler.py index 51fbbd6562..5ed3fc8427 100644 --- a/tests/unit/data/utils/test_tiler.py +++ b/tests/unit/data/utils/test_tiler.py @@ -1,5 +1,8 @@ """Image Tiling Tests.""" +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + import pytest import torch from omegaconf import ListConfig diff --git a/tests/unit/data/video/test_avenue.py b/tests/unit/data/video/test_avenue.py index d5dab87946..6c098b5026 100644 --- a/tests/unit/data/video/test_avenue.py +++ b/tests/unit/data/video/test_avenue.py @@ -16,12 +16,14 @@ class TestAvenue(_TestAnomalibVideoDatamodule): """Avenue Datamodule Unit Tests.""" @pytest.fixture() - def clip_length_in_frames(self) -> int: + @staticmethod + def clip_length_in_frames() -> int: """Return the number of frames in each clip.""" return 2 @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType, clip_length_in_frames: int) -> Avenue: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: int) -> Avenue: """Create and return a Avenue datamodule.""" _datamodule = Avenue( root=dataset_path / "avenue", @@ -40,6 +42,7 @@ def datamodule(self, dataset_path: Path, task_type: TaskType, clip_length_in_fra return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" return "configs/data/avenue.yaml" diff --git a/tests/unit/data/video/test_shanghaitech.py b/tests/unit/data/video/test_shanghaitech.py index ec7a6cbc9f..1ebbc2c537 100644 --- a/tests/unit/data/video/test_shanghaitech.py +++ b/tests/unit/data/video/test_shanghaitech.py @@ -16,12 +16,14 @@ class TestShanghaiTech(_TestAnomalibVideoDatamodule): """ShanghaiTech Datamodule Unit Tests.""" @pytest.fixture() - def clip_length_in_frames(self) -> int: + @staticmethod + def clip_length_in_frames() -> int: """Return the number of frames in each clip.""" return 2 @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType, clip_length_in_frames: int) -> ShanghaiTech: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: int) -> ShanghaiTech: """Create and return a Shanghai datamodule.""" _datamodule = ShanghaiTech( root=dataset_path / "shanghaitech", @@ -40,6 +42,7 @@ def datamodule(self, dataset_path: Path, task_type: TaskType, clip_length_in_fra return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" - return "configs/data/shanghaitec.yaml" + return "configs/data/shanghaitech.yaml" diff --git a/tests/unit/data/video/test_ucsdped.py b/tests/unit/data/video/test_ucsdped.py index 55857addc2..64411bfc84 100644 --- a/tests/unit/data/video/test_ucsdped.py +++ b/tests/unit/data/video/test_ucsdped.py @@ -16,12 +16,14 @@ class TestUCSDped(_TestAnomalibVideoDatamodule): """UCSDped Datamodule Unit Tests.""" @pytest.fixture() - def clip_length_in_frames(self) -> int: + @staticmethod + def clip_length_in_frames() -> int: """Return the number of frames in each clip.""" return 2 @pytest.fixture() - def datamodule(self, dataset_path: Path, task_type: TaskType, clip_length_in_frames: int) -> UCSDped: + @staticmethod + def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: int) -> UCSDped: """Create and return a UCSDped datamodule.""" _datamodule = UCSDped( root=dataset_path / "ucsdped", @@ -39,6 +41,7 @@ def datamodule(self, dataset_path: Path, task_type: TaskType, clip_length_in_fra return _datamodule @pytest.fixture() - def fxt_data_config_path(self) -> str: + @staticmethod + def fxt_data_config_path() -> str: """Return the path to the test data config.""" return "configs/data/ucsd_ped.yaml" diff --git a/tests/unit/engine/test_engine.py b/tests/unit/engine/test_engine.py index 5f7e0fd2a2..412268cfd5 100644 --- a/tests/unit/engine/test_engine.py +++ b/tests/unit/engine/test_engine.py @@ -18,7 +18,8 @@ class TestEngine: """Test Engine.""" @pytest.fixture() - def fxt_full_config_path(self, tmp_path: Path) -> Path: + @staticmethod + def fxt_full_config_path(tmp_path: Path) -> Path: """Fixture full configuration examples.""" config_str = """ seed_everything: true @@ -118,7 +119,8 @@ def fxt_full_config_path(self, tmp_path: Path) -> Path: yaml.dump(config_dict, file) return config_file - def test_from_config(self, fxt_full_config_path: Path) -> None: + @staticmethod + def test_from_config(fxt_full_config_path: Path) -> None: """Test Engine.from_config.""" with pytest.raises(FileNotFoundError): Engine.from_config(config_path="wrong_configs.yaml") diff --git a/tests/unit/engine/test_setup_transform.py b/tests/unit/engine/test_setup_transform.py index 47255aba98..f1a7ce9ee7 100644 --- a/tests/unit/engine/test_setup_transform.py +++ b/tests/unit/engine/test_setup_transform.py @@ -41,17 +41,20 @@ def __init__(self) -> None: super().__init__() self.model = torch.nn.Linear(10, 10) - def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform: + @staticmethod + def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform: """Return a Resize transform.""" if image_size is None: image_size = (256, 256) return Resize(image_size) - def trainer_arguments(self) -> dict: + @staticmethod + def trainer_arguments() -> dict: """Return an empty dictionary.""" return {} - def learning_type(self) -> LearningType: + @staticmethod + def learning_type() -> LearningType: """Return the learning type.""" return LearningType.ZERO_SHOT @@ -107,7 +110,8 @@ class TestSetupTransform: """Tests for the `_setup_transform` method of the Anomalib Engine.""" # test update single dataloader - def test_single_dataloader_default_transform(self) -> None: + @staticmethod + def test_single_dataloader_default_transform() -> None: """Tests if the default model transform is used when no transform is passed to the dataloader.""" dataset = DummyDataset() dataloader = DataLoader(dataset, batch_size=1) @@ -119,7 +123,8 @@ def test_single_dataloader_default_transform(self) -> None: assert dataset.transform is not None # test update multiple dataloaders - def test_multiple_dataloaders_default_transform(self) -> None: + @staticmethod + def test_multiple_dataloaders_default_transform() -> None: """Tests if the default model transform is used when no transform is passed to the dataloader.""" dataset = DummyDataset() dataloader = DataLoader(dataset, batch_size=1) @@ -130,7 +135,8 @@ def test_multiple_dataloaders_default_transform(self) -> None: # after the setup_transform is called, the dataset should have the default transform from the model assert dataset.transform is not None - def test_single_dataloader_custom_transform(self) -> None: + @staticmethod + def test_single_dataloader_custom_transform() -> None: """Tests if the user-specified transform is used when passed to the dataloader.""" transform = Transform() dataset = DummyDataset(transform=transform) @@ -143,7 +149,8 @@ def test_single_dataloader_custom_transform(self) -> None: assert model.transform == transform # test if the user-specified transform is used when passed to the datamodule - def test_custom_transform(self) -> None: + @staticmethod + def test_custom_transform() -> None: """Tests if the user-specified transform is used when passed to the datamodule.""" transform = Transform() datamodule = DummyDataModule(transform=transform) @@ -157,7 +164,8 @@ def test_custom_transform(self) -> None: assert model.transform == transform # test if the user-specified transform is used when passed to the datamodule - def test_custom_train_transform(self) -> None: + @staticmethod + def test_custom_train_transform() -> None: """Tests if the user-specified transform is used when passed to the datamodule as train_transform.""" model = DummyModel() transform = Transform() @@ -173,7 +181,8 @@ def test_custom_train_transform(self) -> None: assert model.transform is not None # test if the user-specified transform is used when passed to the datamodule - def test_custom_eval_transform(self) -> None: + @staticmethod + def test_custom_eval_transform() -> None: """Tests if the user-specified transform is used when passed to the datamodule as eval_transform.""" model = DummyModel() transform = Transform() @@ -188,7 +197,8 @@ def test_custom_eval_transform(self) -> None: assert model.transform == transform # test update datamodule - def test_datamodule_default_transform(self) -> None: + @staticmethod + def test_datamodule_default_transform() -> None: """Tests if the default model transform is used when no transform is passed to the datamodule.""" datamodule = DummyDataModule() model = DummyModel() @@ -197,7 +207,8 @@ def test_datamodule_default_transform(self) -> None: assert isinstance(model.transform, Transform) # test if image size is taken from datamodule - def test_datamodule_image_size(self) -> None: + @staticmethod + def test_datamodule_image_size() -> None: """Tests if the image size that is passed to the datamodule overwrites the default size from the model.""" datamodule = DummyDataModule(image_size=(100, 100)) model = DummyModel() @@ -206,14 +217,16 @@ def test_datamodule_image_size(self) -> None: assert isinstance(model.transform, Resize) assert model.transform.size == [100, 100] - def test_transform_from_checkpoint(self, checkpoint_path: Path) -> None: + @staticmethod + def test_transform_from_checkpoint(checkpoint_path: Path) -> None: """Tests if the transform from the checkpoint is used.""" model = DummyModel() Engine._setup_transform(model, ckpt_path=checkpoint_path) # noqa: SLF001 assert isinstance(model.transform, Resize) assert model.transform.size == [50, 50] - def test_precendence_datamodule(self, checkpoint_path: Path) -> None: + @staticmethod + def test_precendence_datamodule(checkpoint_path: Path) -> None: """Tests if transform from the datamodule goes first if both checkpoint and datamodule are provided.""" transform = Transform() datamodule = DummyDataModule(transform=transform) @@ -221,7 +234,8 @@ def test_precendence_datamodule(self, checkpoint_path: Path) -> None: Engine._setup_transform(model, ckpt_path=checkpoint_path, datamodule=datamodule) # noqa: SLF001 assert model.transform == transform - def test_transform_already_assigned(self) -> None: + @staticmethod + def test_transform_already_assigned() -> None: """Tests if the transform from the model is used when the model already has a transform assigned.""" transform = Transform() model = DummyModel() diff --git a/tests/unit/metrics/aupro/aupro_reference.py b/tests/unit/metrics/aupro/aupro_reference.py index df217c817d..f1d1d085e9 100644 --- a/tests/unit/metrics/aupro/aupro_reference.py +++ b/tests/unit/metrics/aupro/aupro_reference.py @@ -1,5 +1,3 @@ -# REMARK: CODE WAS TAKEN FROM https://github.com/eliahuhorwitz/3D-ADS/blob/main/utils/au_pro_util.py - """Utils for testing AUPRO metric. Code based on the official MVTec 3D-AD evaluation code found at @@ -9,6 +7,11 @@ The PRO curve can also be integrated up to a constant integration limit. """ +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +# Original code was taken from https://github.com/eliahuhorwitz/3D-ADS/blob/main/utils/au_pro_util.py + import logging from bisect import bisect diff --git a/tests/unit/metrics/pimo/__init__.py b/tests/unit/metrics/pimo/__init__.py new file mode 100644 index 0000000000..555d67a102 --- /dev/null +++ b/tests/unit/metrics/pimo/__init__.py @@ -0,0 +1,8 @@ +"""Per-Image Metrics Tests.""" + +# Original Code +# https://github.com/jpcbertoldo/aupimo +# +# Modified +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 diff --git a/tests/unit/metrics/pimo/test_binary_classification_curve.py b/tests/unit/metrics/pimo/test_binary_classification_curve.py new file mode 100644 index 0000000000..5459d08a14 --- /dev/null +++ b/tests/unit/metrics/pimo/test_binary_classification_curve.py @@ -0,0 +1,423 @@ +"""Tests for per-image binary classification curves using numpy version.""" + +# Original Code +# https://github.com/jpcbertoldo/aupimo +# +# Modified +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +# ruff: noqa: SLF001, PT011 + +import pytest +import torch + +from anomalib.metrics.pimo.binary_classification_curve import ( + _binary_classification_curve, + binary_classification_curve, + per_image_fpr, + per_image_tpr, + threshold_and_binary_classification_curve, +) + + +def pytest_generate_tests(metafunc: pytest.Metafunc) -> None: + """Generate test cases.""" + pred = torch.arange(1, 5, dtype=torch.float32) + thresholds = torch.arange(1, 5, dtype=torch.float32) + + gt_norm = torch.zeros(4).to(bool) + gt_anom = torch.concatenate([torch.zeros(2), torch.ones(2)]).to(bool) + + # in the case where thresholds are all unique values in the predictions + expected_norm = torch.stack( + [ + torch.tensor([[0, 4], [0, 0]]), + torch.tensor([[1, 3], [0, 0]]), + torch.tensor([[2, 2], [0, 0]]), + torch.tensor([[3, 1], [0, 0]]), + ], + axis=0, + ).to(int) + expected_anom = torch.stack( + [ + torch.tensor([[0, 2], [0, 2]]), + torch.tensor([[1, 1], [0, 2]]), + torch.tensor([[2, 0], [0, 2]]), + torch.tensor([[2, 0], [1, 1]]), + ], + axis=0, + ).to(int) + + expected_tprs_norm = torch.tensor([torch.nan, torch.nan, torch.nan, torch.nan]) + expected_tprs_anom = torch.tensor([1.0, 1.0, 1.0, 0.5]) + expected_tprs = torch.stack([expected_tprs_anom, expected_tprs_norm], axis=0).to(torch.float64) + + expected_fprs_norm = torch.tensor([1.0, 0.75, 0.5, 0.25]) + expected_fprs_anom = torch.tensor([1.0, 0.5, 0.0, 0.0]) + expected_fprs = torch.stack([expected_fprs_anom, expected_fprs_norm], axis=0).to(torch.float64) + + # in the case where all thresholds are higher than the highest prediction + expected_norm_thresholds_too_high = torch.stack( + [ + torch.tensor([[4, 0], [0, 0]]), + torch.tensor([[4, 0], [0, 0]]), + torch.tensor([[4, 0], [0, 0]]), + torch.tensor([[4, 0], [0, 0]]), + ], + axis=0, + ).to(int) + expected_anom_thresholds_too_high = torch.stack( + [ + torch.tensor([[2, 0], [2, 0]]), + torch.tensor([[2, 0], [2, 0]]), + torch.tensor([[2, 0], [2, 0]]), + torch.tensor([[2, 0], [2, 0]]), + ], + axis=0, + ).to(int) + + # in the case where all thresholds are lower than the lowest prediction + expected_norm_thresholds_too_low = torch.stack( + [ + torch.tensor([[0, 4], [0, 0]]), + torch.tensor([[0, 4], [0, 0]]), + torch.tensor([[0, 4], [0, 0]]), + torch.tensor([[0, 4], [0, 0]]), + ], + axis=0, + ).to(int) + expected_anom_thresholds_too_low = torch.stack( + [ + torch.tensor([[0, 2], [0, 2]]), + torch.tensor([[0, 2], [0, 2]]), + torch.tensor([[0, 2], [0, 2]]), + torch.tensor([[0, 2], [0, 2]]), + ], + axis=0, + ).to(int) + + if metafunc.function is test__binclf_one_curve: + metafunc.parametrize( + argnames=("pred", "gt", "thresholds", "expected"), + argvalues=[ + (pred, gt_anom, thresholds[:3], expected_anom[:3]), + (pred, gt_anom, thresholds, expected_anom), + (pred, gt_norm, thresholds, expected_norm), + (pred, gt_norm, 10 * thresholds, expected_norm_thresholds_too_high), + (pred, gt_anom, 10 * thresholds, expected_anom_thresholds_too_high), + (pred, gt_norm, 0.001 * thresholds, expected_norm_thresholds_too_low), + (pred, gt_anom, 0.001 * thresholds, expected_anom_thresholds_too_low), + ], + ) + + preds = torch.stack([pred, pred], axis=0) + gts = torch.stack([gt_anom, gt_norm], axis=0) + binclf_curves = torch.stack([expected_anom, expected_norm], axis=0) + binclf_curves_thresholds_too_high = torch.stack( + [expected_anom_thresholds_too_high, expected_norm_thresholds_too_high], + axis=0, + ) + binclf_curves_thresholds_too_low = torch.stack( + [expected_anom_thresholds_too_low, expected_norm_thresholds_too_low], + axis=0, + ) + + if metafunc.function is test__binclf_multiple_curves: + metafunc.parametrize( + argnames=("preds", "gts", "thresholds", "expecteds"), + argvalues=[ + (preds, gts, thresholds[:3], binclf_curves[:, :3]), + (preds, gts, thresholds, binclf_curves), + ], + ) + + if metafunc.function is test_binclf_multiple_curves: + metafunc.parametrize( + argnames=( + "preds", + "gts", + "thresholds", + "expected_binclf_curves", + ), + argvalues=[ + (preds[:1], gts[:1], thresholds, binclf_curves[:1]), + (preds, gts, thresholds, binclf_curves), + (10 * preds, gts, 10 * thresholds, binclf_curves), + ], + ) + + if metafunc.function is test_binclf_multiple_curves_validations: + metafunc.parametrize( + argnames=("args", "kwargs", "exception"), + argvalues=[ + # `scores` and `gts` must be 2D + ([preds.reshape(2, 2, 2), gts, thresholds], {}, ValueError), + ([preds, gts.flatten(), thresholds], {}, ValueError), + # `thresholds` must be 1D + ([preds, gts, thresholds.reshape(2, 2)], {}, ValueError), + # `scores` and `gts` must have the same shape + ([preds, gts[:1], thresholds], {}, ValueError), + ([preds[:, :2], gts, thresholds], {}, ValueError), + # `scores` be of type float + ([preds.to(int), gts, thresholds], {}, TypeError), + # `gts` be of type bool + ([preds, gts.to(int), thresholds], {}, TypeError), + # `thresholds` be of type float + ([preds, gts, thresholds.to(int)], {}, TypeError), + # `thresholds` must be sorted in ascending order + ([preds, gts, torch.flip(thresholds, dims=[0])], {}, ValueError), + ([preds, gts, torch.concatenate([thresholds[-2:], thresholds[:2]])], {}, ValueError), + # `thresholds` must be unique + ([preds, gts, torch.sort(torch.concatenate([thresholds, thresholds]))[0]], {}, ValueError), + ], + ) + + # the following tests are for `per_image_binclf_curve()`, which expects + # inputs in image spatial format, i.e. (height, width) + preds = preds.reshape(2, 2, 2) + gts = gts.reshape(2, 2, 2) + + per_image_binclf_curves_argvalues = [ + # `thresholds_choice` = "given" + ( + preds, + gts, + "given", + thresholds, + None, + thresholds, + binclf_curves, + ), + ( + preds, + gts, + "given", + 10 * thresholds, + 2, + 10 * thresholds, + binclf_curves_thresholds_too_high, + ), + ( + preds, + gts, + "given", + 0.01 * thresholds, + None, + 0.01 * thresholds, + binclf_curves_thresholds_too_low, + ), + # `thresholds_choice` = 'minmax-linspace'" + ( + preds, + gts, + "minmax-linspace", + None, + len(thresholds), + thresholds, + binclf_curves, + ), + ( + 2 * preds, + gts.to(int), # this is ok + "minmax-linspace", + None, + len(thresholds), + 2 * thresholds, + binclf_curves, + ), + ] + + if metafunc.function is test_per_image_binclf_curve: + metafunc.parametrize( + argnames=( + "anomaly_maps", + "masks", + "threshold_choice", + "thresholds", + "num_thresholds", + "expected_thresholds", + "expected_binclf_curves", + ), + argvalues=per_image_binclf_curves_argvalues, + ) + + if metafunc.function is test_per_image_binclf_curve_validations: + metafunc.parametrize( + argnames=("args", "exception"), + argvalues=[ + # `scores` and `gts` must be 3D + ([preds.reshape(2, 2, 2, 1), gts], ValueError), + ([preds, gts.flatten()], ValueError), + # `scores` and `gts` must have the same shape + ([preds, gts[:1]], ValueError), + ([preds[:, :1], gts], ValueError), + # `scores` be of type float + ([preds.to(int), gts], TypeError), + # `gts` be of type bool or int + ([preds, gts.to(float)], TypeError), + # `thresholds` be of type float + ([preds, gts, thresholds.to(int)], TypeError), + ], + ) + metafunc.parametrize( + argnames=("kwargs",), + argvalues=[ + ( + { + "threshold_choice": "minmax-linspace", + "thresholds": None, + "num_thresholds": len(thresholds), + }, + ), + ], + ) + + # same as above but testing other validations + if metafunc.function is test_per_image_binclf_curve_validations_alt: + metafunc.parametrize( + argnames=("args", "kwargs", "exception"), + argvalues=[ + # invalid `thresholds_choice` + ( + [preds, gts], + {"threshold_choice": "glfrb", "thresholds": thresholds, "num_thresholds": None}, + ValueError, + ), + ], + ) + + if metafunc.function is test_rate_metrics: + metafunc.parametrize( + argnames=("binclf_curves", "expected_fprs", "expected_tprs"), + argvalues=[ + (binclf_curves, expected_fprs, expected_tprs), + (10 * binclf_curves, expected_fprs, expected_tprs), + ], + ) + + +# ================================================================================================== +# LOW-LEVEL FUNCTIONS (PYTHON) + + +def test__binclf_one_curve( + pred: torch.Tensor, + gt: torch.Tensor, + thresholds: torch.Tensor, + expected: torch.Tensor, +) -> None: + """Test if `_binclf_one_curve()` returns the expected values.""" + computed = _binary_classification_curve(pred, gt, thresholds) + assert computed.shape == (thresholds.numel(), 2, 2) + assert (computed == expected.numpy()).all() + + +def test__binclf_multiple_curves( + preds: torch.Tensor, + gts: torch.Tensor, + thresholds: torch.Tensor, + expecteds: torch.Tensor, +) -> None: + """Test if `_binclf_multiple_curves()` returns the expected values.""" + computed = binary_classification_curve(preds, gts, thresholds) + assert computed.shape == (preds.shape[0], thresholds.numel(), 2, 2) + assert (computed == expecteds).all() + + +# ================================================================================================== +# API FUNCTIONS (NUMPY) + + +def test_binclf_multiple_curves( + preds: torch.Tensor, + gts: torch.Tensor, + thresholds: torch.Tensor, + expected_binclf_curves: torch.Tensor, +) -> None: + """Test if `binclf_multiple_curves()` returns the expected values.""" + computed = binary_classification_curve( + preds, + gts, + thresholds, + ) + assert computed.shape == expected_binclf_curves.shape + assert (computed == expected_binclf_curves).all() + + # it's ok to have the threhsholds beyond the range of the preds + binary_classification_curve(preds, gts, 2 * thresholds) + + # or inside the bounds without reaching them + binary_classification_curve(preds, gts, 0.5 * thresholds) + + # it's also ok to have more thresholds than unique values in the preds + # add the values in between the thresholds + thresholds_unncessary = 0.5 * (thresholds[:-1] + thresholds[1:]) + thresholds_unncessary = torch.concatenate([thresholds_unncessary, thresholds]) + thresholds_unncessary = torch.sort(thresholds_unncessary)[0] + binary_classification_curve(preds, gts, thresholds_unncessary) + + # or less + binary_classification_curve(preds, gts, thresholds[1:3]) + + +def test_binclf_multiple_curves_validations(args: list, kwargs: dict, exception: Exception) -> None: + """Test if `_binclf_multiple_curves_python()` raises the expected errors.""" + with pytest.raises(exception): + binary_classification_curve(*args, **kwargs) + + +def test_per_image_binclf_curve( + anomaly_maps: torch.Tensor, + masks: torch.Tensor, + threshold_choice: str, + thresholds: torch.Tensor | None, + num_thresholds: int | None, + expected_thresholds: torch.Tensor, + expected_binclf_curves: torch.Tensor, +) -> None: + """Test if `per_image_binclf_curve()` returns the expected values.""" + computed_thresholds, computed_binclf_curves = threshold_and_binary_classification_curve( + anomaly_maps, + masks, + threshold_choice=threshold_choice, + thresholds=thresholds, + num_thresholds=num_thresholds, + ) + + # thresholds + assert computed_thresholds.shape == expected_thresholds.shape + assert computed_thresholds.dtype == computed_thresholds.dtype + assert (computed_thresholds == expected_thresholds).all() + + # binclf_curves + assert computed_binclf_curves.shape == expected_binclf_curves.shape + assert computed_binclf_curves.dtype == expected_binclf_curves.dtype + assert (computed_binclf_curves == expected_binclf_curves).all() + + +def test_per_image_binclf_curve_validations(args: list, kwargs: dict, exception: Exception) -> None: + """Test if `per_image_binclf_curve()` raises the expected errors.""" + with pytest.raises(exception): + threshold_and_binary_classification_curve(*args, **kwargs) + + +def test_per_image_binclf_curve_validations_alt(args: list, kwargs: dict, exception: Exception) -> None: + """Test if `per_image_binclf_curve()` raises the expected errors.""" + test_per_image_binclf_curve_validations(args, kwargs, exception) + + +def test_rate_metrics( + binclf_curves: torch.Tensor, + expected_fprs: torch.Tensor, + expected_tprs: torch.Tensor, +) -> None: + """Test if rate metrics are computed correctly.""" + tprs = per_image_tpr(binclf_curves) + fprs = per_image_fpr(binclf_curves) + + assert tprs.shape == expected_tprs.shape + assert fprs.shape == expected_fprs.shape + + assert torch.allclose(tprs, expected_tprs, equal_nan=True) + assert torch.allclose(fprs, expected_fprs, equal_nan=True) diff --git a/tests/unit/metrics/pimo/test_pimo.py b/tests/unit/metrics/pimo/test_pimo.py new file mode 100644 index 0000000000..81bafe4c8e --- /dev/null +++ b/tests/unit/metrics/pimo/test_pimo.py @@ -0,0 +1,368 @@ +"""Test `anomalib.metrics.per_image.functional`.""" + +# Original Code +# https://github.com/jpcbertoldo/aupimo +# +# Modified +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import logging + +import pytest +import torch +from torch import Tensor + +from anomalib.metrics.pimo import AUPIMOResult, PIMOResult, functional, pimo + + +def pytest_generate_tests(metafunc: pytest.Metafunc) -> None: + """Generate tests for all functions in this module. + + All functions are parametrized with the same setting: 1 normal and 2 anomalous images. + The anomaly maps are the same for all functions, but the masks are different. + """ + expected_thresholds = torch.arange(1, 7 + 1, dtype=torch.float32) + shape = (1000, 1000) # (H, W), 1 million pixels + + # --- normal --- + # histogram of scores: + # value: 7 6 5 4 3 2 1 + # count: 1 9 90 900 9k 90k 900k + # cumsum: 1 10 100 1k 10k 100k 1M + pred_norm = torch.ones(1_000_000, dtype=torch.float32) + pred_norm[:100_000] += 1 + pred_norm[:10_000] += 1 + pred_norm[:1_000] += 1 + pred_norm[:100] += 1 + pred_norm[:10] += 1 + pred_norm[:1] += 1 + pred_norm = pred_norm.reshape(shape) + mask_norm = torch.zeros_like(pred_norm, dtype=torch.int32) + + expected_fpr_norm = torch.tensor([1.0, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6], dtype=torch.float64) + expected_tpr_norm = torch.full((7,), torch.nan, dtype=torch.float64) + + # --- anomalous --- + pred_anom1 = pred_norm.clone() + mask_anom1 = torch.ones_like(pred_anom1, dtype=torch.int32) + expected_tpr_anom1 = expected_fpr_norm.clone() + + # only the first 100_000 pixels are anomalous + # which corresponds to the first 100_000 highest scores (2 to 7) + pred_anom2 = pred_norm.clone() + mask_anom2 = torch.concatenate([torch.ones(100_000), torch.zeros(900_000)]).reshape(shape).to(torch.int32) + expected_tpr_anom2 = (10 * expected_fpr_norm).clip(0, 1) + + anomaly_maps = torch.stack([pred_norm, pred_anom1, pred_anom2], axis=0) + masks = torch.stack([mask_norm, mask_anom1, mask_anom2], axis=0) + + expected_shared_fpr = expected_fpr_norm + expected_per_image_tprs = torch.stack([expected_tpr_norm, expected_tpr_anom1, expected_tpr_anom2], axis=0) + expected_image_classes = torch.tensor([0, 1, 1], dtype=torch.int32) + + if metafunc.function is test_pimo or metafunc.function is test_aupimo_values: + argvalues_tensors = [ + ( + anomaly_maps, + masks, + expected_thresholds, + expected_shared_fpr, + expected_per_image_tprs, + expected_image_classes, + ), + ( + 10 * anomaly_maps, + masks, + 10 * expected_thresholds, + expected_shared_fpr, + expected_per_image_tprs, + expected_image_classes, + ), + ] + metafunc.parametrize( + argnames=( + "anomaly_maps", + "masks", + "expected_thresholds", + "expected_shared_fpr", + "expected_per_image_tprs", + "expected_image_classes", + ), + argvalues=argvalues_tensors, + ) + + if metafunc.function is test_aupimo_values: + argvalues_tensors = [ + ( + (1e-1, 1.0), + torch.tensor( + [ + torch.nan, + # recall: trapezium area = (a + b) * h / 2 + (0.10 + 1.0) * 1 / 2, + (1.0 + 1.0) * 1 / 2, + ], + dtype=torch.float64, + ), + ), + ( + (1e-3, 1e-1), + torch.tensor( + [ + torch.nan, + # average of two trapezium areas / 2 (normalizing factor) + (((1e-3 + 1e-2) * 1 / 2) + ((1e-2 + 1e-1) * 1 / 2)) / 2, + (((1e-2 + 1e-1) * 1 / 2) + ((1e-1 + 1.0) * 1 / 2)) / 2, + ], + dtype=torch.float64, + ), + ), + ( + (1e-5, 1e-4), + torch.tensor( + [ + torch.nan, + (1e-5 + 1e-4) * 1 / 2, + (1e-4 + 1e-3) * 1 / 2, + ], + dtype=torch.float64, + ), + ), + ] + metafunc.parametrize( + argnames=( + "fpr_bounds", + "expected_aupimos", # trapezoid surfaces + ), + argvalues=argvalues_tensors, + ) + + if metafunc.function is test_aupimo_edge: + metafunc.parametrize( + argnames=( + "anomaly_maps", + "masks", + ), + argvalues=[ + ( + anomaly_maps, + masks, + ), + ( + 10 * anomaly_maps, + masks, + ), + ], + ) + metafunc.parametrize( + argnames=("fpr_bounds",), + argvalues=[ + ((1e-1, 1.0),), + ((1e-3, 1e-2),), + ((1e-5, 1e-4),), + (None,), + ], + ) + + +def _do_test_pimo_outputs( + thresholds: Tensor, + shared_fpr: Tensor, + per_image_tprs: Tensor, + image_classes: Tensor, + expected_thresholds: Tensor, + expected_shared_fpr: Tensor, + expected_per_image_tprs: Tensor, + expected_image_classes: Tensor, +) -> None: + """Test if the outputs of any of the PIMO interfaces are correct.""" + assert isinstance(shared_fpr, Tensor) + assert isinstance(per_image_tprs, Tensor) + assert isinstance(image_classes, Tensor) + assert isinstance(expected_thresholds, Tensor) + assert isinstance(expected_shared_fpr, Tensor) + assert isinstance(expected_per_image_tprs, Tensor) + assert isinstance(expected_image_classes, Tensor) + allclose = torch.allclose + + assert thresholds.ndim == 1 + assert shared_fpr.ndim == 1 + assert per_image_tprs.ndim == 2 + assert tuple(image_classes.shape) == (3,) + + assert allclose(thresholds, expected_thresholds) + assert allclose(shared_fpr, expected_shared_fpr) + assert allclose(per_image_tprs, expected_per_image_tprs, equal_nan=True) + assert (image_classes == expected_image_classes).all() + + +def test_pimo( + anomaly_maps: Tensor, + masks: Tensor, + expected_thresholds: Tensor, + expected_shared_fpr: Tensor, + expected_per_image_tprs: Tensor, + expected_image_classes: Tensor, +) -> None: + """Test if `pimo()` returns the expected values.""" + + def do_assertions(pimo_result: PIMOResult) -> None: + thresholds = pimo_result.thresholds + shared_fpr = pimo_result.shared_fpr + per_image_tprs = pimo_result.per_image_tprs + image_classes = pimo_result.image_classes + _do_test_pimo_outputs( + thresholds, + shared_fpr, + per_image_tprs, + image_classes, + expected_thresholds, + expected_shared_fpr, + expected_per_image_tprs, + expected_image_classes, + ) + + # metric interface + metric = pimo.PIMO( + num_thresholds=7, + ) + metric.update(anomaly_maps, masks) + pimo_result = metric.compute() + do_assertions(pimo_result) + + +def _do_test_aupimo_outputs( + thresholds: Tensor, + shared_fpr: Tensor, + per_image_tprs: Tensor, + image_classes: Tensor, + aupimos: Tensor, + expected_thresholds: Tensor, + expected_shared_fpr: Tensor, + expected_per_image_tprs: Tensor, + expected_image_classes: Tensor, + expected_aupimos: Tensor, +) -> None: + _do_test_pimo_outputs( + thresholds, + shared_fpr, + per_image_tprs, + image_classes, + expected_thresholds, + expected_shared_fpr, + expected_per_image_tprs, + expected_image_classes, + ) + assert isinstance(aupimos, Tensor) + assert isinstance(expected_aupimos, Tensor) + allclose = torch.allclose + assert tuple(aupimos.shape) == (3,) + assert allclose(aupimos, expected_aupimos, equal_nan=True) + + +def test_aupimo_values( + anomaly_maps: torch.Tensor, + masks: torch.Tensor, + fpr_bounds: tuple[float, float], + expected_thresholds: torch.Tensor, + expected_shared_fpr: torch.Tensor, + expected_per_image_tprs: torch.Tensor, + expected_image_classes: torch.Tensor, + expected_aupimos: torch.Tensor, +) -> None: + """Test if `aupimo()` returns the expected values.""" + + def do_assertions(pimo_result: PIMOResult, aupimo_result: AUPIMOResult) -> None: + # test metadata + assert aupimo_result.fpr_bounds == fpr_bounds + # recall: this one is not the same as the number of thresholds in the curve + # this is the number of thresholds used to compute the integral in `aupimo()` + # always less because of the integration bounds + assert aupimo_result.num_thresholds < 7 + + # test data + # from pimo result + thresholds = pimo_result.thresholds + shared_fpr = pimo_result.shared_fpr + per_image_tprs = pimo_result.per_image_tprs + image_classes = pimo_result.image_classes + # from aupimo result + aupimos = aupimo_result.aupimos + _do_test_aupimo_outputs( + thresholds, + shared_fpr, + per_image_tprs, + image_classes, + aupimos, + expected_thresholds, + expected_shared_fpr, + expected_per_image_tprs, + expected_image_classes, + expected_aupimos, + ) + thresh_lower_bound = aupimo_result.thresh_lower_bound + thresh_upper_bound = aupimo_result.thresh_upper_bound + assert anomaly_maps.min() <= thresh_lower_bound < thresh_upper_bound <= anomaly_maps.max() + + # metric interface + metric = pimo.AUPIMO( + num_thresholds=7, + fpr_bounds=fpr_bounds, + return_average=False, + force=True, + ) + metric.update(anomaly_maps, masks) + pimo_result_from_metric, aupimo_result_from_metric = metric.compute() + do_assertions(pimo_result_from_metric, aupimo_result_from_metric) + + # metric interface + metric = pimo.AUPIMO( + num_thresholds=7, + fpr_bounds=fpr_bounds, + return_average=True, # only return the average AUPIMO + force=True, + ) + metric.update(anomaly_maps, masks) + metric.compute() + + +def test_aupimo_edge( + anomaly_maps: torch.Tensor, + masks: torch.Tensor, + fpr_bounds: tuple[float, float], + caplog: pytest.LogCaptureFixture, +) -> None: + """Test some edge cases.""" + # None is the case of testing the default bounds + fpr_bounds = {"fpr_bounds": fpr_bounds} if fpr_bounds is not None else {} + + # not enough points on the curve + # 10 thresholds / 6 decades = 1.6 thresholds per decade < 3 + with pytest.raises(RuntimeError): # force=False --> raise error + functional.aupimo_scores( + anomaly_maps, + masks, + num_thresholds=10, + force=False, + **fpr_bounds, + ) + + with caplog.at_level(logging.WARNING): # force=True --> warn + functional.aupimo_scores( + anomaly_maps, + masks, + num_thresholds=10, + force=True, + **fpr_bounds, + ) + assert "Computation was forced!" in caplog.text + + # default number of points on the curve (300k thresholds) should be enough + torch.manual_seed(42) + functional.aupimo_scores( + anomaly_maps * torch.FloatTensor(anomaly_maps.shape).uniform_(1.0, 1.1), + masks, + force=False, + **fpr_bounds, + ) diff --git a/tests/unit/metrics/threshold/test_threshold.py b/tests/unit/metrics/threshold/test_threshold.py new file mode 100644 index 0000000000..918e850c23 --- /dev/null +++ b/tests/unit/metrics/threshold/test_threshold.py @@ -0,0 +1,60 @@ +"""Test Threshold metric.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import pytest +from torchmetrics import Metric + +from anomalib.metrics.threshold import BaseThreshold, Threshold + + +class TestThreshold: + """Test cases for the Threshold class.""" + + @staticmethod + def test_threshold_abstract_methods() -> None: + """Test that Threshold class raises NotImplementedError for abstract methods.""" + threshold = Threshold() + + with pytest.raises(NotImplementedError, match="Subclass of Threshold must implement the compute method"): + threshold.compute() + + with pytest.raises(NotImplementedError, match="Subclass of Threshold must implement the update method"): + threshold.update() + + @staticmethod + def test_threshold_initialization() -> None: + """Test that Threshold can be initialized without errors.""" + threshold = Threshold() + assert isinstance(threshold, Metric) + + +class TestBaseThreshold: + """Test cases for the BaseThreshold class.""" + + @staticmethod + def test_base_threshold_deprecation_warning() -> None: + """Test that BaseThreshold class raises a DeprecationWarning.""" + with pytest.warns( + DeprecationWarning, + match="BaseThreshold is deprecated and will be removed in a future version. Use Threshold instead.", + ): + BaseThreshold() + + @staticmethod + def test_base_threshold_inheritance() -> None: + """Test that BaseThreshold inherits from Threshold.""" + base_threshold = BaseThreshold() + assert isinstance(base_threshold, Threshold) + + @staticmethod + def test_base_threshold_abstract_methods() -> None: + """Test that BaseThreshold class raises NotImplementedError for abstract methods.""" + base_threshold = BaseThreshold() + + with pytest.raises(NotImplementedError, match="Subclass of Threshold must implement the compute method"): + base_threshold.compute() + + with pytest.raises(NotImplementedError, match="Subclass of Threshold must implement the update method"): + base_threshold.update() diff --git a/tests/unit/models/components/__init__.py b/tests/unit/models/components/__init__.py index b0d0d58d06..90c8fb6953 100644 --- a/tests/unit/models/components/__init__.py +++ b/tests/unit/models/components/__init__.py @@ -1 +1,4 @@ """Test individual components.""" + +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 diff --git a/tests/unit/models/components/base/test_anomaly_module.py b/tests/unit/models/components/base/test_anomaly_module.py index 17e401cc6f..c77ab7c212 100644 --- a/tests/unit/models/components/base/test_anomaly_module.py +++ b/tests/unit/models/components/base/test_anomaly_module.py @@ -10,15 +10,22 @@ from anomalib.models.components.base import AnomalyModule +@pytest.fixture(scope="class") +def model_config_folder_path() -> str: + """Fixture that returns model config folder path.""" + return "configs/model" + + class TestAnomalyModule: """Test AnomalyModule.""" - @pytest.fixture() - def fxt_model_config_folder_path(self) -> str: - """Fixture that returns model config folder path.""" - return "configs/model" + @pytest.fixture(autouse=True) + def setup(self, model_config_folder_path: str) -> None: + """Setup test AnomalyModule.""" + self.model_config_folder_path = model_config_folder_path - def test_from_config_with_wrong_config_path(self) -> None: + @staticmethod + def test_from_config_with_wrong_config_path() -> None: """Test AnomalyModule.from_config with wrong model name.""" with pytest.raises(FileNotFoundError): AnomalyModule.from_config(config_path="wrong_configs.yaml") @@ -45,9 +52,9 @@ def test_from_config_with_wrong_config_path(self) -> None: "uflow", ], ) - def test_from_config(self, model_name: str, fxt_model_config_folder_path: str) -> None: + def test_from_config(self, model_name: str) -> None: """Test AnomalyModule.from_config.""" - config_path = Path(fxt_model_config_folder_path) / f"{model_name}.yaml" + config_path = Path(self.model_config_folder_path) / f"{model_name}.yaml" model = AnomalyModule.from_config(config_path=config_path) assert model is not None assert isinstance(model, AnomalyModule) diff --git a/tests/unit/models/components/base/test_buffer_list_mixin.py b/tests/unit/models/components/base/test_buffer_list_mixin.py index 9c573521b1..82cbaf6794 100644 --- a/tests/unit/models/components/base/test_buffer_list_mixin.py +++ b/tests/unit/models/components/base/test_buffer_list_mixin.py @@ -35,25 +35,29 @@ def module() -> BufferListModule: class TestBufferListMixin: """Test the BufferListMixin module.""" - def test_get_buffer_list(self, module: BufferListModule) -> None: + @staticmethod + def test_get_buffer_list(module: BufferListModule) -> None: """Test retrieving the tensor_list.""" assert isinstance(module.tensor_list, list) assert all(isinstance(tensor, torch.Tensor) for tensor in module.tensor_list) - def test_set_buffer_list(self, module: BufferListModule) -> None: + @staticmethod + def test_set_buffer_list(module: BufferListModule) -> None: """Test setting/updating the tensor_list.""" tensor_list = [torch.rand(3) for _ in range(3)] module.tensor_list = tensor_list assert tensor_lists_are_equal(module.tensor_list, tensor_list) - def test_buffer_list_device_placement(self, module: BufferListModule) -> None: + @staticmethod + def test_buffer_list_device_placement(module: BufferListModule) -> None: """Test if the device of the buffer list is updated with the module.""" module.cuda() assert all(tensor.is_cuda for tensor in module.tensor_list) module.cpu() assert all(tensor.is_cpu for tensor in module.tensor_list) - def test_persistent_buffer_list(self) -> None: + @staticmethod + def test_persistent_buffer_list(module: BufferListModule) -> None: """Test if the buffer_list is persistent when re-loading the state dict.""" # create a module, assign the buffer list and get the state dict module = BufferListModule() @@ -66,7 +70,8 @@ def test_persistent_buffer_list(self) -> None: # assert that the previously set buffer list has been restored assert tensor_lists_are_equal(module.tensor_list, tensor_list) - def test_non_persistent_buffer_list(self) -> None: + @staticmethod + def test_non_persistent_buffer_list(module: BufferListModule) -> None: """Test if the buffer_list is persistent when re-loading the state dict.""" # create a module, assign the buffer list and get the state dict module = BufferListModule() diff --git a/tests/unit/models/components/base/test_dynamic_buffer_mixin.py b/tests/unit/models/components/base/test_dynamic_buffer_mixin.py index 6fc108196f..5953abba03 100644 --- a/tests/unit/models/components/base/test_dynamic_buffer_mixin.py +++ b/tests/unit/models/components/base/test_dynamic_buffer_mixin.py @@ -41,18 +41,21 @@ def module() -> DynamicBufferModule: class TestDynamicBufferMixin: """Test the DynamicBufferMixin.""" - def test_get_tensor_attribute_tensor(self, module: DynamicBufferModule) -> None: + @staticmethod + def test_get_tensor_attribute_tensor(module: DynamicBufferModule) -> None: """Test the get_tensor_attribute method with a tensor field.""" tensor_attribute = module.get_tensor_attribute("tensor_attribute") assert isinstance(tensor_attribute, torch.Tensor) assert torch.equal(tensor_attribute, module.tensor_attribute) - def test_get_tensor_attribute_non_tensor(self, module: DynamicBufferModule) -> None: + @staticmethod + def test_get_tensor_attribute_non_tensor(module: DynamicBufferModule) -> None: """Test the get_tensor_attribute method with a non-tensor field.""" with pytest.raises(ValueError, match="Attribute with name 'non_tensor_attribute' is not a torch Tensor"): module.get_tensor_attribute("non_tensor_attribute") - def test_load_from_state_dict(self, module: DynamicBufferModule) -> None: + @staticmethod + def test_load_from_state_dict(module: DynamicBufferModule) -> None: """Test updating the buffers from a state_dict.""" state_dict = { "prefix_first_buffer": torch.zeros(5, 5), diff --git a/tests/unit/models/components/clustering/__init__.py b/tests/unit/models/components/clustering/__init__.py index 48f2e342e8..eedbb37347 100644 --- a/tests/unit/models/components/clustering/__init__.py +++ b/tests/unit/models/components/clustering/__init__.py @@ -1 +1,4 @@ """Tests for clustering components.""" + +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 diff --git a/tests/unit/models/components/clustering/test_gmm.py b/tests/unit/models/components/clustering/test_gmm.py index 197c3bf861..18b9de2747 100644 --- a/tests/unit/models/components/clustering/test_gmm.py +++ b/tests/unit/models/components/clustering/test_gmm.py @@ -1,5 +1,8 @@ """Unit tests for Anomalib's Gaussian Mixture Model.""" +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + import logging import torch diff --git a/tests/unit/models/components/test_blur.py b/tests/unit/models/components/test_blur.py index 61f3d79a7b..305df7e20a 100644 --- a/tests/unit/models/components/test_blur.py +++ b/tests/unit/models/components/test_blur.py @@ -1,5 +1,8 @@ """Test if our implementation produces same result as kornia.""" +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + import pytest import torch from kornia.filters import GaussianBlur2d as korniaGaussianBlur2d diff --git a/tests/unit/models/image/winclip/test_prompting.py b/tests/unit/models/image/winclip/test_prompting.py index 61b9c2956e..6c4584f0dc 100644 --- a/tests/unit/models/image/winclip/test_prompting.py +++ b/tests/unit/models/image/winclip/test_prompting.py @@ -1,24 +1,30 @@ """Unit tests for WinCLIP's compositional prompt ensemble.""" +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + from anomalib.models.image.winclip.prompting import create_prompt_ensemble class TestCreatePromptEnsemble: """Test the create_prompt_ensemble function.""" - def test_length(self) -> None: + @staticmethod + def test_length() -> None: """Test if the correct number of normal and anomalous prompts are created.""" normal_prompts, anomalous_prompts = create_prompt_ensemble("object") assert len(normal_prompts) == 147 assert len(anomalous_prompts) == 84 - def test_class_name_in_every_prompt(self) -> None: + @staticmethod + def test_class_name_in_every_prompt() -> None: """Test prompt ensemble creation.""" normal_prompts, anomalous_prompts = create_prompt_ensemble("item") assert all("item" in prompt for prompt in normal_prompts) assert all("item" in prompt for prompt in anomalous_prompts) - def test_called_without_class_name(self) -> None: + @staticmethod + def test_called_without_class_name() -> None: """Test prompt ensemble creation without class name.""" normal_prompts, anomalous_prompts = create_prompt_ensemble() assert all("object" in prompt for prompt in normal_prompts) diff --git a/tests/unit/models/image/winclip/test_torch_model.py b/tests/unit/models/image/winclip/test_torch_model.py index e36c91f0f1..0ecfd79203 100644 --- a/tests/unit/models/image/winclip/test_torch_model.py +++ b/tests/unit/models/image/winclip/test_torch_model.py @@ -12,21 +12,24 @@ class TestSetupWinClipModel: """Test the WinCLIP torch model.""" - def test_zero_shot_from_init(self) -> None: + @staticmethod + def test_zero_shot_from_init() -> None: """Test WinCLIP initialization from init method in zero-shot mode.""" model = WinClipModel(class_name="item") assert model.k_shot == 0 assert getattr(model, "text_embeddings", None) is not None - def test_zero_shot_from_setup(self) -> None: + @staticmethod + def test_zero_shot_from_setup() -> None: """Test WinCLIP initialization from setup method in zero-shot mode.""" model = WinClipModel() model.setup(class_name="item") assert model.k_shot == 0 assert getattr(model, "text_embeddings", None) is not None + @staticmethod @pytest.mark.parametrize("apply_transform", [True, False]) - def test_few_shot_from_init(self, apply_transform: bool) -> None: + def test_few_shot_from_init(apply_transform: bool) -> None: """Test WinCLIP initialization from init in few-shot mode.""" ref_images = torch.rand(2, 3, 240, 240) model = WinClipModel(class_name="item", reference_images=ref_images, apply_transform=apply_transform) @@ -34,8 +37,9 @@ def test_few_shot_from_init(self, apply_transform: bool) -> None: assert getattr(model, "text_embeddings", None) is not None assert getattr(model, "visual_embeddings", None) is not None + @staticmethod @pytest.mark.parametrize("apply_transform", [True, False]) - def test_few_shot_from_setup(self, apply_transform: bool) -> None: + def test_few_shot_from_setup(apply_transform: bool) -> None: """Test WinCLIP initialization from setup method in few-shot mode.""" ref_images = torch.rand(2, 3, 240, 240) model = WinClipModel(apply_transform=apply_transform) @@ -44,7 +48,8 @@ def test_few_shot_from_setup(self, apply_transform: bool) -> None: assert getattr(model, "text_embeddings", None) is not None assert getattr(model, "visual_embeddings", None) is not None - def test_raises_error_when_not_initialized(self) -> None: + @staticmethod + def test_raises_error_when_not_initialized() -> None: """Test if an error is raised when trying to access un-initialized attributes.""" model = WinClipModel() with pytest.raises(RuntimeError): diff --git a/tests/unit/models/image/winclip/test_utils.py b/tests/unit/models/image/winclip/test_utils.py index a828eec07a..b41f2be893 100644 --- a/tests/unit/models/image/winclip/test_utils.py +++ b/tests/unit/models/image/winclip/test_utils.py @@ -18,37 +18,43 @@ class TestCosineSimilarity: """Unit tests for cosine similarity computation.""" - def test_computation(self) -> None: + @staticmethod + def test_computation() -> None: """Test cosine similarity computation.""" input1 = torch.tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) input2 = torch.tensor([[0.0, 1.0, 0.0], [1.0, 1.0, 0.0]]) assert torch.allclose(cosine_similarity(input1, input2), torch.tensor([[[0.0000, 0.7071], [1.0000, 0.7071]]])) - def test_single_batch(self) -> None: + @staticmethod + def test_single_batch() -> None: """Test cosine similarity with single batch inputs.""" input1 = torch.randn(1, 100, 128) input2 = torch.randn(1, 200, 128) assert cosine_similarity(input1, input2).shape == torch.Size([1, 100, 200]) - def test_multi_batch(self) -> None: + @staticmethod + def test_multi_batch() -> None: """Test cosine similarity with multiple batch inputs.""" input1 = torch.randn(10, 100, 128) input2 = torch.randn(10, 200, 128) assert cosine_similarity(input1, input2).shape == torch.Size([10, 100, 200]) - def test_2d(self) -> None: + @staticmethod + def test_2d() -> None: """Test cosine similarity with 2D input.""" input1 = torch.randn(100, 128) input2 = torch.randn(200, 128) assert cosine_similarity(input1, input2).shape == torch.Size([100, 200]) - def test_2d_3d(self) -> None: + @staticmethod + def test_2d_3d() -> None: """Test cosine similarity with 2D and 3D input.""" input1 = torch.randn(100, 128) input2 = torch.randn(1, 200, 128) assert cosine_similarity(input1, input2).shape == torch.Size([100, 200]) - def test_3d_2d(self) -> None: + @staticmethod + def test_3d_2d() -> None: """Test cosine similarity with 3D and 2D input.""" input1 = torch.randn(10, 100, 128) input2 = torch.randn(200, 128) @@ -58,14 +64,16 @@ def test_3d_2d(self) -> None: class TestClassScores: """Unit tests for CLIP class score computation.""" - def test_computation(self) -> None: + @staticmethod + def test_computation() -> None: """Test CLIP class score computation.""" input1 = torch.tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) input2 = torch.tensor([[0.0, 1.0, 0.0], [1.0, 1.0, 0.0]]) target = torch.tensor([[0.3302, 0.6698], [0.5727, 0.4273]]) assert torch.allclose(class_scores(input1, input2), target, atol=1e-4) - def test_called_with_target(self) -> None: + @staticmethod + def test_called_with_target() -> None: """Test CLIP class score computation without target.""" input1 = torch.randn(100, 128) input2 = torch.randn(200, 128) @@ -75,7 +83,8 @@ def test_called_with_target(self) -> None: class TestHarmonicAggregation: """Unit tests for harmonic aggregation computation.""" - def test_3x3_grid(self) -> None: + @staticmethod + def test_3x3_grid() -> None: """Test harmonic aggregation computation.""" # example for a 3x3 patch grid with 4 sliding windows of size 2x2 window_scores = torch.tensor([[1.0, 0.75, 0.5, 0.25]]) @@ -85,7 +94,8 @@ def test_3x3_grid(self) -> None: output = harmonic_aggregation(window_scores, output_size, masks) assert torch.allclose(output, target, atol=1e-4) - def test_multi_batch(self) -> None: + @staticmethod + def test_multi_batch() -> None: """Test harmonic aggregation computation with multiple batches.""" window_scores = torch.randn(2, 4) output_size = (3, 3) @@ -97,14 +107,16 @@ def test_multi_batch(self) -> None: class TestVisualAssociationScore: """Unit tests for visual association score computation.""" - def test_computation(self) -> None: + @staticmethod + def test_computation() -> None: """Test visual association score computation.""" embeddings = torch.tensor([[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]]) reference_embeddings = torch.tensor([[[0.0, 1.0, 0.0], [1.0, 1.0, 0.0]]]) target = torch.tensor([[0.1464, 0.0000]]) assert torch.allclose(visual_association_score(embeddings, reference_embeddings), target, atol=1e-4) - def test_multi_batch(self) -> None: + @staticmethod + def test_multi_batch() -> None: """Test visual association score computation with multiple batches.""" embeddings = torch.randn(10, 100, 128) reference_embeddings = torch.randn(2, 100, 128) @@ -114,13 +126,15 @@ def test_multi_batch(self) -> None: class TestMakeMasks: """Unit tests for mask generation.""" - def test_produces_correct_indices(self) -> None: + @staticmethod + def test_produces_correct_indices() -> None: """Test mask generation.""" patch_grid_size = (3, 3) kernel_size = 2 target = torch.tensor([[0, 1, 3, 4], [1, 2, 4, 5], [3, 4, 6, 7], [4, 5, 7, 8]]) assert torch.equal(make_masks(patch_grid_size, kernel_size), target) + @staticmethod @pytest.mark.parametrize( ("grid_size", "kernel_size", "stride", "target"), [ @@ -131,10 +145,11 @@ def test_produces_correct_indices(self) -> None: ((4, 4), 2, 2, (4, 4)), ], ) - def test_shapes(self, grid_size: tuple[int, int], kernel_size: int, stride: int, target: tuple[int, int]) -> None: + def test_shapes(grid_size: tuple[int, int], kernel_size: int, stride: int, target: tuple[int, int]) -> None: """Test mask generation for different grid sizes and kernel sizes.""" assert make_masks(grid_size, kernel_size, stride).shape == target + @staticmethod @pytest.mark.parametrize( ("grid_size", "kernel_size"), [ @@ -144,7 +159,6 @@ def test_shapes(self, grid_size: tuple[int, int], kernel_size: int, stride: int, ], ) def test_raises_error_when_window_size_larger_than_grid_size( - self, grid_size: tuple[int, int], kernel_size: int, ) -> None: diff --git a/tests/unit/models/test_feature_extractor.py b/tests/unit/models/test_feature_extractor.py index 6234ebe9f4..1faa3e7b78 100644 --- a/tests/unit/models/test_feature_extractor.py +++ b/tests/unit/models/test_feature_extractor.py @@ -1,5 +1,8 @@ """Test feature extractors.""" +# Copyright (C) 2022-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + from tempfile import TemporaryDirectory import pytest @@ -18,15 +21,10 @@ class TestFeatureExtractor: """Test the feature extractor.""" - @pytest.mark.parametrize( - "backbone", - ["resnet18", "wide_resnet50_2"], - ) - @pytest.mark.parametrize( - "pretrained", - [True, False], - ) - def test_timm_feature_extraction(self, backbone: str, pretrained: bool) -> None: + @staticmethod + @pytest.mark.parametrize("backbone", ["resnet18", "wide_resnet50_2"]) + @pytest.mark.parametrize("pretrained", [True, False]) + def test_timm_feature_extraction(backbone: str, pretrained: bool) -> None: """Test if the feature extractor can be instantiated and if the output is as expected.""" layers = ["layer1", "layer2", "layer3"] model = TimmFeatureExtractor(backbone=backbone, layers=layers, pre_trained=pretrained) @@ -48,7 +46,8 @@ def test_timm_feature_extraction(self, backbone: str, pretrained: bool) -> None: else: pass - def test_torchfx_feature_extraction(self) -> None: + @staticmethod + def test_torchfx_feature_extraction() -> None: """Test types of inputs for instantiating the feature extractor.""" model = TorchFXFeatureExtractor("resnet18", ["layer1", "layer2", "layer3"]) test_input = torch.rand((32, 3, 256, 256)) @@ -98,14 +97,8 @@ def test_torchfx_feature_extraction(self) -> None: assert features["layer3"].shape == torch.Size((32, 256, 16, 16)) -@pytest.mark.parametrize( - "backbone", - ["resnet18", "wide_resnet50_2"], -) -@pytest.mark.parametrize( - "input_size", - [(256, 256), (224, 224), (128, 128)], -) +@pytest.mark.parametrize("backbone", ["resnet18", "wide_resnet50_2"]) +@pytest.mark.parametrize("input_size", [(256, 256), (224, 224), (128, 128)]) def test_dryrun_find_featuremap_dims(backbone: str, input_size: tuple[int, int]) -> None: """Use the function and check the expected output format.""" layers = ["layer1", "layer2", "layer3"] diff --git a/tests/unit/models/test_model_utils.py b/tests/unit/models/test_model_utils.py index d52b30cc3c..2389ab882e 100644 --- a/tests/unit/models/test_model_utils.py +++ b/tests/unit/models/test_model_utils.py @@ -13,7 +13,8 @@ class TestGetModel: """Test the `get_model` method.""" - def test_get_model_by_name(self) -> None: + @staticmethod + def test_get_model_by_name() -> None: """Test get_model by name.""" model = get_model("Padim") assert isinstance(model, Padim) @@ -27,29 +28,34 @@ def test_get_model_by_name(self) -> None: model = get_model("efficientad") assert isinstance(model, EfficientAd) - def test_get_model_by_name_with_init_args(self) -> None: + @staticmethod + def test_get_model_by_name_with_init_args() -> None: """Test get_model by name with init args.""" model = get_model("Patchcore", backbone="wide_resnet50_2") assert isinstance(model, Patchcore) - def test_get_model_by_dict(self) -> None: + @staticmethod + def test_get_model_by_dict() -> None: """Test get_model by dict.""" model = get_model({"class_path": "Padim"}) assert isinstance(model, Padim) - def test_get_model_by_dict_with_init_args(self) -> None: + @staticmethod + def test_get_model_by_dict_with_init_args() -> None: """Test get_model by dict with init args.""" model = get_model({"class_path": "Padim", "init_args": {"backbone": "wide_resnet50_2"}}) assert isinstance(model, Padim) model = get_model({"class_path": "Patchcore"}, backbone="wide_resnet50_2") assert isinstance(model, Patchcore) - def test_get_model_by_dict_with_full_class_path(self) -> None: + @staticmethod + def test_get_model_by_dict_with_full_class_path() -> None: """Test get_model by dict with full class path.""" model = get_model({"class_path": "anomalib.models.Padim", "init_args": {"backbone": "wide_resnet50_2"}}) assert isinstance(model, Padim) - def test_get_model_by_namespace(self) -> None: + @staticmethod + def test_get_model_by_namespace() -> None: """Test get_model by namespace.""" config = OmegaConf.create({"class_path": "Padim"}) namespace = Namespace(**config) @@ -69,7 +75,8 @@ def test_get_model_by_namespace(self) -> None: model = get_model(namespace) assert isinstance(model, Padim) - def test_get_model_by_dict_config(self) -> None: + @staticmethod + def test_get_model_by_dict_config() -> None: """Test get_model by dict config.""" config = OmegaConf.create({"class_path": "Padim"}) model = get_model(config) @@ -78,17 +85,20 @@ def test_get_model_by_dict_config(self) -> None: model = get_model(config) assert isinstance(model, Padim) - def test_get_unknown_model(self) -> None: + @staticmethod + def test_get_unknown_model() -> None: """Test get_model with unknown model.""" with pytest.raises(UnknownModelError): get_model("UnimplementedModel") - def test_get_model_with_invalid_type(self) -> None: + @staticmethod + def test_get_model_with_invalid_type() -> None: """Test get_model with invalid type.""" with pytest.raises(TypeError): get_model(OmegaConf.create([{"class_path": "Padim"}])) - def test_get_model_with_invalid_class_path(self) -> None: + @staticmethod + def test_get_model_with_invalid_class_path() -> None: """Test get_model with invalid class path.""" with pytest.raises(UnknownModelError): get_model({"class_path": "anomalib.models.InvalidModel"}) diff --git a/tests/unit/models/video/test_ai_vad.py b/tests/unit/models/video/test_ai_vad.py index 899f8af905..e9ddb050dd 100644 --- a/tests/unit/models/video/test_ai_vad.py +++ b/tests/unit/models/video/test_ai_vad.py @@ -11,7 +11,8 @@ class TestAiVadFeatureExtractor: """Test if the different feature extractors of the AiVad model can handle edge case without bbox detections.""" - def test_velocity_extractor(self) -> None: + @staticmethod + def test_velocity_extractor() -> None: """Test velocity extractor submodule.""" pl_module = AiVad() velocity_feature_extractor = pl_module.model.feature_extractor.velocity_extractor @@ -24,7 +25,8 @@ def test_velocity_extractor(self) -> None: # features should be empty because there are no boxes assert velocity_features.numel() == 0 - def test_deep_feature_extractor(self) -> None: + @staticmethod + def test_deep_feature_extractor() -> None: """Test deep feature extractor submodule.""" pl_module = AiVad() deep_feature_extractor = pl_module.model.feature_extractor.deep_extractor @@ -38,7 +40,8 @@ def test_deep_feature_extractor(self) -> None: # features should be empty because there are no boxes assert deep_features.numel() == 0 - def test_pose_feature_extractor(self) -> None: + @staticmethod + def test_pose_feature_extractor() -> None: """Test pose feature extractor submodule.""" pl_module = AiVad() pose_feature_extractor = pl_module.model.feature_extractor.pose_extractor diff --git a/tests/unit/pipelines/__init__.py b/tests/unit/pipelines/__init__.py new file mode 100644 index 0000000000..46de40af76 --- /dev/null +++ b/tests/unit/pipelines/__init__.py @@ -0,0 +1,4 @@ +"""Pipeline unit tests.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 diff --git a/tests/unit/pipelines/tiled_ensemble/__init__.py b/tests/unit/pipelines/tiled_ensemble/__init__.py new file mode 100644 index 0000000000..a78a1ad659 --- /dev/null +++ b/tests/unit/pipelines/tiled_ensemble/__init__.py @@ -0,0 +1,4 @@ +"""Tiled ensemble unit tests.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 diff --git a/tests/unit/pipelines/tiled_ensemble/conftest.py b/tests/unit/pipelines/tiled_ensemble/conftest.py new file mode 100644 index 0000000000..b4fad61ebb --- /dev/null +++ b/tests/unit/pipelines/tiled_ensemble/conftest.py @@ -0,0 +1,151 @@ +"""Fixtures that are used in tiled ensemble testing.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import json +from pathlib import Path +from tempfile import TemporaryDirectory + +import pytest +import torch +import yaml + +from anomalib.data import AnomalibDataModule +from anomalib.models import AnomalyModule +from anomalib.pipelines.tiled_ensemble.components.utils.ensemble_tiling import EnsembleTiler +from anomalib.pipelines.tiled_ensemble.components.utils.helper_functions import ( + get_ensemble_datamodule, + get_ensemble_model, + get_ensemble_tiler, +) +from anomalib.pipelines.tiled_ensemble.components.utils.prediction_data import EnsemblePredictions +from anomalib.pipelines.tiled_ensemble.components.utils.prediction_merging import PredictionMergingMechanism + + +@pytest.fixture(scope="module") +def get_ensemble_config(dataset_path: Path) -> dict: + """Return ensemble dummy config dict with corrected dataset path to dummy temp dir.""" + with Path("tests/unit/pipelines/tiled_ensemble/dummy_config.yaml").open(encoding="utf-8") as file: + config = yaml.safe_load(file) + # dummy dataset + config["data"]["init_args"]["root"] = dataset_path / "mvtec" + + return config + + +@pytest.fixture(scope="module") +def get_tiler(get_ensemble_config: dict) -> EnsembleTiler: + """Return EnsembleTiler object based on test dummy config.""" + config = get_ensemble_config + + return get_ensemble_tiler(config["tiling"], config["data"]) + + +@pytest.fixture(scope="module") +def get_model(get_ensemble_config: dict, get_tiler: EnsembleTiler) -> AnomalyModule: + """Return model prepared for tiled ensemble training.""" + config = get_ensemble_config + tiler = get_tiler + + return get_ensemble_model(config["TrainModels"]["model"], tiler) + + +@pytest.fixture(scope="module") +def get_datamodule(get_ensemble_config: dict, get_tiler: EnsembleTiler) -> AnomalibDataModule: + """Return ensemble datamodule.""" + config = get_ensemble_config + tiler = get_tiler + datamodule = get_ensemble_datamodule(config, tiler, (0, 0)) + datamodule.setup() + + return datamodule + + +@pytest.fixture(scope="module") +def get_tile_predictions(get_datamodule: AnomalibDataModule) -> EnsemblePredictions: + """Return tile predictions inside EnsemblePredictions object.""" + datamodule = get_datamodule + + data = EnsemblePredictions() + + for tile_index in [(0, 0), (0, 1), (1, 0), (1, 1)]: + datamodule.collate_fn.tile_index = tile_index + + tile_prediction = [] + batch = next(iter(datamodule.test_dataloader())) + + # make mock labels and scores + batch["pred_scores"] = torch.rand(batch["label"].shape) + batch["pred_labels"] = batch["pred_scores"] > 0.5 + + # set mock maps to just one channel of image + batch["anomaly_maps"] = batch["image"].clone()[:, 0, :, :].unsqueeze(1) + # set mock pred mask to mask but add channel + batch["pred_masks"] = batch["mask"].clone().unsqueeze(1) + + tile_prediction.append(batch) + + # store to prediction storage object + data.add_tile_prediction(tile_index, tile_prediction) + + return data + + +@pytest.fixture(scope="module") +def get_batch_predictions() -> list[dict]: + """Return mock batched predictions.""" + mock_data = { + "image": torch.rand((5, 3, 100, 100)), + "mask": (torch.rand((5, 100, 100)) > 0.5).type(torch.float32), + "anomaly_maps": torch.rand((5, 1, 100, 100)), + "label": torch.Tensor([0, 1, 1, 0, 1]), + "pred_scores": torch.rand(5), + "pred_labels": torch.ones(5), + "pred_masks": torch.zeros((5, 100, 100)), + } + + return [mock_data, mock_data] + + +@pytest.fixture(scope="module") +def get_merging_mechanism( + get_tile_predictions: EnsemblePredictions, + get_tiler: EnsembleTiler, +) -> PredictionMergingMechanism: + """Return ensemble prediction merging mechanism object.""" + tiler = get_tiler + predictions = get_tile_predictions + return PredictionMergingMechanism(predictions, tiler) + + +@pytest.fixture(scope="module") +def get_mock_stats_dir() -> Path: + """Get temp dir containing statistics.""" + with TemporaryDirectory() as temp_dir: + stats = { + "minmax": { + "anomaly_maps": { + "min": 1.9403648376464844, + "max": 209.91940307617188, + }, + "box_scores": { + "min": 0.5, + "max": 0.45, + }, + "pred_scores": { + "min": 9.390382766723633, + "max": 209.91940307617188, + }, + }, + "image_threshold": 0.1111, + "pixel_threshold": 0.1111, + } + stats_path = Path(temp_dir) / "weights" / "lightning" / "stats.json" + stats_path.parent.mkdir(parents=True) + + # save mock statistics + with stats_path.open("w", encoding="utf-8") as stats_file: + json.dump(stats, stats_file, ensure_ascii=False, indent=4) + + yield Path(temp_dir) diff --git a/tests/unit/pipelines/tiled_ensemble/dummy_config.yaml b/tests/unit/pipelines/tiled_ensemble/dummy_config.yaml new file mode 100644 index 0000000000..fcd4b7c716 --- /dev/null +++ b/tests/unit/pipelines/tiled_ensemble/dummy_config.yaml @@ -0,0 +1,52 @@ +seed: 42 +accelerator: "cpu" +default_root_dir: "results" + +tiling: + tile_size: [50, 50] + stride: 50 + +normalization_stage: image # on what level we normalize, options: [tile, image, none] +thresholding: + method: F1AdaptiveThreshold # refer to documentation for thresholding methods + stage: image # stage at which we apply threshold, options: [tile, image] + +data: + class_path: anomalib.data.MVTec + init_args: + root: toBeSetup + category: dummy + train_batch_size: 32 + eval_batch_size: 32 + num_workers: 0 + task: segmentation + transform: null + train_transform: null + eval_transform: null + test_split_mode: from_dir + test_split_ratio: 0.2 + val_split_mode: same_as_test + val_split_ratio: 0.5 + image_size: [100, 100] + +SeamSmoothing: + apply: True # if this is applied, area around tile seams are is smoothed + sigma: 2 # sigma of gaussian filter used to smooth this area + width: 0.1 # width factor, multiplied by tile dimension gives the region width around seam which will be smoothed + +TrainModels: + model: + class_path: Fastflow + + metrics: + pixel: AUROC + image: AUROC + + trainer: + max_epochs: 1 + callbacks: + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + patience: 1 + monitor: pixel_AUROC + mode: max diff --git a/tests/unit/pipelines/tiled_ensemble/test_components.py b/tests/unit/pipelines/tiled_ensemble/test_components.py new file mode 100644 index 0000000000..0e3c0dcdd4 --- /dev/null +++ b/tests/unit/pipelines/tiled_ensemble/test_components.py @@ -0,0 +1,387 @@ +"""Test working of tiled ensemble pipeline components.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import copy +from pathlib import Path +from tempfile import TemporaryDirectory + +import pytest +import torch + +from anomalib.data import get_datamodule +from anomalib.metrics import F1AdaptiveThreshold, ManualThreshold +from anomalib.pipelines.tiled_ensemble.components import ( + MergeJobGenerator, + MetricsCalculationJobGenerator, + NormalizationJobGenerator, + SmoothingJobGenerator, + StatisticsJobGenerator, + ThresholdingJobGenerator, +) +from anomalib.pipelines.tiled_ensemble.components.metrics_calculation import MetricsCalculationJob +from anomalib.pipelines.tiled_ensemble.components.smoothing import SmoothingJob +from anomalib.pipelines.tiled_ensemble.components.utils import NormalizationStage +from anomalib.pipelines.tiled_ensemble.components.utils.prediction_data import EnsemblePredictions +from anomalib.pipelines.tiled_ensemble.components.utils.prediction_merging import PredictionMergingMechanism + + +class TestMerging: + """Test merging mechanism and merging job.""" + + @staticmethod + def test_tile_merging(get_ensemble_config: dict, get_merging_mechanism: PredictionMergingMechanism) -> None: + """Test tiled data merging.""" + config = get_ensemble_config + merger = get_merging_mechanism + + # prepared original data + datamodule = get_datamodule(config) + datamodule.prepare_data() + datamodule.setup() + original_data = next(iter(datamodule.test_dataloader())) + + batch = merger.ensemble_predictions.get_batch_tiles(0) + + merged_image = merger.merge_tiles(batch, "image") + assert merged_image.equal(original_data["image"]) + + merged_mask = merger.merge_tiles(batch, "mask") + assert merged_mask.equal(original_data["mask"]) + + @staticmethod + def test_label_and_score_merging(get_merging_mechanism: PredictionMergingMechanism) -> None: + """Test label and score merging.""" + merger = get_merging_mechanism + scores = torch.rand(4, 10) + labels = scores > 0.5 + + mock_data = {(0, 0): {}, (0, 1): {}, (1, 0): {}, (1, 1): {}} + + for i, data in enumerate(mock_data.values()): + data["pred_scores"] = scores[i] + data["pred_labels"] = labels[i] + + merged = merger.merge_labels_and_scores(mock_data) + + assert merged["pred_scores"].equal(scores.mean(dim=0)) + + assert merged["pred_labels"].equal(labels.any(dim=0)) + + @staticmethod + def test_merge_job( + get_tile_predictions: EnsemblePredictions, + get_ensemble_config: dict, + get_merging_mechanism: PredictionMergingMechanism, + ) -> None: + """Test merging job execution.""" + config = get_ensemble_config + predictions = copy.deepcopy(get_tile_predictions) + merging_mechanism = get_merging_mechanism + + merging_job_generator = MergeJobGenerator(tiling_args=config["tiling"], data_args=config["data"]) + merging_job = next(merging_job_generator.generate_jobs(prev_stage_result=predictions)) + + merged_direct = merging_mechanism.merge_tile_predictions(0) + merged_with_job = merging_job.run()[0] + + # check that merging by job is same as with the mechanism directly + for key, value in merged_direct.items(): + if isinstance(value, torch.Tensor): + assert merged_with_job[key].equal(value) + elif isinstance(value, list) and isinstance(value[0], torch.Tensor): + # boxes + assert all(j.equal(d) for j, d in zip(merged_with_job[key], value, strict=False)) + else: + assert merged_with_job[key] == value + + +class TestStatsCalculation: + """Test post-processing statistics calculations.""" + + @staticmethod + @pytest.mark.parametrize( + ("threshold_str", "threshold_cls"), + [("F1AdaptiveThreshold", F1AdaptiveThreshold), ("ManualThreshold", ManualThreshold)], + ) + def test_threshold_method(threshold_str: str, threshold_cls: type, get_ensemble_config: dict) -> None: + """Test that correct thresholding method is used.""" + config = copy.deepcopy(get_ensemble_config) + config["thresholding"]["method"] = threshold_str + + stats_job_generator = StatisticsJobGenerator(Path("mock"), threshold_str) + stats_job = next(stats_job_generator.generate_jobs(None, None)) + + assert isinstance(stats_job.image_threshold, threshold_cls) + + @staticmethod + def test_stats_run(project_path: Path) -> None: + """Test execution of statistics calc. job.""" + mock_preds = [ + { + "pred_scores": torch.rand(4), + "label": torch.ones(4), + "anomaly_maps": torch.rand(4, 1, 50, 50), + "mask": torch.ones(4, 1, 50, 50), + }, + ] + + stats_job_generator = StatisticsJobGenerator(project_path, "F1AdaptiveThreshold") + stats_job = next(stats_job_generator.generate_jobs(None, mock_preds)) + + results = stats_job.run() + + assert "minmax" in results + assert "image_threshold" in results + assert "pixel_threshold" in results + + # save as it's removed from results + save_path = results["save_path"] + stats_job.save(results) + assert Path(save_path).exists() + + @staticmethod + @pytest.mark.parametrize( + ("key", "values"), + [ + ("anomaly_maps", [torch.rand(5, 1, 50, 50), torch.rand(5, 1, 50, 50)]), + ("pred_scores", [torch.rand(5), torch.rand(5)]), + ], + ) + def test_minmax(key: str, values: list) -> None: + """Test minmax stats calculation.""" + # add given keys to test all possible sources of minmax + data = [ + {"pred_scores": torch.rand(5), "label": torch.ones(5), key: values[0]}, + {"pred_scores": torch.rand(5), "label": torch.ones(5), key: values[1]}, + ] + + stats_job_generator = StatisticsJobGenerator(Path("mock"), "F1AdaptiveThreshold") + stats_job = next(stats_job_generator.generate_jobs(None, data)) + results = stats_job.run() + + if isinstance(values[0], list): + values[0] = torch.cat(values[0]) + values[1] = torch.cat(values[1]) + values = torch.stack(values) + + assert results["minmax"][key]["min"] == torch.min(values) + assert results["minmax"][key]["max"] == torch.max(values) + + @staticmethod + @pytest.mark.parametrize( + ("labels", "preds", "target_threshold"), + [ + (torch.Tensor([0, 0, 0, 1, 1]), torch.Tensor([2.3, 1.6, 2.6, 7.9, 3.3]), 3.3), # standard case + (torch.Tensor([1, 0, 0, 0]), torch.Tensor([4, 3, 2, 1]), 4), # 100% recall for all thresholds + ], + ) + def test_threshold(labels: torch.Tensor, preds: torch.Tensor, target_threshold: float) -> None: + """Test threshold calculation job.""" + data = [ + { + "label": labels, + "mask": labels, + "pred_scores": preds, + "anomaly_maps": preds, + }, + ] + + stats_job_generator = StatisticsJobGenerator(Path("mock"), "F1AdaptiveThreshold") + stats_job = next(stats_job_generator.generate_jobs(None, data)) + results = stats_job.run() + + assert round(results["image_threshold"], 5) == target_threshold + assert round(results["pixel_threshold"], 5) == target_threshold + + +class TestMetrics: + """Test ensemble metrics.""" + + @pytest.fixture(scope="class") + @staticmethod + def get_ensemble_metrics_job( + get_ensemble_config: dict, + get_batch_predictions: list[dict], + ) -> tuple[MetricsCalculationJob, str]: + """Return Metrics calculation job and path to directory where metrics csv will be saved.""" + config = get_ensemble_config + with TemporaryDirectory() as tmp_dir: + metrics = MetricsCalculationJobGenerator( + config["accelerator"], + root_dir=Path(tmp_dir), + task=config["data"]["init_args"]["task"], + metrics=config["TrainModels"]["metrics"], + normalization_stage=NormalizationStage(config["normalization_stage"]), + ) + + mock_predictions = get_batch_predictions + + return next(metrics.generate_jobs(prev_stage_result=copy.deepcopy(mock_predictions))), tmp_dir + + @staticmethod + def test_metrics_result(get_ensemble_metrics_job: tuple[MetricsCalculationJob, str]) -> None: + """Test metrics result.""" + metrics_job, _ = get_ensemble_metrics_job + + result = metrics_job.run() + + assert "pixel_AUROC" in result + assert "image_AUROC" in result + + @staticmethod + def test_metrics_saving(get_ensemble_metrics_job: tuple[MetricsCalculationJob, str]) -> None: + """Test metrics saving to csv.""" + metrics_job, tmp_dir = get_ensemble_metrics_job + + result = metrics_job.run() + metrics_job.save(result) + assert (Path(tmp_dir) / "metric_results.csv").exists() + + +class TestJoinSmoothing: + """Test JoinSmoothing job responsible for smoothing area at tile seams.""" + + @pytest.fixture(scope="class") + @staticmethod + def get_join_smoothing_job(get_ensemble_config: dict, get_batch_predictions: list[dict]) -> SmoothingJob: + """Make and return SmoothingJob instance.""" + config = get_ensemble_config + job_gen = SmoothingJobGenerator( + accelerator=config["accelerator"], + tiling_args=config["tiling"], + data_args=config["data"], + ) + # copy since smoothing changes data + mock_predictions = copy.deepcopy(get_batch_predictions) + return next(job_gen.generate_jobs(config["SeamSmoothing"], mock_predictions)) + + @staticmethod + def test_mask(get_join_smoothing_job: SmoothingJob) -> None: + """Test seam mask in case where tiles don't overlap.""" + smooth = get_join_smoothing_job + + join_index = smooth.tiler.tile_size_h, smooth.tiler.tile_size_w + + # seam should be covered by True + assert smooth.seam_mask[join_index] + + # non-seam region should be false + assert not smooth.seam_mask[0, 0] + assert not smooth.seam_mask[-1, -1] + + @staticmethod + def test_mask_overlapping(get_ensemble_config: dict, get_batch_predictions: list[dict]) -> None: + """Test seam mask in case where tiles overlap.""" + config = copy.deepcopy(get_ensemble_config) + # tile size = 50, stride = 25 -> overlapping + config["tiling"]["stride"] = 25 + job_gen = SmoothingJobGenerator( + accelerator=config["accelerator"], + tiling_args=config["tiling"], + data_args=config["data"], + ) + mock_predictions = copy.deepcopy(get_batch_predictions) + smooth = next(job_gen.generate_jobs(config["SeamSmoothing"], mock_predictions)) + + join_index = smooth.tiler.stride_h, smooth.tiler.stride_w + + # overlap seam should be covered by True + assert smooth.seam_mask[join_index] + assert smooth.seam_mask[-join_index[0], -join_index[1]] + + # non-seam region should be false + assert not smooth.seam_mask[0, 0] + assert not smooth.seam_mask[-1, -1] + + @staticmethod + def test_smoothing(get_join_smoothing_job: SmoothingJob, get_batch_predictions: list[dict]) -> None: + """Test smoothing job run.""" + original_data = get_batch_predictions + # fixture makes a copy of data + smooth = get_join_smoothing_job + + # take first batch + smoothed = smooth.run()[0] + join_index = smooth.tiler.tile_size_h, smooth.tiler.tile_size_w + + # join sections should be processed + assert not smoothed["anomaly_maps"][:, :, join_index].equal(original_data[0]["anomaly_maps"][:, :, join_index]) + + # non-join section shouldn't be changed + assert smoothed["anomaly_maps"][:, :, 0, 0].equal(original_data[0]["anomaly_maps"][:, :, 0, 0]) + + +def test_normalization(get_batch_predictions: list[dict], project_path: Path) -> None: + """Test normalization step.""" + original_predictions = copy.deepcopy(get_batch_predictions) + + for batch in original_predictions: + batch["anomaly_maps"] *= 100 + batch["pred_scores"] *= 100 + + # # get and save stats using stats job on predictions + stats_job_generator = StatisticsJobGenerator(project_path, "F1AdaptiveThreshold") + stats_job = next(stats_job_generator.generate_jobs(prev_stage_result=original_predictions)) + stats = stats_job.run() + stats_job.save(stats) + + # normalize predictions based on obtained stats + norm_job_generator = NormalizationJobGenerator(root_dir=project_path) + # copy as this changes preds + norm_job = next(norm_job_generator.generate_jobs(prev_stage_result=original_predictions)) + normalized_predictions = norm_job.run() + + for batch in normalized_predictions: + assert (batch["anomaly_maps"] >= 0).all() + assert (batch["anomaly_maps"] <= 1).all() + + assert (batch["pred_scores"] >= 0).all() + assert (batch["pred_scores"] <= 1).all() + + +class TestThresholding: + """Test tiled ensemble thresholding stage.""" + + @pytest.fixture(scope="class") + @staticmethod + def get_threshold_job(get_mock_stats_dir: Path) -> callable: + """Return a function that takes prediction data and runs threshold job.""" + thresh_job_generator = ThresholdingJobGenerator( + root_dir=get_mock_stats_dir, + normalization_stage=NormalizationStage.IMAGE, + ) + + def thresh_helper(preds: dict) -> list | None: + thresh_job = next(thresh_job_generator.generate_jobs(prev_stage_result=preds)) + return thresh_job.run() + + return thresh_helper + + @staticmethod + def test_score_threshold(get_threshold_job: callable) -> None: + """Test anomaly score thresholding.""" + thresholding = get_threshold_job + + data = [{"pred_scores": torch.tensor([0.7, 0.8, 0.1, 0.33, 0.5])}] + + thresholded = thresholding(data)[0] + + assert thresholded["pred_labels"].equal(torch.tensor([True, True, False, False, True])) + + @staticmethod + def test_anomap_threshold(get_threshold_job: callable) -> None: + """Test anomaly map thresholding.""" + thresholding = get_threshold_job + + data = [ + { + "pred_scores": torch.tensor([0.7, 0.8, 0.1, 0.33, 0.5]), + "anomaly_maps": torch.tensor([[0.7, 0.8, 0.1], [0.33, 0.5, 0.1]]), + }, + ] + + thresholded = thresholding(data)[0] + + assert thresholded["pred_masks"].equal(torch.tensor([[True, True, False], [False, True, False]])) diff --git a/tests/unit/pipelines/tiled_ensemble/test_helper_functions.py b/tests/unit/pipelines/tiled_ensemble/test_helper_functions.py new file mode 100644 index 0000000000..06e5864cef --- /dev/null +++ b/tests/unit/pipelines/tiled_ensemble/test_helper_functions.py @@ -0,0 +1,113 @@ +"""Test ensemble helper functions.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from pathlib import Path + +import pytest +from jsonargparse import Namespace +from lightning.pytorch.callbacks import EarlyStopping + +from anomalib.callbacks.normalization import _MinMaxNormalizationCallback +from anomalib.models import AnomalyModule +from anomalib.pipelines.tiled_ensemble.components.utils import NormalizationStage +from anomalib.pipelines.tiled_ensemble.components.utils.ensemble_tiling import EnsembleTiler, TileCollater +from anomalib.pipelines.tiled_ensemble.components.utils.helper_functions import ( + get_ensemble_datamodule, + get_ensemble_engine, + get_ensemble_model, + get_ensemble_tiler, + get_threshold_values, + parse_trainer_kwargs, +) + + +class TestHelperFunctions: + """Test ensemble helper functions.""" + + @staticmethod + def test_ensemble_datamodule(get_ensemble_config: dict, get_tiler: EnsembleTiler) -> None: + """Test that datamodule is created and has correct collate function.""" + config = get_ensemble_config + tiler = get_tiler + datamodule = get_ensemble_datamodule(config, tiler, (0, 0)) + + assert isinstance(datamodule.collate_fn, TileCollater) + + @staticmethod + def test_ensemble_model(get_ensemble_config: dict, get_tiler: EnsembleTiler) -> None: + """Test that model is successfully created with correct input shape.""" + config = get_ensemble_config + tiler = get_tiler + model = get_ensemble_model(config["TrainModels"]["model"], tiler) + + assert model.input_size == tuple(config["tiling"]["tile_size"]) + + @staticmethod + def test_tiler(get_ensemble_config: dict) -> None: + """Test that tiler is successfully instantiated.""" + config = get_ensemble_config + + tiler = get_ensemble_tiler(config["tiling"], config["data"]) + assert isinstance(tiler, EnsembleTiler) + + @staticmethod + def test_trainer_kwargs(get_ensemble_config: dict) -> None: + """Test that objects are correctly constructed from kwargs.""" + config = get_ensemble_config + + objects = parse_trainer_kwargs(config["TrainModels"]["trainer"]) + assert isinstance(objects, Namespace) + # verify that early stopping is parsed and added to callbacks + assert isinstance(objects.callbacks[0], EarlyStopping) + + @staticmethod + @pytest.mark.parametrize( + "normalization_stage", + [NormalizationStage.NONE, NormalizationStage.IMAGE, NormalizationStage.TILE], + ) + def test_threshold_values(normalization_stage: NormalizationStage, get_mock_stats_dir: Path) -> None: + """Test that threshold values are correctly set based on normalization stage.""" + stats_dir = get_mock_stats_dir + + i_thresh, p_thresh = get_threshold_values(normalization_stage, stats_dir) + + if normalization_stage != NormalizationStage.NONE: + # minmax normalization sets thresholds to 0.5 + assert i_thresh == p_thresh == 0.5 + else: + assert i_thresh == p_thresh == 0.1111 + + +class TestEnsembleEngine: + """Test ensemble engine configuration.""" + + @staticmethod + @pytest.mark.parametrize( + "normalization_stage", + [NormalizationStage.NONE, NormalizationStage.IMAGE, NormalizationStage.TILE], + ) + def test_normalisation(normalization_stage: NormalizationStage, get_model: AnomalyModule) -> None: + """Test that normalization callback is correctly initialized.""" + engine = get_ensemble_engine( + tile_index=(0, 0), + accelerator="cpu", + devices="1", + root_dir=Path("mock"), + normalization_stage=normalization_stage, + ) + + engine._setup_anomalib_callbacks(get_model) # noqa: SLF001 + + # verify that only in case of tile level normalization the callback is present + if normalization_stage == NormalizationStage.TILE: + assert any( + isinstance(x, _MinMaxNormalizationCallback) + for x in engine._cache.args["callbacks"] # noqa: SLF001 + ) + else: + assert not any( + isinstance(x, _MinMaxNormalizationCallback) + for x in engine._cache.args["callbacks"] # noqa: SLF001 + ) diff --git a/tests/unit/pipelines/tiled_ensemble/test_prediction_data.py b/tests/unit/pipelines/tiled_ensemble/test_prediction_data.py new file mode 100644 index 0000000000..7185f1e2ca --- /dev/null +++ b/tests/unit/pipelines/tiled_ensemble/test_prediction_data.py @@ -0,0 +1,69 @@ +"""Test tiled prediction storage class.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import copy +from collections.abc import Callable + +import torch +from torch import Tensor + +from anomalib.data import AnomalibDataModule +from anomalib.pipelines.tiled_ensemble.components.utils.prediction_data import EnsemblePredictions + + +class TestPredictionData: + """Test EnsemblePredictions class, used for tiled prediction storage.""" + + @staticmethod + def store_all(data: EnsemblePredictions, datamodule: AnomalibDataModule) -> dict: + """Store the tiled predictions in the EnsemblePredictions object.""" + tile_dict = {} + for tile_index in [(0, 0), (0, 1), (1, 0), (1, 1)]: + datamodule.collate_fn.tile_index = tile_index + + tile_prediction = [] + for batch in iter(datamodule.train_dataloader()): + # set mock maps to just one channel of image + batch["anomaly_maps"] = batch["image"].clone()[:, 0, :, :].unsqueeze(1) + # set mock pred mask to mask but add channel + batch["pred_masks"] = batch["mask"].clone().unsqueeze(1) + tile_prediction.append(batch) + # save original + tile_dict[tile_index] = copy.deepcopy(tile_prediction) + # store to prediction storage object + data.add_tile_prediction(tile_index, tile_prediction) + + return tile_dict + + @staticmethod + def verify_equal(name: str, tile_dict: dict, storage: EnsemblePredictions, eq_funct: Callable) -> bool: + """Verify that all data at same tile index and same batch index matches.""" + batch_num = len(tile_dict[0, 0]) + + for batch_i in range(batch_num): + # batch is dict where key: tile index and val is batched data of that tile + curr_batch = storage.get_batch_tiles(batch_i) + + # go over all indices of current batch of stored data + for tile_index, stored_data_batch in curr_batch.items(): + stored_data = stored_data_batch[name] + # get original data dict at current tile index and batch index + original_data = tile_dict[tile_index][batch_i][name] + if isinstance(original_data, Tensor): + if not eq_funct(original_data, stored_data): + return False + elif original_data != stored_data: + return False + + return True + + def test_prediction_object(self, get_datamodule: AnomalibDataModule) -> None: + """Test prediction storage class.""" + datamodule = get_datamodule + storage = EnsemblePredictions() + original = self.store_all(storage, datamodule) + + for name in original[0, 0][0]: + assert self.verify_equal(name, original, storage, torch.equal), f"{name} doesn't match" diff --git a/tests/unit/pipelines/tiled_ensemble/test_tiler.py b/tests/unit/pipelines/tiled_ensemble/test_tiler.py new file mode 100644 index 0000000000..96b6c0e7bc --- /dev/null +++ b/tests/unit/pipelines/tiled_ensemble/test_tiler.py @@ -0,0 +1,119 @@ +"""Tiling related tests for tiled ensemble.""" + +# Copyright (C) 2023-2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +import copy + +import pytest +import torch + +from anomalib.data import AnomalibDataModule +from anomalib.pipelines.tiled_ensemble.components.utils.helper_functions import get_ensemble_tiler + +tiler_config = { + "tiling": { + "tile_size": 256, + "stride": 256, + }, + "data": {"init_args": {"image_size": 512}}, +} + +tiler_config_overlap = { + "tiling": { + "tile_size": 256, + "stride": 128, + }, + "data": {"init_args": {"image_size": 512}}, +} + + +class TestTiler: + """EnsembleTiler tests.""" + + @staticmethod + @pytest.mark.parametrize( + ("input_shape", "config", "expected_shape"), + [ + (torch.Size([5, 3, 512, 512]), tiler_config, torch.Size([2, 2, 5, 3, 256, 256])), + (torch.Size([5, 3, 512, 512]), tiler_config_overlap, torch.Size([3, 3, 5, 3, 256, 256])), + (torch.Size([5, 3, 500, 500]), tiler_config, torch.Size([2, 2, 5, 3, 256, 256])), + (torch.Size([5, 3, 500, 500]), tiler_config_overlap, torch.Size([3, 3, 5, 3, 256, 256])), + ], + ) + def test_basic_tile_for_ensemble(input_shape: torch.Size, config: dict, expected_shape: torch.Size) -> None: + """Test basic tiling of data.""" + config = copy.deepcopy(config) + config["data"]["init_args"]["image_size"] = input_shape[-1] + tiler = get_ensemble_tiler(config["tiling"], config["data"]) + + images = torch.rand(size=input_shape) + tiled = tiler.tile(images) + + assert tiled.shape == expected_shape + + @staticmethod + @pytest.mark.parametrize( + ("input_shape", "config"), + [ + (torch.Size([5, 3, 512, 512]), tiler_config), + (torch.Size([5, 3, 512, 512]), tiler_config_overlap), + (torch.Size([5, 3, 500, 500]), tiler_config), + (torch.Size([5, 3, 500, 500]), tiler_config_overlap), + ], + ) + def test_basic_tile_reconstruction(input_shape: torch.Size, config: dict) -> None: + """Test basic reconstruction of tiled data.""" + config = copy.deepcopy(config) + config["data"]["init_args"]["image_size"] = input_shape[-1] + + tiler = get_ensemble_tiler(config["tiling"], config["data"]) + + images = torch.rand(size=input_shape) + tiled = tiler.tile(images.clone()) + untiled = tiler.untile(tiled) + + assert images.shape == untiled.shape + assert images.equal(untiled) + + @staticmethod + @pytest.mark.parametrize( + ("input_shape", "config"), + [ + (torch.Size([5, 3, 512, 512]), tiler_config), + (torch.Size([5, 3, 500, 500]), tiler_config), + ], + ) + def test_untile_different_instance(input_shape: torch.Size, config: dict) -> None: + """Test untiling with different Tiler instance.""" + config = copy.deepcopy(config) + config["data"]["init_args"]["image_size"] = input_shape[-1] + tiler_1 = get_ensemble_tiler(config["tiling"], config["data"]) + + tiler_2 = get_ensemble_tiler(config["tiling"], config["data"]) + + images = torch.rand(size=input_shape) + tiled = tiler_1.tile(images.clone()) + + untiled = tiler_2.untile(tiled) + + # untiling should work even with different instance of tiler + assert images.shape == untiled.shape + assert images.equal(untiled) + + +class TestTileCollater: + """Test tile collater.""" + + @staticmethod + def test_collate_tile_shape(get_ensemble_config: dict, get_datamodule: AnomalibDataModule) -> None: + """Test that collate function successfully tiles the image.""" + config = get_ensemble_config + # datamodule with tile collater + datamodule = get_datamodule + + tile_w, tile_h = config["tiling"]["tile_size"] + + batch = next(iter(datamodule.train_dataloader())) + assert batch["image"].shape[1:] == (3, tile_w, tile_h) + assert batch["mask"].shape[1:] == (tile_w, tile_h) diff --git a/tests/unit/utils/test_visualizer.py b/tests/unit/utils/test_visualizer.py index 19a905e558..4df882a7f1 100644 --- a/tests/unit/utils/test_visualizer.py +++ b/tests/unit/utils/test_visualizer.py @@ -38,9 +38,9 @@ def test_visualize_fully_defected_masks() -> None: class TestVisualizer: """Test visualization callback for test and predict with different task types.""" + @staticmethod @pytest.mark.parametrize("task", [TaskType.CLASSIFICATION, TaskType.SEGMENTATION, TaskType.DETECTION]) def test_model_visualizer_mode( - self, ckpt_path: Callable[[str], Path], project_path: Path, dataset_path: Path, diff --git a/third-party-programs.txt b/third-party-programs.txt index 3155b2a930..5eeaca8ea9 100644 --- a/third-party-programs.txt +++ b/third-party-programs.txt @@ -42,3 +42,7 @@ terms are listed below. 7. CLIP neural network used for deep feature extraction in AI-VAD model Copyright (c) 2022 @openai, https://github.com/openai/CLIP. SPDX-License-Identifier: MIT + +8. AUPIMO metric implementation is based on the original code + Copyright (c) 2023 @jpcbertoldo, https://github.com/jpcbertoldo/aupimo + SPDX-License-Identifier: MIT diff --git a/tools/inference/gradio_inference.py b/tools/inference/gradio_inference.py index 36bc46f02e..89cf5f14ec 100644 --- a/tools/inference/gradio_inference.py +++ b/tools/inference/gradio_inference.py @@ -53,18 +53,17 @@ def get_inferencer(weight_path: Path, metadata: Path | None = None) -> Inference extension = weight_path.suffix inferencer: Inferencer module = import_module("anomalib.deploy") - if extension in (".pt", ".pth", ".ckpt"): + if extension in {".pt", ".pth", ".ckpt"}: torch_inferencer = module.TorchInferencer inferencer = torch_inferencer(path=weight_path) - elif extension in (".onnx", ".bin", ".xml"): + elif extension in {".onnx", ".bin", ".xml"}: if metadata is None: msg = "When using OpenVINO Inferencer, the following arguments are required: --metadata" raise ValueError(msg) openvino_inferencer = module.OpenVINOInferencer inferencer = openvino_inferencer(path=weight_path, metadata=metadata) - else: msg = ( "Model extension is not supported. " diff --git a/tools/tiled_ensemble/ens_config.yaml b/tools/tiled_ensemble/ens_config.yaml new file mode 100644 index 0000000000..2490b22e9a --- /dev/null +++ b/tools/tiled_ensemble/ens_config.yaml @@ -0,0 +1,43 @@ +seed: 42 +accelerator: "gpu" +default_root_dir: "results" + +tiling: + tile_size: [128, 128] + stride: 128 + +normalization_stage: image # on what level we normalize, options: [tile, image, none] +thresholding: + method: F1AdaptiveThreshold # refer to documentation for thresholding methods + stage: image # stage at which we apply threshold, options: [tile, image] + +data: + class_path: anomalib.data.MVTec + init_args: + root: ./datasets/MVTec + category: bottle + train_batch_size: 32 + eval_batch_size: 32 + num_workers: 8 + task: segmentation + transform: null + train_transform: null + eval_transform: null + test_split_mode: from_dir + test_split_ratio: 0.2 + val_split_mode: same_as_test + val_split_ratio: 0.5 + image_size: [256, 256] + +SeamSmoothing: + apply: True # if this is applied, area around tile seams are is smoothed + sigma: 2 # sigma of gaussian filter used to smooth this area + width: 0.1 # width factor, multiplied by tile dimension gives the region width around seam which will be smoothed + +TrainModels: + model: + class_path: Padim + + metrics: + pixel: AUROC + image: AUROC diff --git a/tools/tiled_ensemble/eval.py b/tools/tiled_ensemble/eval.py new file mode 100644 index 0000000000..58be27c25c --- /dev/null +++ b/tools/tiled_ensemble/eval.py @@ -0,0 +1,28 @@ +"""Run tiled ensemble prediction.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from pathlib import Path + +from jsonargparse import ArgumentParser + +from anomalib.pipelines.tiled_ensemble import EvalTiledEnsemble + + +def get_parser() -> ArgumentParser: + """Create a new parser if none is provided.""" + parser = ArgumentParser() + parser.add_argument("--config", type=str | Path, help="Configuration file path.", required=True) + parser.add_argument("--root", type=str | Path, help="Weights file path.", required=True) + + return parser + + +if __name__ == "__main__": + args = get_parser().parse_args() + + print("Running tiled ensemble test pipeline.") + # pass the path to root dir with checkpoints + test_pipeline = EvalTiledEnsemble(args.root) + test_pipeline.run(args) diff --git a/tools/tiled_ensemble/train.py b/tools/tiled_ensemble/train.py new file mode 100644 index 0000000000..8aed47ea0d --- /dev/null +++ b/tools/tiled_ensemble/train.py @@ -0,0 +1,17 @@ +"""Run tiled ensemble training.""" + +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from anomalib.pipelines.tiled_ensemble import EvalTiledEnsemble, TrainTiledEnsemble + +if __name__ == "__main__": + print("Running tiled ensemble train pipeline") + train_pipeline = TrainTiledEnsemble() + # run training + train_pipeline.run() + + print("Running tiled ensemble test pipeline.") + # pass the root dir from train run to load checkpoints + test_pipeline = EvalTiledEnsemble(train_pipeline.root_dir) + test_pipeline.run() diff --git a/tools/upgrade/config.py b/tools/upgrade/config.py index d03f21d752..71bf17a4b5 100644 --- a/tools/upgrade/config.py +++ b/tools/upgrade/config.py @@ -119,7 +119,7 @@ def __init__(self, config: str | Path | dict[str, Any]) -> None: @staticmethod def safe_load(path: str | Path) -> dict: """Load a yaml file and return the content as a dictionary.""" - with Path(path).open("r") as f: + with Path(path).open("r", encoding="utf-8") as f: return yaml.safe_load(f) def upgrade_data_config(self) -> dict[str, Any]: @@ -248,7 +248,8 @@ def add_seed_config(self) -> dict[str, Any]: """Create seed everything field in v1 config.""" return {"seed_everything": bool(self.old_config["project"]["seed"])} - def add_ckpt_path_config(self) -> dict[str, Any]: + @staticmethod + def add_ckpt_path_config() -> dict[str, Any]: """Create checkpoint path directory in v1 config.""" return {"ckpt_path": None} @@ -311,7 +312,7 @@ def save_config(config: dict, path: str | Path) -> None: Returns: None """ - with Path(path).open("w") as file: + with Path(path).open("w", encoding="utf-8") as file: yaml.safe_dump(config, file, sort_keys=False)